Microsoft/NT4
Microsoft/NT4
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
ce47f986d8
NT4/private/windows/media/avi/vidcap32/toolbar.c

1738 lines
54 KiB
C
Raw Normal View History

First commit
2001-01-01 00:00:00 +01:00
/**************************************************************************
*
* THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY
* KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR
* PURPOSE.
*
* Copyright (c) 1992 - 1995 Microsoft Corporation. All Rights Reserved.
*
**************************************************************************/
/****************************************************************************
*
* toolbar.c: Toolbar control window
*
* Vidcap32 Source code
*
***************************************************************************/
#include <string.h>
#include <windows.h>
#include <windowsx.h>
//#include <win32.h>
#include "toolbar.h" // use this for generic app
/************************************************************************/
/* work for win3.0 */
#ifndef COLOR_BTNHIGHLIGHT
#define COLOR_BTNHIGHLIGHT 20
#endif
char szToolBarClass[] = "ToolBarClass";
HBRUSH ghbrToolbar; // brush for toolbar background
//
// Window proc for buttons, THIS FUNCTION MUST BE EXPORTED
//
LONG FAR PASCAL toolbarWndProc(HWND, unsigned, UINT, LONG);
typedef long (FAR PASCAL *LPWNDPROC)();
/*
Defines
*/
#ifdef _WIN32
#define GETARRAYBUTT(hwnd) ((HANDLE)GetWindowLong(hwnd,GWL_ARRAYBUTT))
#define GETNUMBUTTONS(hwnd) ((int)GetWindowLong(hwnd,GWL_NUMBUTTONS))
#define GETPRESSED(hwnd) ((BOOL)GetWindowLong(hwnd,GWL_PRESSED))
#define GETKEYPRESSED(hwnd) ((BOOL)GetWindowLong(hwnd,GWL_KEYPRESSED))
#define GETWHICH(hwnd) ((int)GetWindowLong(hwnd,GWL_WHICH))
#define GETSHIFTED(hwnd) ((BOOL)GetWindowLong(hwnd,GWL_SHIFTED))
#define GETBMPHANDLE(hwnd) ((HANDLE)GetWindowLong(hwnd,GWL_BMPHANDLE))
#define GETBMPINT(hwnd) ((int)GetWindowLong(hwnd,GWL_BMPINT))
#define GETBUTTONSIZE(hwnd) GetWindowLong(hwnd,GWL_BUTTONSIZE)
#define GETHINST(hwnd) ((HANDLE)GetWindowLong(hwnd,GWL_HINST))
#define SETARRAYBUTT(hwnd, h) SetWindowLong(hwnd, GWL_ARRAYBUTT, (UINT)h)
#define SETNUMBUTTONS(hwnd, wNumButtons) \
SetWindowLong(hwnd, GWL_NUMBUTTONS, wNumButtons)
#define SETPRESSED(hwnd, f) SetWindowLong(hwnd, GWL_PRESSED, (UINT)f)
#define SETKEYPRESSED(hwnd, f) SetWindowLong(hwnd, GWL_KEYPRESSED, (UINT)f)
#define SETWHICH(hwnd, i) SetWindowLong(hwnd, GWL_WHICH, (UINT)i)
#define SETSHIFTED(hwnd, i) SetWindowLong(hwnd, GWL_SHIFTED, (UINT)i)
#define SETBMPHANDLE(hwnd, h) SetWindowLong(hwnd, GWL_BMPHANDLE, (UINT)h)
#define SETBMPINT(hwnd, i) SetWindowLong(hwnd, GWL_BMPINT, (UINT)i)
#define SETBUTTONSIZE(hwnd, l) SetWindowLong(hwnd, GWL_BUTTONSIZE, l)
#define SETHINST(hwnd, h) SetWindowLong(hwnd, GWL_HINST, (UINT)h)
#else
#define GETARRAYBUTT(hwnd) ((HANDLE)GetWindowWord(hwnd,GWW_ARRAYBUTT))
#define GETNUMBUTTONS(hwnd) ((int)GetWindowWord(hwnd,GWW_NUMBUTTONS))
#define GETPRESSED(hwnd) ((BOOL)GetWindowWord(hwnd,GWW_PRESSED))
#define GETKEYPRESSED(hwnd) ((BOOL)GetWindowWord(hwnd,GWW_KEYPRESSED))
#define GETWHICH(hwnd) ((int)GetWindowWord(hwnd,GWW_WHICH))
#define GETSHIFTED(hwnd) ((BOOL)GetWindowWord(hwnd,GWW_SHIFTED))
#define GETBMPHANDLE(hwnd) ((HANDLE)GetWindowWord(hwnd,GWW_BMPHANDLE))
#define GETBMPINT(hwnd) ((int)GetWindowWord(hwnd,GWW_BMPINT))
#define GETBUTTONSIZE(hwnd) GetWindowLong(hwnd,GWL_BUTTONSIZE)
#define GETHINST(hwnd) ((HANDLE)GetWindowWord(hwnd,GWW_HINST))
#define SETARRAYBUTT(hwnd, h) SetWindowWord(hwnd, GWW_ARRAYBUTT, (WORD)h)
#define SETNUMBUTTONS(hwnd, wNumButtons) \
SetWindowWord(hwnd, GWW_NUMBUTTONS, wNumButtons)
#define SETPRESSED(hwnd, f) SetWindowWord(hwnd, GWW_PRESSED, (WORD)f)
#define SETKEYPRESSED(hwnd, f) SetWindowWord(hwnd, GWW_KEYPRESSED, (WORD)f)
#define SETWHICH(hwnd, i) SetWindowWord(hwnd, GWW_WHICH, (WORD)i)
#define SETSHIFTED(hwnd, i) SetWindowWord(hwnd, GWW_SHIFTED, (WORD)i)
#define SETBMPHANDLE(hwnd, h) SetWindowWord(hwnd, GWW_BMPHANDLE, (WORD)h)
#define SETBMPINT(hwnd, i) SetWindowWord(hwnd, GWW_BMPINT, (WORD)i)
#define SETBUTTONSIZE(hwnd, l) SetWindowLong(hwnd, GWL_BUTTONSIZE, l)
#define SETHINST(hwnd, h) SetWindowWord(hwnd, GWW_HINST, (WORD)h)
#endif
#define lpCreate ((LPCREATESTRUCT)lParam)
/* Prototypes */
static void NEAR PASCAL NotifyParent(HWND, int);
/**************************************************************************
toolbarInit( hInst, hPrev )
Call this routine to initialize the toolbar code.
Arguments:
hPrev instance handle of previous instance
hInst instance handle of current instance
Returns:
TRUE if successful, FALSE if not
***************************************************************************/
BOOL FAR PASCAL toolbarInit(HANDLE hInst, HANDLE hPrev)
{
WNDCLASS cls;
/* Register the tool bar window class */
if (!hPrev) {
cls.hCursor = LoadCursor(NULL,IDC_ARROW);
cls.hIcon = NULL;
cls.lpszMenuName = NULL;
cls.lpszClassName = (LPSTR)szToolBarClass;
cls.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
cls.hInstance = hInst;
cls.style = CS_DBLCLKS;
cls.lpfnWndProc = toolbarWndProc;
cls.cbClsExtra = 0;
cls.cbWndExtra = TOOLBAR_EXTRABYTES;
if (!RegisterClass(&cls))
return FALSE;
}
return TRUE;
}
/***************************************************************************/
/* toolbarSetBitmap: takes a resource ID and associates that bitmap with */
/* a given toolbar. Also takes the instance handle and */
/* the size of the buttons on the toolbar. */
/***************************************************************************/
BOOL FAR PASCAL toolbarSetBitmap(HWND hwnd, HANDLE hInst, int ibmp, POINT ptSize)
{
SETHINST(hwnd, hInst);
SETBMPHANDLE(hwnd, NULL);
SETBMPINT(hwnd, ibmp);
SETBUTTONSIZE(hwnd, MAKELONG(ptSize.y, ptSize.x));
return (BOOL)SendMessage(hwnd, WM_SYSCOLORCHANGE, 0, 0L); // do the work
}
/***************************************************************************/
/* toolbarGetNumButtons: return the number of buttons registered on a */
/* given toolbar window. */
/***************************************************************************/
int FAR PASCAL toolbarGetNumButtons(HWND hwnd)
{
return GETNUMBUTTONS(hwnd);
}
/***************************************************************************/
/* toolbarButtonFromIndex: Given an index into the array of buttons on */
/* this toolbar, return which button is there. */
/* Returns -1 for an error code. */
/***************************************************************************/
int FAR PASCAL toolbarButtonFromIndex(HWND hwnd, int iBtnPos)
{
int iButton;
HANDLE h;
TOOLBUTTON far *lpaButtons;
/* Get the array of buttons on this toolbar */
h = GETARRAYBUTT(hwnd);
if (!h)
return -1;
/* Validate the index passed in */
if (iBtnPos > GETNUMBUTTONS(hwnd) || iBtnPos < 0)
return -1;
lpaButtons = (TOOLBUTTON far *)GlobalLock(h);
/* Read off the answer */
iButton = lpaButtons[iBtnPos].iButton;
GlobalUnlock(h);
return iButton;
}
/***************************************************************************/
/* toolbarIndexFromButton: Given a button ID, return the position in the */
/* array that it appears at. */
/* Returns -1 for an error code. */
/***************************************************************************/
int FAR PASCAL toolbarIndexFromButton(HWND hwnd, int iButton)
{
int i, iBtnPos = -1;
HANDLE h;
TOOLBUTTON far *lpButton;
/* Get the array of buttons */
h = GETARRAYBUTT(hwnd);
if (!h)
return -1;
lpButton = (TOOLBUTTON far *)GlobalLock(h);
/* loop through until you find it */
for(i = 0; i < GETNUMBUTTONS(hwnd); i++, lpButton++)
if (lpButton->iButton == iButton) {
iBtnPos = i;
break;
}
GlobalUnlock(h);
return iBtnPos;
}
/***************************************************************************/
/* toolbarPrevStateFromButton: Given a button ID, return the state that */
/* the button was in before it was pressed */
/* all the way down (for non-push buttons). */
/* Return -1 for an error code. */
/***************************************************************************/
int FAR PASCAL toolbarPrevStateFromButton(HWND hwnd, int iButton)
{
int i, iPrevState = -1;
HANDLE h;
TOOLBUTTON far *lpButton;
/* Get the array of buttons */
h = GETARRAYBUTT(hwnd);
if (!h)
return -1;
lpButton = (TOOLBUTTON far *)GlobalLock(h);
/* look for what we need */
for(i = 0; i < GETNUMBUTTONS(hwnd); i++, lpButton++)
if (lpButton->iButton == iButton) {
iPrevState = lpButton->iPrevState;
break;
}
GlobalUnlock(h);
return iPrevState;
}
/***************************************************************************/
/* toolbarActivityFromButton: Given a button ID, return the most recent */
/* activity that happened to it. (eg DBLCLK) */
/* Return -1 for an error code. */
/***************************************************************************/
int FAR PASCAL toolbarActivityFromButton(HWND hwnd, int iButton)
{
int i, iActivity = -1;
HANDLE h;
TOOLBUTTON far *lpButton;
/* Get the array of buttons */
h = GETARRAYBUTT(hwnd);
if (!h)
return -1;
lpButton = (TOOLBUTTON far *)GlobalLock(h);
/* loop through until you find it */
for(i = 0; i < GETNUMBUTTONS(hwnd); i++, lpButton++)
if (lpButton->iButton == iButton)
iActivity = lpButton->iActivity;
GlobalUnlock(h);
return iActivity;
}
/***************************************************************************/
/* toolbarIndexFromPoint: Given a point in the toolbar window, return the */
/* index of the button beneath that point. */
/* Return -1 for an error code. */
/***************************************************************************/
int FAR PASCAL toolbarIndexFromPoint(HWND hwnd, POINT pt)
{
int i, iBtnPos = -1;
HANDLE h;
TOOLBUTTON far *lpButton;
/* Get the array of buttons */
h = GETARRAYBUTT(hwnd);
if (!h)
return -1;
lpButton = (TOOLBUTTON far *)GlobalLock(h);
/* loop through until we find an intersection */
for(i = 0; i < GETNUMBUTTONS(hwnd); i++, lpButton++)
if (PtInRect(&lpButton->rc, pt)) {
iBtnPos = i;
break;
}
GlobalUnlock(h);
return iBtnPos;
}
/***************************************************************************/
/* toolbarRectFromIndex: Given an index into our array of buttons, return*/
/* the rect occupied by that button. */
/* Return a NULL rect for an error. */
/***************************************************************************/
BOOL FAR PASCAL toolbarRectFromIndex(HWND hwnd, int iBtnPos, LPRECT lprc)
{
HANDLE h;
TOOLBUTTON far *lpaButtons;
/* Get the array of buttons */
h = GETARRAYBUTT(hwnd);
if (!h)
return FALSE;
/* Validate the index passed in */
if (iBtnPos > GETNUMBUTTONS(hwnd) || iBtnPos < 0)
return FALSE;
lpaButtons = (TOOLBUTTON far *)GlobalLock(h);
/* Read off the rect */
*lprc = lpaButtons[iBtnPos].rc;
GlobalUnlock(h);
return TRUE;
}
/***************************************************************************/
/* toolbarFullStateFromButton: Given a button in our array of buttons, */
/* return the state of that button. */
/* (including the wierd state FULLDOWN). For */
/* just UP or DOWN or GRAYED, */
/* call toolbarStateFromButton. */
/* Return -1 for an error. */
/***************************************************************************/
int FAR PASCAL toolbarFullStateFromButton(HWND hwnd, int iButton)
{
int iState, iBtnPos;
HANDLE h;
TOOLBUTTON far *lpaButtons;
iBtnPos = toolbarIndexFromButton(hwnd, iButton);
if (iBtnPos == -1)
return -1;
/* Get the array of buttons */
h = GETARRAYBUTT(hwnd);
if (!h)
return -1;
lpaButtons = (TOOLBUTTON far *)GlobalLock(h);
/* Read off the state */
iState = lpaButtons[iBtnPos].iState;
GlobalUnlock(h);
return iState;
}
/***************************************************************************/
/* toolbarStateFromButton: This fn is called by the parent application */
/* to get the state of a button. It will only */
/* return DOWN, or UP or GRAYED as opposed to */
/* toolbarFullStateFromButton which could return */
/* FULLDOWN. */
/***************************************************************************/
int FAR PASCAL toolbarStateFromButton(HWND hwnd, int iButton)
{
int iState;
/* If a checkbox button is all the way down, it's previous state is */
/* the one we want. */
if ((iState = toolbarFullStateFromButton(hwnd, iButton))
== BTNST_FULLDOWN) {
iState = toolbarPrevStateFromButton(hwnd, iButton);
return iState;
} else
return iState;
}
/***************************************************************************/
/* toolbarStringFromIndex: Given an index into our array of buttons, return*/
/* the string resource associated with it. */
/* Return -1 for an error. */
/***************************************************************************/
int FAR PASCAL toolbarStringFromIndex(HWND hwnd, int iBtnPos)
{
int iString;
HANDLE h;
TOOLBUTTON far *lpaButtons;
/* Get the array of buttons */
h = GETARRAYBUTT(hwnd);
if (!h)
return -1;
/* Validate the index passed in */
if (iBtnPos > GETNUMBUTTONS(hwnd) || iBtnPos < 0)
return -1;
lpaButtons = (TOOLBUTTON far *)GlobalLock(h);
/* Read off the ID */
iString = lpaButtons[iBtnPos].iString;
GlobalUnlock(h);
return iString;
}
/***************************************************************************/
/* toolbarTypeFromIndex: Given an index into our array of buttons, return*/
/* the type of button it is (PUSH, RADIO, etc.) */
/* Return -1 for an error. */
/***************************************************************************/
int FAR PASCAL toolbarTypeFromIndex(HWND hwnd, int iBtnPos)
{
int iType;
HANDLE h;
TOOLBUTTON far *lpaButtons;
/* Get the Array of buttons */
h = GETARRAYBUTT(hwnd);
if (!h)
return -1;
/* Validate the index passed in */
if (iBtnPos > GETNUMBUTTONS(hwnd) || iBtnPos < 0)
return -1;
lpaButtons = (TOOLBUTTON far *)GlobalLock(h);
/* Read off the type */
iType = lpaButtons[iBtnPos].iType;
GlobalUnlock(h);
return iType;
}
/***************************************************************************/
/* toolbarAddTool: Add a button to this toolbar. Sort them by leftmost */
/* position in the window (for tabbing order). */
/* Return FALSE for an error. */
/***************************************************************************/
BOOL FAR PASCAL toolbarAddTool(HWND hwnd, TOOLBUTTON tb)
{
HANDLE h;
TOOLBUTTON far *lpaButtons;
int cButtons, i, j;
BOOL fInsert = FALSE;
/* We better not have this button on the toolbar already */
if (toolbarIndexFromButton(hwnd, tb.iButton) != -1)
return FALSE;
/* Get the array of buttons */
h = GETARRAYBUTT(hwnd);
if (!h)
return FALSE;
/* How many buttons are there already? */
cButtons = GETNUMBUTTONS(hwnd);
/* If we have filled our alloced memory for this array already, we */
/* need to re-alloc some more memory */
if ( ((cButtons & (TOOLGROW - 1)) == 0) && (cButtons > 0) ) {
/* Re-alloc it bigger */
h = GlobalReAlloc(h,
GlobalSize(h) + TOOLGROW * sizeof(TOOLBUTTON),
GMEM_MOVEABLE | GMEM_SHARE);
if (!h)
return FALSE;
}
lpaButtons = (TOOLBUTTON far *)GlobalLock(h);
/* Look for the spot we need to insert this new guy at. */
/* Remember, we sort by left x position breaking ties */
/* with top y position. */
for (i = 0; i < cButtons; i++) {
// Here it goes
if (lpaButtons[i].rc.left > tb.rc.left ||
(lpaButtons[i].rc.left == tb.rc.left &&
lpaButtons[i].rc.top > tb.rc.top)) {
fInsert = TRUE;
/* Open up a spot in the array */
for (j = cButtons; j > i; j--)
lpaButtons[j] = lpaButtons[j-1];
/* Add our new guy */
lpaButtons[i] = tb; // redraw now
InvalidateRect(hwnd, &(lpaButtons[i].rc), FALSE);
break;
}
}
/* If our loop didn't insert it, we need to add it to the end */
if (!fInsert)
lpaButtons[i] = tb;
/* If we are told that this button has the focus, we better */
/* change the focus to it. Then use the normal state. */
if (tb.iState == BTNST_FOCUSUP) {
tb.iState = BTNST_UP;
SETWHICH(hwnd, i);
} else if (tb.iState == BTNST_FOCUSDOWN || tb.iState == BTNST_FULLDOWN){
tb.iState = BTNST_DOWN; // nonsense to init to FULLDOWN
SETWHICH(hwnd, i);
}
cButtons++; // one more button now.
GlobalUnlock(h);
SETNUMBUTTONS(hwnd, cButtons); // new count
SETARRAYBUTT(hwnd, h); // re-alloc might have changed it
/* Just in case no one else makes this new button draw */
InvalidateRect(hwnd, &(tb.rc), FALSE);
return TRUE;
}
/***************************************************************************/
/* toolbarRetrieveTool: Get the TOOLBUTTON struct for the given button. */
/* Return FALSE for an error. */
/***************************************************************************/
BOOL FAR PASCAL toolbarRetrieveTool(HWND hwnd, int iButton, LPTOOLBUTTON lptb)
{
int i;
HANDLE h;
TOOLBUTTON far *lpButton;
BOOL fFound = FALSE;
/* Get the array of buttons */
h = GETARRAYBUTT(hwnd);
if (!h)
return FALSE;
lpButton = (TOOLBUTTON far *)GlobalLock(h);
/* look for what we need */
for(i = 0; i < GETNUMBUTTONS(hwnd); i++, lpButton++)
if (lpButton->iButton == iButton) {
*lptb = *lpButton;
fFound = TRUE;
break;
}
GlobalUnlock(h);
return fFound;
}
/***************************************************************************/
/* toolbarRemoveTool: Remove this button ID from our array of buttons on */
/* the toolbar. (only 1 of each button ID allowed). */
/* Return FALSE for an error. */
/***************************************************************************/
BOOL FAR PASCAL toolbarRemoveTool(HWND hwnd, int iButton)
{
HANDLE h;
TOOLBUTTON far *lpaButtons;
int cButtons, i, j;
BOOL fFound = FALSE;
/* Get the array of buttons */
h = GETARRAYBUTT(hwnd);
if (!h)
return FALSE;
/* How many buttons are on there now? */
cButtons = GETNUMBUTTONS(hwnd);
lpaButtons = (TOOLBUTTON far *)GlobalLock(h);
/* Find a match, remove it, and close the array around it. */
for (i = 0; i < cButtons; i++)
if (lpaButtons[i].iButton == iButton) {
fFound = TRUE;
// redraw now
InvalidateRect(hwnd, &(lpaButtons[i].rc), FALSE);
if (i != cButtons - 1) // Last button? Don't bother!
for (j = i; j < cButtons; j++)
lpaButtons[j] = lpaButtons[j + 1];
break;
}
GlobalUnlock(h);
/* Didn't find it! */
if (!fFound)
return FALSE;
/* One less button */
cButtons--;
/* Every once in a while, re-alloc a smaller array chunk to */
/* save memory. */
if ( ((cButtons & (TOOLGROW - 1)) == 0) && (cButtons > 0) ) {
/* Re-alloc it smaller */
h = GlobalReAlloc(h,
GlobalSize(h) - TOOLGROW * sizeof(TOOLBUTTON),
GMEM_MOVEABLE | GMEM_SHARE);
if (!h)
return FALSE;
}
SETNUMBUTTONS(hwnd, cButtons); // new count
SETARRAYBUTT(hwnd, h); // re-alloc could have changed it
return TRUE;
}
/***************************************************************************/
/* toolbarModifyString: Given a button ID on the toolbar, change it's */
/* string resource associated with it. */
/* returns FALSE for an error or if no such button */
/***************************************************************************/
BOOL FAR PASCAL toolbarModifyString(HWND hwnd, int iButton, int iString)
{
HANDLE h;
TOOLBUTTON far *lpButton;
int cButtons, i;
BOOL fFound = FALSE;
/* Get the array of buttons */
h = GETARRAYBUTT(hwnd);
if (!h)
return FALSE;
/* How many buttons? */
cButtons = GETNUMBUTTONS(hwnd);
lpButton = (TOOLBUTTON far *)GlobalLock(h);
/* Find that button, and change it's state */
for (i = 0; i < cButtons; i++, lpButton++)
if (lpButton->iButton == iButton) {
lpButton->iString = iString;
fFound = TRUE; // redraw now
break;
}
GlobalUnlock(h);
return fFound;
}
/***************************************************************************/
/* toolbarModifyState: Given a button ID on the toolbar, change it's */
/* state. */
/* returns FALSE for an error or if no such button */
/***************************************************************************/
BOOL FAR PASCAL toolbarModifyState(HWND hwnd, int iButton, int iState)
{
HANDLE h;
TOOLBUTTON far *lpButton;
int cButtons, i;
BOOL fFound = FALSE;
/* Get the array of buttons */
h = GETARRAYBUTT(hwnd);
if (!h)
return FALSE;
/* How many buttons? */
cButtons = GETNUMBUTTONS(hwnd);
lpButton = (TOOLBUTTON far *)GlobalLock(h);
/* Find that button, and change it's state */
for (i = 0; i < cButtons; i++, lpButton++)
if (lpButton->iButton == iButton) {
if (lpButton->iState != iState) {
lpButton->iState = iState;
InvalidateRect(hwnd, &(lpButton->rc), FALSE);
}
fFound = TRUE; // redraw now
/* if we're pushing a radio button down, bring */
/* all others in its group up */
if (lpButton->iType >= BTNTYPE_RADIO &&
iState == BTNST_DOWN)
toolbarExclusiveRadio(hwnd, lpButton->iType,
iButton);
break;
}
GlobalUnlock(h);
return fFound;
}
/***************************************************************************/
/* toolbarModifyPrevState: Given a button on the toolbar, change it's prev-*/
/* ious state. Used for non-PUSH buttons to remember */
/* what state a button was in before pressed all the */
/* way down, so that when you let go, you know what */
/* state to set it to (the opposite of what it was). */
/* returns FALSE for an error (no button array) */
/***************************************************************************/
BOOL FAR PASCAL toolbarModifyPrevState(HWND hwnd, int iButton, int iPrevState)
{
HANDLE h;
TOOLBUTTON far *lpButton;
int cButtons, i;
/* Get button array */
h = GETARRAYBUTT(hwnd);
if (!h)
return FALSE;
/* How many buttons? */
cButtons = GETNUMBUTTONS(hwnd);
lpButton = (TOOLBUTTON far *)GlobalLock(h);
/* Find the button, change the state */
for (i = 0; i < cButtons; i++, lpButton++)
if (lpButton->iButton == iButton) {
lpButton->iPrevState = iPrevState;
break;
}
GlobalUnlock(h);
return TRUE;
}
/***************************************************************************/
/* toolbarModifyActivity: Given a button ID on the toolbar, change it's */
/* activity. This tells the app what just happened */
/* to the button (ie. KEYUP, MOUSEDBLCLK, etc.) */
/* returns FALSE for an error or if no such button */
/***************************************************************************/
BOOL FAR PASCAL toolbarModifyActivity(HWND hwnd, int iButton, int iActivity)
{
HANDLE h;
TOOLBUTTON far *lpButton;
int cButtons, i;
/* Get the button array */
h = GETARRAYBUTT(hwnd);
if (!h)
return FALSE;
/* How many buttons */
cButtons = GETNUMBUTTONS(hwnd);
lpButton = (TOOLBUTTON far *)GlobalLock(h);
/* loop through and change the right one */
for (i = 0; i < cButtons; i++, lpButton++)
if (lpButton->iButton == iButton) {
lpButton->iActivity = iActivity;
break;
}
GlobalUnlock(h);
return TRUE;
}
/***************************************************************************/
/* toolbarFixFocus: SETWHICH() has been called to tell us which button */
/* has the focus, but the states of all the buttons are */
/* not updated (ie. take focus away from the old button) */
/* This routine is called from the Paint routine to fix */
/* the states of all the buttons before drawing them. */
/* Returns FALSE for an error. */
/***************************************************************************/
BOOL FAR PASCAL toolbarFixFocus(HWND hwnd)
{
int iFocus;
HANDLE h;
TOOLBUTTON far *lpaButtons;
/* Get the array of buttons */
h = GETARRAYBUTT(hwnd);
if (!h)
return FALSE;
lpaButtons = (TOOLBUTTON far *)GlobalLock(h);
/* if focus is on an illegal button, default to the first one */
iFocus = GETWHICH(hwnd);
if (iFocus < 0 || iFocus >= GETNUMBUTTONS(hwnd))
SETWHICH(hwnd, 0);
/* First of all, make sure that the focus in not on a grayed button. */
/* if so, we advance focus. If it runs out of buttons without */
/* finding a non-gray one, we start back at the beginning and start */
/* looking for a non-gray one from there. If every button is grayed,*/
/* we leave no focus anywhere. */
if (lpaButtons[GETWHICH(hwnd)].iState == BTNST_GRAYED) {
if (!toolbarMoveFocus(hwnd, FALSE)) {
SETWHICH(hwnd, -1);
toolbarMoveFocus(hwnd, FALSE);
}
}
GlobalUnlock(h);
return TRUE;
}
/***************************************************************************/
/* toolbarExclusiveRadio: For radio buttons, we need to pop all others */
/* in the group up when one goes down. Pass the */
/* button that is going down, and its group, and */
/* this routine will pop all others up. */
/* Returns FALSE for an error. */
/***************************************************************************/
BOOL FAR PASCAL toolbarExclusiveRadio(HWND hwnd, int iType, int iButton)
{
int i;
HANDLE h;
TOOLBUTTON far *lpButton;
/* Get the array of buttons */
h = GETARRAYBUTT(hwnd);
if (!h)
return FALSE;
lpButton = (TOOLBUTTON far *)GlobalLock(h);
/* all buttons with this type that aren't this button come up */
/* if they are not grayed */
for(i = 0; i < GETNUMBUTTONS(hwnd); i++, lpButton++)
if (lpButton->iType == iType)
if (lpButton->iButton != iButton &&
lpButton->iState != BTNST_GRAYED) {
toolbarModifyState(hwnd, lpButton->iButton, BTNST_UP);
}
GlobalUnlock(h);
return TRUE;
}
/* NotifyParent() of activity to a button */
static void NEAR PASCAL NotifyParent(HWND hwnd, int iButton)
{
#ifdef _WIN32
PostMessage(
GetParent(hwnd),
WM_COMMAND,
GET_WM_COMMAND_MPS(GetWindowLong(hwnd, GWL_ID), hwnd, iButton));
#else
PostMessage(GetParent(hwnd),WM_COMMAND,
GetWindowWord(hwnd,GWW_ID),MAKELONG(hwnd,iButton));
#endif
}
/***************************************************************************/
/* toolbarPaintControl: Handles paint messages by blitting each bitmap */
/* that is on the toolbar to its rect. */
/* First, it fixes the states of the buttons to give */
/* the focus to the proper button. */
/* Returns FALSE for an error. */
/***************************************************************************/
static BOOL NEAR PASCAL toolbarPaintControl(HWND hwnd, HDC hdc)
{
int iBtnPos; /* 0 to toolbarGetNumButtons inclusive */
int iButton; /* 0 to NUMBUTTONS-1 inclusive */
int iState; /* 0 to NUMSTATES-1 inclusive */
HDC hdcBtn; /* DC onto button bitmap */
RECT rcDest;
POINT pt;
long l;
HANDLE hbm;
/* Make a source HDC for the button pictures, and select the button */
/* bitmap into it. */
hdcBtn = CreateCompatibleDC(hdc);
if (!hdcBtn)
return FALSE;
hbm = GETBMPHANDLE(hwnd);
if (hbm) {
if (!SelectObject(hdcBtn, GETBMPHANDLE(hwnd))) {
DeleteDC(hdcBtn);
return FALSE;
}
}
toolbarFixFocus(hwnd); // set the focus field correctly
/* Go through all buttons on the toolbar */
for (iBtnPos = 0; iBtnPos < toolbarGetNumButtons(hwnd); iBtnPos++) {
iButton = toolbarButtonFromIndex(hwnd, iBtnPos); // button
iState = toolbarFullStateFromButton(hwnd, iButton); // state
toolbarRectFromIndex(hwnd, iBtnPos, &rcDest); // Dest Rect
/* If we have the focus, we should draw it that way */
if (GetFocus() == hwnd && GETWHICH(hwnd) == iBtnPos
&& iState == BTNST_UP)
iState = BTNST_FOCUSUP;
if (GetFocus() == hwnd && GETWHICH(hwnd) == iBtnPos
&& iState == BTNST_DOWN)
iState = BTNST_FOCUSDOWN;
/* If we don't have the focus, we should take it away */
if ((GetFocus() != hwnd || GETWHICH(hwnd) != iBtnPos)
&& iState == BTNST_FOCUSUP)
iState = BTNST_UP;
if ((GetFocus() != hwnd || GETWHICH(hwnd) == iBtnPos)
&& iState == BTNST_FOCUSDOWN)
iState = BTNST_DOWN;
/* The size of each button */
l = GETBUTTONSIZE(hwnd);
pt.x = HIWORD(l);
pt.y = LOWORD(l);
/* Blit from the button picture to the toolbar window */
BitBlt(hdc, rcDest.left, rcDest.top,
rcDest.right - rcDest.left, rcDest.bottom - rcDest.top,
hdcBtn, pt.x * iButton, pt.y * iState,
SRCCOPY);
}
DeleteDC(hdcBtn);
return TRUE;
}
/***************************************************************************/
/* toolbarMoveFocus: Move Focus forward or backward one button. You give */
/* it the direction to move the focus. The routine will*/
/* stop at the end of the button list without wrapping */
/* around. */
/* Returns TRUE if focus moved, or FALSE if it ran out */
/* of buttons before finding a non-grayed one. */
/***************************************************************************/
BOOL FAR PASCAL toolbarMoveFocus(HWND hwnd, BOOL fBackward)
{
int iBtnPos, iButton, nOffset, nStopAt;
RECT rc;
int iPrevPos = GETWHICH(hwnd); /* Who used to have focus? */
/* Fix illegal value. It's OK to be one less or greater than range */
if (iPrevPos < -1 || iPrevPos > GETNUMBUTTONS(hwnd))
SETWHICH(hwnd, 0); // good a default as any
if (fBackward) {
nOffset = -1;
nStopAt = -1;
} else {
nOffset = 1;
nStopAt = GETNUMBUTTONS(hwnd);
}
/* look for next button that isn't grayed */
/* DON'T wrap around - future code will pass */
/* the focus to another window (???) */
for (iBtnPos = GETWHICH(hwnd) + nOffset;
iBtnPos != nStopAt;
iBtnPos += nOffset) {
iButton = toolbarButtonFromIndex(hwnd, iBtnPos);
if (toolbarStateFromButton(hwnd, iButton) !=
BTNST_GRAYED) {
SETWHICH(hwnd, iBtnPos); // set focus
/* Redraw both old and new focused button */
toolbarRectFromIndex(hwnd, iPrevPos, &rc);
InvalidateRect(hwnd, &rc, FALSE);
toolbarRectFromIndex(hwnd, iBtnPos, &rc);
InvalidateRect(hwnd, &rc, FALSE);
break;
}
}
if (GETWHICH(hwnd) != iPrevPos)
return TRUE;
else
return FALSE;
}
/***************************************************************************/
/* toolbarSetFocus : Set the focus in the toolbar to the specified button.*/
/* If it's gray, it'll set focus to next ungrayed btn. */
/* Returns TRUE if focus set, or FALSE if the button */
/* doesn't exist or if it and all buttons after it were */
/* grayed... You can use TB_FIRST or TB_LAST in */
/* place of a button ID. This uses the first or last */
/* un-grayed button. */
/***************************************************************************/
BOOL FAR PASCAL toolbarSetFocus(HWND hwnd, int iButton)
{
int iBtnPos;
RECT rc;
/* Don't move focus while a button is down */
if (GetCapture() != hwnd && !GETKEYPRESSED(hwnd)) {
/* redraw button with focus in case focus moves */
toolbarRectFromIndex(hwnd, GETWHICH(hwnd), &rc);
InvalidateRect(hwnd, &rc, FALSE);
if (iButton == TB_FIRST) {
SETWHICH(hwnd, -1); // move forward to 1st button
return toolbarMoveFocus(hwnd, FALSE);
} else if (iButton == TB_LAST) {
SETWHICH(hwnd, GETNUMBUTTONS(hwnd));
return toolbarMoveFocus(hwnd, TRUE);
} else {
iBtnPos = toolbarIndexFromButton(hwnd, iButton);
if (iBtnPos != -1) {
SETWHICH(hwnd, --iBtnPos);
return toolbarMoveFocus(hwnd, FALSE);
} else
return FALSE;
}
return TRUE;
} else
return FALSE;
}
//
// LoadUIBitmap() - load a bitmap resource
//
// load a bitmap resource from a resource file, converting all
// the standard UI colors to the current user specifed ones.
//
// this code is designed to load bitmaps used in "gray ui" or
// "toolbar" code.
//
// the bitmap must be a 4bpp windows 3.0 DIB, with the standard
// VGA 16 colors.
//
// the bitmap must be authored with the following colors
//
// Button Text Black (index 0)
// Button Face lt gray (index 7)
// Button Shadow gray (index 8)
// Button Highlight white (index 15)
// Window Color yellow (index 11)
// Window Frame green (index 10)
//
// Example:
//
// hbm = LoadUIBitmap(hInstance, "TestBmp",
// GetSysColor(COLOR_BTNTEXT),
// GetSysColor(COLOR_BTNFACE),
// GetSysColor(COLOR_BTNSHADOW),
// GetSysColor(COLOR_BTNHIGHLIGHT),
// GetSysColor(COLOR_WINDOW),
// GetSysColor(COLOR_WINDOWFRAME));
//
// Author: JimBov, ToddLa
//
//
HBITMAP FAR PASCAL LoadUIBitmap(
HANDLE hInstance, // EXE file to load resource from
LPCSTR szName, // name of bitmap resource
COLORREF rgbText, // color to use for "Button Text"
COLORREF rgbFace, // color to use for "Button Face"
COLORREF rgbShadow, // color to use for "Button Shadow"
COLORREF rgbHighlight, // color to use for "Button Hilight"
COLORREF rgbWindow, // color to use for "Window Color"
COLORREF rgbFrame) // color to use for "Window Frame"
{
LPBYTE lpb;
HBITMAP hbm;
LPBITMAPINFOHEADER lpbi;
HANDLE h;
HDC hdc;
LPDWORD lprgb;
int isize;
HANDLE hmem;
LPBYTE lpCopy;
// convert a RGB into a RGBQ
#define RGBQ(dw) RGB(GetBValue(dw),GetGValue(dw),GetRValue(dw))
h = LoadResource (hInstance,FindResource(hInstance, szName, RT_BITMAP));
lpbi = (LPBITMAPINFOHEADER)LockResource(h);
if (!lpbi)
return(NULL);
if (lpbi->biSize != sizeof(BITMAPINFOHEADER))
return NULL;
if (lpbi->biBitCount != 4)
return NULL;
/*
* copy the resource since they are now loaded read-only
*/
#ifdef _WIN32
isize = lpbi->biSize + lpbi->biSizeImage +
((int)lpbi->biClrUsed ?
(int)lpbi->biClrUsed :
(1 << (int)lpbi->biBitCount))
* sizeof(RGBQUAD);
hmem = GlobalAlloc(GHND, isize);
lpCopy = GlobalLock(hmem);
if ((hmem == NULL) || (lpCopy == NULL)) {
UnlockResource(h);
FreeResource(h);
return(NULL);
}
CopyMemory(lpCopy, lpbi, isize);
UnlockResource(h);
FreeResource(h);
lpbi = (LPBITMAPINFOHEADER)lpCopy;
#endif
/* Calcluate the pointer to the Bits information */
/* First skip over the header structure */
lprgb = (LPDWORD)((LPBYTE)(lpbi) + lpbi->biSize);
/* Skip the color table entries, if any */
lpb = (LPBYTE)lprgb + ((int)lpbi->biClrUsed ? (int)lpbi->biClrUsed :
(1 << (int)lpbi->biBitCount)) * sizeof(RGBQUAD);
lprgb[0] = RGBQ(rgbText); // Black
lprgb[7] = RGBQ(rgbFace); // lt gray
lprgb[8] = RGBQ(rgbShadow); // gray
lprgb[15] = RGBQ(rgbHighlight); // white
lprgb[11] = RGBQ(rgbWindow); // yellow
lprgb[10] = RGBQ(rgbFrame); // green
hdc = GetDC(NULL);
hbm = CreateDIBitmap (hdc, lpbi, CBM_INIT, (LPVOID)lpb,
(LPBITMAPINFO)lpbi, DIB_RGB_COLORS);
ReleaseDC(NULL, hdc);
UnlockResource(h);
FreeResource(h);
return(hbm);
}
/****************************************************************************
toolbarWndProc()
Window proc for toolbar.
Arguments:
Standard window proc
****************************************************************************/
LONG FAR PASCAL toolbarWndProc(HWND hwnd, unsigned message,
UINT wParam, LONG lParam)
{
PAINTSTRUCT ps;
POINT pt;
RECT rc;
int iBtnPos, iButton, ibmp;
HANDLE lpaButtons, hbm, hInst;
switch (message) {
case WM_CREATE: // do all initialization
/* What do these do? */
SetWindowPos(hwnd, NULL, 0, 0, 0, 0,
SWP_NOZORDER | SWP_NOSIZE |
SWP_NOMOVE | SWP_NOACTIVATE);
SetWindowLong(hwnd,GWL_STYLE,lpCreate->style & 0xFFFF00FF);
/* Alloc some space for the array of buttons on this bar */
lpaButtons = GlobalAlloc(GMEM_MOVEABLE | GMEM_SHARE,
TOOLGROW * sizeof(TOOLBUTTON));
SETARRAYBUTT(hwnd, lpaButtons); // list of buttons on toolbar
SETNUMBUTTONS(hwnd, 0); // # buttons in toolbar
SETPRESSED(hwnd, FALSE); // mouse button being pressed?
SETKEYPRESSED(hwnd, FALSE); // is a key being pressed?
SETWHICH(hwnd, -1); // which button has the focus?
SETSHIFTED(hwnd, FALSE); // shift-click or right-click?
/* This wParam will be sent to the parent window to indentify */
/* that the toolbar sent the WM_COMMAND msg. The hwnd of the */
/* toolbar that sent the msg will be in the lParam. */
#ifdef _WIN32
SetWindowLong(hwnd, GWL_ID, IDC_TOOLBAR);
#else
SetWindowWord(hwnd, GWW_ID, (WORD)IDC_TOOLBAR);
#endif
/* later on, someone will set the bmp handle of the buttons */
SETBMPHANDLE(hwnd, NULL);
break;
case WM_LBUTTONDOWN: // button goes down on a toolbar button
case WM_RBUTTONDOWN:
case WM_LBUTTONDBLCLK:
case WM_RBUTTONDBLCLK:
/* If we don't give ourself focus, we'll never get KEYDOWN */
/* or KEYUP messages. */
/* Get the focus only if we're a TABSTOP and the app wants */
/* us to take focus. */
if ( (GetWindowLong(hwnd, GWL_STYLE) & WS_TABSTOP)
&& GetFocus() != hwnd)
SetFocus(hwnd);
/* ignore messages if window is disabled */
if (!IsWindowEnabled(hwnd))
return 0L;
/* ignore multiple down messages (we set Capture here) */
/* also ignore if a key is down */
if (GetCapture() == hwnd || GETPRESSED(hwnd))
return 0L;
/* Where did the mouse go down? */
pt.x = (short)LOWORD(lParam);
pt.y = (short)HIWORD(lParam);
/* which button was pressed? */
iBtnPos = toolbarIndexFromPoint(hwnd, pt);
/* If it was a valid button... */
if (iBtnPos >= 0) {
int iOldPos;
int iState, iType, iButton;
/* Everything you wanted to know about this button */
iType = toolbarTypeFromIndex(hwnd, iBtnPos);
iButton = toolbarButtonFromIndex(hwnd, iBtnPos);
iState = toolbarFullStateFromButton(hwnd, iButton);
/* ignore downs on a grayed button, unless it's a */
/* custom button, then tell them anyway */
if (iType != BTNTYPE_CUSTOM && iState == BTNST_GRAYED)
return 0;
/* We better get all mouse messages from now on */
SetCapture(hwnd);
/* Shift key or right button indicates a SHIFT down */
SETSHIFTED(hwnd, (message == WM_RBUTTONDOWN) ||
(wParam & MK_SHIFT));
/* Yes, we've pressed the button down */
SETPRESSED(hwnd, TRUE);
/* Remember who used to have the focus, and we get it now */
iOldPos = GETWHICH(hwnd);
SETWHICH(hwnd, iBtnPos);
/* For a push button, send it down */
if (iType == BTNTYPE_PUSH)
toolbarModifyState(hwnd, iButton, BTNST_DOWN);
/* for a checkbox or radio button (of any group), */
/* remember what state it was in, and send it FULL down */
/* (with focus). */
if (iType == BTNTYPE_CHECKBOX || iType >= BTNTYPE_RADIO) {
toolbarModifyPrevState(hwnd, iButton, iState);
toolbarModifyState(hwnd,iButton,BTNST_FULLDOWN);
}
toolbarModifyActivity(hwnd, iButton, BTNACT_MOUSEDOWN);
/* Set Double click flag appropriately */
if (message == WM_LBUTTONDBLCLK ||
message == WM_RBUTTONDBLCLK)
NotifyParent(hwnd, (GETSHIFTED(hwnd) ? BTN_SHIFT : 0)
+ BTN_DBLCLICK + iButton);
else
NotifyParent(hwnd, (GETSHIFTED(hwnd) ? BTN_SHIFT : 0)
+ iButton);
/* Invalidate the Rect of the button being pressed */
toolbarRectFromIndex(hwnd, iBtnPos, &rc);
InvalidateRect(hwnd, &rc, FALSE);
/* Invalidate the Rect of the button losing focus */
toolbarRectFromIndex(hwnd, iOldPos, &rc);
InvalidateRect(hwnd, &rc, FALSE);
/* Force re-paint now */
UpdateWindow(hwnd);
/* Set a timer for repeated mouse downs */
SetTimer(hwnd, TIMER_BUTTONREPEAT,
MSEC_BUTTONREPEAT, NULL);
}
return 0L;
case WM_MOUSEMOVE:
#if 0
/* This should be impossible - it means that the system lost */
/* a mouse up (maybe codeview is up?) We need to force a */
/* mouse up at this point. */
if (GetCapture() == hwnd &&
(wParam & (MK_LBUTTON | MK_RBUTTON) == 0))
SendMessage(hwnd, WM_LBUTTONUP, 0, lParam);
#endif
/* Mouse moving while pressing a button? If not, ignore. */
if (GetCapture() == hwnd) {
int iPrevState, iState, iButton, iType;
BOOL fPressed;
/* Which button is being pressed down? */
iBtnPos = GETWHICH(hwnd);
/* Where is mouse cursor now? */
pt.x = (short)LOWORD(lParam);
pt.y = (short)HIWORD(lParam);
/* where is button being pressed? Are we still on */
/* top of that button or have we moved? */
toolbarRectFromIndex(hwnd, iBtnPos, &rc);
fPressed = PtInRect(&rc, pt);
/* Let go if we move off of the button, but don't */
/* act like it was pressed. */
/* Also, push it back down if we move back on top */
/* of it (while the mouse button is STILL down). */
if (fPressed != GETPRESSED(hwnd)) {
/* update: is this button pressed anymore? */
SETPRESSED(hwnd, fPressed);
iType = toolbarTypeFromIndex(hwnd, iBtnPos);
iButton = toolbarButtonFromIndex(hwnd, iBtnPos);
iState = toolbarFullStateFromButton(hwnd, iButton);
/* The mouse moved back onto the button while */
/* the mouse button was still pressed. */
if (fPressed) {
/* Push the push button back down again */
if (iType == BTNTYPE_PUSH)
toolbarModifyState(hwnd, iButton,
BTNST_DOWN);
/* Push the radio or checkbox button ALL the */
/* way down again. */
if (iType >= BTNTYPE_RADIO ||
iType == BTNTYPE_CHECKBOX)
toolbarModifyState(hwnd, iButton,
BTNST_FULLDOWN);
toolbarModifyActivity(hwnd, iButton,
BTNACT_MOUSEMOVEON);
NotifyParent(hwnd,
(GETSHIFTED(hwnd) ? BTN_SHIFT : 0) +
iButton);
/* We moved the mouse off of the toolbar button */
/* while still holding the mouse button down. */
} else {
/* lift the push button up */
if (iType == BTNTYPE_PUSH)
toolbarModifyState(hwnd, iButton,
BTNST_UP);
/* Restore radio button or checkbox button to */
/* where it was before pressed */
if (iType >= BTNTYPE_RADIO ||
iType == BTNTYPE_CHECKBOX) {
iPrevState = toolbarPrevStateFromButton(hwnd,
iButton);
toolbarModifyState(hwnd, iButton, iPrevState);
}
toolbarModifyActivity(hwnd, iButton,
BTNACT_MOUSEMOVEOFF);
NotifyParent(hwnd,
(GETSHIFTED(hwnd) ? BTN_SHIFT : 0) +
toolbarButtonFromIndex(hwnd, iBtnPos));
}
}
}
return 0L;
case WM_LBUTTONUP:
case WM_RBUTTONUP:
/* If we don't have capture, we aren't expecting this. Ignore */
if (GetCapture() == hwnd) {
int iPrevState, iState, iButton, iType;
/* Who has the focus? */
iBtnPos = GETWHICH(hwnd);
/* Release the mouse */
ReleaseCapture();
/* No more repeats of the mouse button downs */
KillTimer(hwnd, TIMER_BUTTONREPEAT);
/* Everything you wanted to know about the button */
toolbarRectFromIndex(hwnd, iBtnPos, &rc);
iType = toolbarTypeFromIndex(hwnd, iBtnPos);
iButton = toolbarButtonFromIndex(hwnd, iBtnPos);
iState = toolbarFullStateFromButton(hwnd, iButton);
/* Don't do anything if we've moved off the button */
if (GETPRESSED(hwnd)) {
/* No longer down */
SETPRESSED(hwnd, FALSE);
/* Bring the push button up */
if (iType == BTNTYPE_PUSH)
toolbarModifyState(hwnd, iButton, BTNST_UP);
/* Bring the checkbox to the opposite state it was in */
if (iType == BTNTYPE_CHECKBOX) {
iPrevState = toolbarPrevStateFromButton(hwnd,
iButton);
if (iPrevState == BTNST_DOWN)
toolbarModifyState(hwnd, iButton, BTNST_UP);
if (iPrevState == BTNST_UP)
toolbarModifyState(hwnd, iButton, BTNST_DOWN);
}
/* Force a radio button down, and bring all */
/* other radio buttons of this type up */
if (iType >= BTNTYPE_RADIO) {
toolbarModifyState(hwnd, iButton, BTNST_DOWN);
toolbarExclusiveRadio(hwnd, iType, iButton);
}
/* Notify the parent that the mouse button came up */
/* on this button so the app can do something. */
/* Every button should notify the app, not just a */
/* custom button. */
toolbarModifyActivity(hwnd, iButton, BTNACT_MOUSEUP);
NotifyParent(hwnd,
(GETSHIFTED(hwnd) ? BTN_SHIFT : 0) + iButton);
}
}
return 0L;
case WM_TIMER:
/* If we have a tool button down, send a repeat message */
if (GETPRESSED(hwnd)) {
int iButton, iType;
iBtnPos = GETWHICH(hwnd);
iButton = toolbarButtonFromIndex(hwnd, iBtnPos);
iType = toolbarTypeFromIndex(hwnd, iBtnPos);
NotifyParent(hwnd, BTN_REPEAT +
(GETSHIFTED(hwnd) ? BTN_SHIFT : 0) +
toolbarButtonFromIndex(hwnd, iBtnPos));
}
break;
case WM_DESTROY:
if (GETBMPHANDLE(hwnd))
DeleteObject(GETBMPHANDLE(hwnd));
SETBMPHANDLE(hwnd, NULL);
if (GETARRAYBUTT(hwnd))
GlobalFree(GETARRAYBUTT(hwnd));
SETARRAYBUTT(hwnd, NULL);
break;
case WM_SETTEXT:
break;
/* MANY, MANY cases deleted */
case WM_SETFOCUS: // focus comes to toolbar window
{
/* Remember who had the focus and give it back. Of course, */
/* if by some wierdness that button is now grayed, give it */
/* to the next person in line. */
iBtnPos = GETWHICH(hwnd);
if (iBtnPos < 0 || iBtnPos >= toolbarGetNumButtons(hwnd)) {
iBtnPos = 0;
SETWHICH(hwnd, 0);
}
do {
iButton = toolbarButtonFromIndex(hwnd, iBtnPos);
if (toolbarFullStateFromButton(hwnd, iButton)
!= BTNST_GRAYED)
break; // give it here
iBtnPos++;
if (iBtnPos >= toolbarGetNumButtons(hwnd))
iBtnPos = 0; // wrap around
if (iBtnPos == GETWHICH(hwnd))
return 0L; // uh-oh! They're all gray!
} while (iBtnPos != GETWHICH(hwnd));
SETWHICH(hwnd, iBtnPos); // give focus here
/* And redraw! */
toolbarRectFromIndex(hwnd, iBtnPos, &rc);
InvalidateRect(hwnd, &rc, FALSE);
UpdateWindow(hwnd);
return 0;
}
case WM_KILLFOCUS:
/* Send a KEYUP if one is pending */
if (GETKEYPRESSED(hwnd))
SendMessage(hwnd, WM_KEYUP, VK_SPACE, 0L);
/* Redraw the focused button, because now that focus is gone */
/* from our toolbar window, the focused button won't be */
/* focused anymore, although we remember which one it was. */
toolbarRectFromIndex(hwnd, GETWHICH(hwnd), &rc);
InvalidateRect(hwnd, &rc, FALSE);
UpdateWindow(hwnd);
return 0;
case WM_SYSKEYDOWN:
/* Send a KEYUP if one is pending */
if (GETKEYPRESSED(hwnd))
SendMessage(hwnd, WM_KEYUP, VK_SPACE, 0L);
break; // MUST LET DEFWNDPROC RUN!!! (to handle the key)
case WM_GETDLGCODE:
return DLGC_WANTARROWS | DLGC_WANTTAB;
case WM_KEYDOWN:
/* Window disabled or a key is already down */
if (IsWindowEnabled(hwnd) && !GETPRESSED(hwnd)) {
/* Tab forward to next button and move focus there */
if (wParam == VK_TAB && GetKeyState(VK_SHIFT) >= 0 ) {
/* Move Focus forward one. If */
/* we've tabbed off of the toolbar, it's time */
/* to go on to the next control. We need to invldte */
/* because we might be the only control and we need */
/* to repaint to show the new button with highlight */
/* after it wrapped around the end of the toolbar. */
if (!toolbarMoveFocus(hwnd, FALSE)) {
PostMessage(GetParent(hwnd), WM_NEXTDLGCTL, 0, 0L);
toolbarRectFromIndex(hwnd, GETWHICH(hwnd), &rc);
InvalidateRect(hwnd, &rc, FALSE);
}
return 0L;
}
if (wParam == VK_TAB && GetKeyState(VK_SHIFT) < 0 ) {
/* Move focus backward one. If */
/* We've tabbed off of the toolbar, it's time */
/* to go on to the next control. We need to invldte */
/* because we might be the only control and we need */
/* to repaint to show the new button with highlight */
/* after it wrapped around the end of the toolbar. */
if (!toolbarMoveFocus(hwnd, TRUE)) {
PostMessage(GetParent(hwnd), WM_NEXTDLGCTL, 1, 0L);
toolbarRectFromIndex(hwnd, GETWHICH(hwnd), &rc);
InvalidateRect(hwnd, &rc, FALSE);
}
return 0L;
}
if ((wParam == VK_SPACE) && (GetCapture() != hwnd)) {
int iButton, iType, iState;
/* Same as mouse button down -- Press the button! */
iBtnPos = GETWHICH(hwnd);
iType = toolbarTypeFromIndex(hwnd, iBtnPos);
iButton = toolbarButtonFromIndex(hwnd, iBtnPos);
iState = toolbarFullStateFromButton(hwnd, iButton);
/* ignore multiple key downs */
if (!GETKEYPRESSED(hwnd)) {
SETKEYPRESSED(hwnd, TRUE); // a key is pressed
SETSHIFTED(hwnd, FALSE); // NEVER shifted
SETPRESSED(hwnd, TRUE); // a button is pressed
/* Push button goes down - with focus */
if (iType == BTNTYPE_PUSH)
toolbarModifyState(hwnd, iButton, BTNST_DOWN);
/* Radio or checkbox button goes full down */
/* with focus - and remember previous state*/
if (iType >= BTNTYPE_RADIO ||
iType == BTNTYPE_CHECKBOX) {
toolbarModifyPrevState(hwnd, iButton, iState);
toolbarModifyState(hwnd, iButton,
BTNST_FULLDOWN);
}
toolbarModifyActivity(hwnd, iButton,
BTNACT_KEYDOWN);
NotifyParent(hwnd, (GETSHIFTED(hwnd)
? BTN_SHIFT : 0) + iButton);
return 0L;
}
/* If this is another KEYDOWN msg, it's a REPEAT */
/* Notify parent. */
NotifyParent(hwnd, BTN_REPEAT +
(GETSHIFTED(hwnd) ? BTN_SHIFT : 0) +
toolbarButtonFromIndex(hwnd,
GETWHICH(hwnd)));
}
}
break;
case WM_KEYUP:
/* A button was pressed and should come up now */
if ((wParam == VK_SPACE) && (GETKEYPRESSED(hwnd))) {
int iButton, iState, iType, iPrevState;
iBtnPos = GETWHICH(hwnd); // which button?
SETKEYPRESSED(hwnd, FALSE); // let go
SETPRESSED(hwnd, FALSE);
/* Everything about this button */
toolbarRectFromIndex(hwnd, iBtnPos, &rc);
iType = toolbarTypeFromIndex(hwnd, iBtnPos);
iButton = toolbarButtonFromIndex(hwnd, iBtnPos);
iState = toolbarFullStateFromButton(hwnd, iButton);
/* Bring a push button up */
if (iType == BTNTYPE_PUSH)
toolbarModifyState(hwnd, iButton, BTNST_UP);
/* Bring a checkbox to the opposite state it was in */
if (iType == BTNTYPE_CHECKBOX) {
iPrevState = toolbarPrevStateFromButton(hwnd, iButton);
if (iPrevState == BTNST_DOWN)
toolbarModifyState(hwnd, iButton, BTNST_UP);
if (iPrevState == BTNST_UP)
toolbarModifyState(hwnd, iButton, BTNST_DOWN);
}
/* Bring a radio button down, and bring all others in */
/* its group up. */
if (iType >= BTNTYPE_RADIO) {
toolbarModifyState(hwnd, iButton, BTNST_DOWN);
toolbarExclusiveRadio(hwnd, iType, iButton);
}
toolbarModifyActivity(hwnd, iButton, BTNACT_KEYUP);
NotifyParent(hwnd, toolbarButtonFromIndex(hwnd,
(GETSHIFTED(hwnd) ? BTN_SHIFT : 0) +
GETWHICH(hwnd)));
}
break;
case WM_SYSCOLORCHANGE:
/* load the bitmap of what all the buttons look like */
/* and change the colours to the system colours. */
hInst = GETHINST(hwnd);
ibmp = GETBMPINT(hwnd);
hbm = GETBMPHANDLE(hwnd);
if (hbm)
DeleteObject(hbm);
hbm = LoadUIBitmap(hInst, MAKEINTRESOURCE(ibmp),
GetSysColor(COLOR_BTNTEXT),
GetSysColor(COLOR_BTNFACE),
GetSysColor(COLOR_BTNSHADOW),
GetSysColor(COLOR_BTNHIGHLIGHT),
GetSysColor(COLOR_BTNFACE),
GetSysColor(COLOR_WINDOWFRAME));
SETBMPHANDLE(hwnd, hbm);
#ifdef _WIN32
return (long) hbm;
#else
return MAKELONG(hbm, 0);
#endif
case WM_ERASEBKGND:
break;
case WM_PAINT:
/* Call our paint code */
BeginPaint(hwnd, &ps);
toolbarPaintControl(hwnd, ps.hdc);
EndPaint(hwnd, &ps);
return 0L;
}
return DefWindowProc(hwnd, message, wParam, lParam);
}
Reference in New Issue Copy Permalink