开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 视频捕捉/采集 > 查看源码
TOOLBAR.C
资源名称：vc video capture.rar　[点击查看]
上传用户：carrie980
上传日期：2013-03-28
资源大小：1143k
文件大小：55k
源码类别：

视频捕捉/采集

开发平台：

Visual C++

TOOLBAR.C：源码内容
  1. /**************************************************************************
  2.  *
  3.  *  THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY
  4.  *  KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
  5.  *  IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR
  6.  *  PURPOSE.
  7.  *
  8.  *  Copyright (C) 1992 - 1996 Microsoft Corporation.  All Rights Reserved.
  9.  *
  10.  **************************************************************************/
  11. /****************************************************************************
  12.  *
  13.  *   toolbar.c: Toolbar control window
  14.  *
  15.  *   Vidcap32 Source code
  16.  *
  17.  ***************************************************************************/
  19. #include <string.h>
  21. #include <windows.h>
  22. #include <windowsx.h>
  23. //#include <win32.h>
  24. #include "toolbar.h" // use this for generic app
  25. /************************************************************************/
  27. /* work for win3.0 */
  28. #ifndef COLOR_BTNHIGHLIGHT
  29. #define COLOR_BTNHIGHLIGHT 20
  30. #endif
  32. char szToolBarClass[] = "ToolBarClass";
  33. HBRUSH ghbrToolbar; // brush for toolbar background
  35. //
  36. // Window proc for buttons, THIS FUNCTION MUST BE EXPORTED
  37. //
  38. LONG FAR PASCAL toolbarWndProc(HWND, unsigned, UINT, LONG);
  40. typedef long (FAR PASCAL *LPWNDPROC)();
  42. /*
  43. Defines
  44. */
  46. #ifdef _WIN32
  48. #define GETARRAYBUTT(hwnd) ((HANDLE)GetWindowLong(hwnd,GWL_ARRAYBUTT))
  49. #define GETNUMBUTTONS(hwnd) ((int)GetWindowLong(hwnd,GWL_NUMBUTTONS))
  50. #define GETPRESSED(hwnd) ((BOOL)GetWindowLong(hwnd,GWL_PRESSED))
  51. #define GETKEYPRESSED(hwnd) ((BOOL)GetWindowLong(hwnd,GWL_KEYPRESSED))
  52. #define GETWHICH(hwnd) ((int)GetWindowLong(hwnd,GWL_WHICH))
  53. #define GETSHIFTED(hwnd) ((BOOL)GetWindowLong(hwnd,GWL_SHIFTED))
  54. #define GETBMPHANDLE(hwnd) ((HANDLE)GetWindowLong(hwnd,GWL_BMPHANDLE))
  55. #define GETBMPINT(hwnd) ((int)GetWindowLong(hwnd,GWL_BMPINT))
  56. #define GETBUTTONSIZE(hwnd) GetWindowLong(hwnd,GWL_BUTTONSIZE)
  57. #define GETHINST(hwnd) ((HANDLE)GetWindowLong(hwnd,GWL_HINST))
  60. #define SETARRAYBUTT(hwnd, h) SetWindowLong(hwnd, GWL_ARRAYBUTT, (UINT)h)
  61. #define SETNUMBUTTONS(hwnd, wNumButtons) 
  62. SetWindowLong(hwnd, GWL_NUMBUTTONS, wNumButtons)
  63. #define SETPRESSED(hwnd, f) SetWindowLong(hwnd, GWL_PRESSED, (UINT)f)
  64. #define SETKEYPRESSED(hwnd, f) SetWindowLong(hwnd, GWL_KEYPRESSED, (UINT)f)
  65. #define SETWHICH(hwnd, i) SetWindowLong(hwnd, GWL_WHICH, (UINT)i)
  66. #define SETSHIFTED(hwnd, i) SetWindowLong(hwnd, GWL_SHIFTED, (UINT)i)
  67. #define SETBMPHANDLE(hwnd, h) SetWindowLong(hwnd, GWL_BMPHANDLE, (UINT)h)
  68. #define SETBMPINT(hwnd, i) SetWindowLong(hwnd, GWL_BMPINT, (UINT)i)
  69. #define SETBUTTONSIZE(hwnd, l) SetWindowLong(hwnd, GWL_BUTTONSIZE, l)
  70. #define SETHINST(hwnd, h) SetWindowLong(hwnd, GWL_HINST, (UINT)h)
  72. #else
  74. #define GETARRAYBUTT(hwnd) ((HANDLE)GetWindowWord(hwnd,GWW_ARRAYBUTT))
  75. #define GETNUMBUTTONS(hwnd) ((int)GetWindowWord(hwnd,GWW_NUMBUTTONS))
  76. #define GETPRESSED(hwnd) ((BOOL)GetWindowWord(hwnd,GWW_PRESSED))
  77. #define GETKEYPRESSED(hwnd) ((BOOL)GetWindowWord(hwnd,GWW_KEYPRESSED))
  78. #define GETWHICH(hwnd) ((int)GetWindowWord(hwnd,GWW_WHICH))
  79. #define GETSHIFTED(hwnd) ((BOOL)GetWindowWord(hwnd,GWW_SHIFTED))
  80. #define GETBMPHANDLE(hwnd) ((HANDLE)GetWindowWord(hwnd,GWW_BMPHANDLE))
  81. #define GETBMPINT(hwnd) ((int)GetWindowWord(hwnd,GWW_BMPINT))
  82. #define GETBUTTONSIZE(hwnd) GetWindowLong(hwnd,GWL_BUTTONSIZE)
  83. #define GETHINST(hwnd) ((HANDLE)GetWindowWord(hwnd,GWW_HINST))
  86. #define SETARRAYBUTT(hwnd, h) SetWindowWord(hwnd, GWW_ARRAYBUTT, (WORD)h)
  87. #define SETNUMBUTTONS(hwnd, wNumButtons) 
  88. SetWindowWord(hwnd, GWW_NUMBUTTONS, wNumButtons)
  89. #define SETPRESSED(hwnd, f) SetWindowWord(hwnd, GWW_PRESSED, (WORD)f)
  90. #define SETKEYPRESSED(hwnd, f) SetWindowWord(hwnd, GWW_KEYPRESSED, (WORD)f)
  91. #define SETWHICH(hwnd, i) SetWindowWord(hwnd, GWW_WHICH, (WORD)i)
  92. #define SETSHIFTED(hwnd, i) SetWindowWord(hwnd, GWW_SHIFTED, (WORD)i)
  93. #define SETBMPHANDLE(hwnd, h) SetWindowWord(hwnd, GWW_BMPHANDLE, (WORD)h)
  94. #define SETBMPINT(hwnd, i) SetWindowWord(hwnd, GWW_BMPINT, (WORD)i)
  95. #define SETBUTTONSIZE(hwnd, l) SetWindowLong(hwnd, GWL_BUTTONSIZE, l)
  96. #define SETHINST(hwnd, h) SetWindowWord(hwnd, GWW_HINST, (WORD)h)
  98. #endif
  100. #define lpCreate ((LPCREATESTRUCT)lParam)
  102. /* Prototypes */
  104. static void NEAR PASCAL NotifyParent(HWND, int);
  108. /**************************************************************************
  109. toolbarInit( hInst, hPrev )
  111. Call this routine to initialize the toolbar code.
  113. Arguments:
  114. hPrev instance handle of previous instance
  115. hInst instance handle of current instance
  117. Returns:
  118. TRUE if successful, FALSE if not
  119. ***************************************************************************/
  121. BOOL FAR PASCAL toolbarInit(HANDLE hInst, HANDLE hPrev)
  122. {
  123. WNDCLASS cls;
  125. /* Register the tool bar window class */
  126. if (!hPrev) {
  128.     cls.hCursor        = LoadCursor(NULL,IDC_ARROW);
  129.     cls.hIcon          = NULL;
  130.     cls.lpszMenuName   = NULL;
  131.     cls.lpszClassName  = (LPSTR)szToolBarClass;
  132.     cls.hbrBackground  = (HBRUSH)(COLOR_BTNFACE + 1);
  133.     cls.hInstance      = hInst;
  134.     cls.style          = CS_DBLCLKS;
  135.     cls.lpfnWndProc    = toolbarWndProc;
  136.     cls.cbClsExtra     = 0;
  137.     cls.cbWndExtra     = TOOLBAR_EXTRABYTES;
  138.     if (!RegisterClass(&cls))
  139. return FALSE;
  140. }
  142. return TRUE;
  143. }
  146. /***************************************************************************/
  147. /* toolbarSetBitmap:  takes a resource ID and associates that bitmap with  */
  148. /*                    a given toolbar.  Also takes the instance handle and */
  149. /*                    the size of the buttons on the toolbar.              */
  150. /***************************************************************************/
  151. BOOL FAR PASCAL toolbarSetBitmap(HWND hwnd, HANDLE hInst, int ibmp, POINT ptSize)
  152. {
  153. SETHINST(hwnd, hInst);
  154. SETBMPHANDLE(hwnd, NULL);
  155. SETBMPINT(hwnd, ibmp);
  156. SETBUTTONSIZE(hwnd, MAKELONG(ptSize.y, ptSize.x));
  157. return (BOOL)SendMessage(hwnd, WM_SYSCOLORCHANGE, 0, 0L); // do the work
  158. }
  160. /***************************************************************************/
  161. /* toolbarGetNumButtons:  return the number of buttons registered on a     */
  162. /*                        given toolbar window.                            */
  163. /***************************************************************************/
  164. int FAR PASCAL toolbarGetNumButtons(HWND hwnd)
  165. {
  166.     return GETNUMBUTTONS(hwnd);
  167. }
  170. /***************************************************************************/
  171. /* toolbarButtonFromIndex:  Given an index into the array of buttons on    */
  172. /*                          this toolbar, return which button is there.    */
  173. /*                          Returns -1 for an error code.                  */
  174. /***************************************************************************/
  175. int FAR PASCAL toolbarButtonFromIndex(HWND hwnd, int iBtnPos)
  176. {
  177. int iButton;
  178. HANDLE h;
  179. TOOLBUTTON far *lpaButtons;
  181. /* Get the array of buttons on this toolbar */
  182. h = GETARRAYBUTT(hwnd);
  183. if (!h)
  184. return -1;
  186. /* Validate the index passed in */
  187. if (iBtnPos > GETNUMBUTTONS(hwnd) || iBtnPos < 0)
  188. return -1;
  190. lpaButtons = (TOOLBUTTON far *)GlobalLock(h);
  192. /* Read off the answer */
  193. iButton = lpaButtons[iBtnPos].iButton;
  195. GlobalUnlock(h);
  196. return iButton;
  197. }
  200. /***************************************************************************/
  201. /* toolbarIndexFromButton:  Given a button ID, return the position in the  */
  202. /*                          array that it appears at.                      */
  203. /*                          Returns -1 for an error code.                  */
  204. /***************************************************************************/
  205. int FAR PASCAL toolbarIndexFromButton(HWND hwnd, int iButton)
  206. {
  207. int i, iBtnPos = -1;
  208. HANDLE h;
  209. TOOLBUTTON far *lpButton;
  211. /* Get the array of buttons */
  212. h = GETARRAYBUTT(hwnd);
  213. if (!h)
  214. return -1;
  215. lpButton = (TOOLBUTTON far *)GlobalLock(h);
  217. /* loop through until you find it */
  218. for(i = 0; i < GETNUMBUTTONS(hwnd); i++, lpButton++)
  219. if (lpButton->iButton == iButton) {
  220. iBtnPos = i;
  221. break;
  222. }
  224. GlobalUnlock(h);
  225. return iBtnPos;
  226. }
  230. /***************************************************************************/
  231. /* toolbarPrevStateFromButton:  Given a button ID, return the state that   */
  232. /*                              the button was in before it was pressed    */
  233. /*                              all the way down (for non-push buttons).   */
  234. /*                              Return -1 for an error code.               */
  235. /***************************************************************************/
  236. int FAR PASCAL toolbarPrevStateFromButton(HWND hwnd, int iButton)
  237. {
  238. int i, iPrevState = -1;
  239. HANDLE h;
  240. TOOLBUTTON far *lpButton;
  242. /* Get the array of buttons */
  243. h = GETARRAYBUTT(hwnd);
  244. if (!h)
  245. return -1;
  246. lpButton = (TOOLBUTTON far *)GlobalLock(h);
  248. /* look for what we need */
  249. for(i = 0; i < GETNUMBUTTONS(hwnd); i++, lpButton++)
  250. if (lpButton->iButton == iButton) {
  251. iPrevState = lpButton->iPrevState;
  252. break;
  253. }
  255. GlobalUnlock(h);
  256. return iPrevState;
  257. }
  261. /***************************************************************************/
  262. /* toolbarActivityFromButton:   Given a button ID, return the most recent  */
  263. /*                              activity that happened to it. (eg DBLCLK)  */
  264. /*                              Return -1 for an error code.               */
  265. /***************************************************************************/
  266. int FAR PASCAL toolbarActivityFromButton(HWND hwnd, int iButton)
  267. {
  268. int i, iActivity = -1;
  269. HANDLE h;
  270. TOOLBUTTON far *lpButton;
  272. /* Get the array of buttons */
  273. h = GETARRAYBUTT(hwnd);
  274. if (!h)
  275. return -1;
  276. lpButton = (TOOLBUTTON far *)GlobalLock(h);
  278. /* loop through until you find it */
  279. for(i = 0; i < GETNUMBUTTONS(hwnd); i++, lpButton++)
  280. if (lpButton->iButton == iButton)
  281. iActivity = lpButton->iActivity;
  283. GlobalUnlock(h);
  284. return iActivity;
  285. }
  289. /***************************************************************************/
  290. /* toolbarIndexFromPoint:  Given a point in the toolbar window, return the */
  291. /*                         index of the button beneath that point.         */
  292. /*                         Return -1 for an error code.                    */
  293. /***************************************************************************/
  294. int FAR PASCAL toolbarIndexFromPoint(HWND hwnd, POINT pt)
  295. {
  296. int i, iBtnPos = -1;
  297. HANDLE h;
  298. TOOLBUTTON far *lpButton;
  300. /* Get the array of buttons */
  301. h = GETARRAYBUTT(hwnd);
  302. if (!h)
  303. return -1;
  304. lpButton = (TOOLBUTTON far *)GlobalLock(h);
  306. /* loop through until we find an intersection */
  307. for(i = 0; i < GETNUMBUTTONS(hwnd); i++, lpButton++)
  308. if (PtInRect(&lpButton->rc, pt)) {
  309. iBtnPos = i;
  310. break;
  311. }
  313. GlobalUnlock(h);
  314. return iBtnPos;
  315. }
  319. /***************************************************************************/
  320. /* toolbarRectFromIndex:   Given an index into our array of buttons, return*/
  321. /*                         the rect occupied by that button.               */
  322. /*                         Return a NULL rect for an error.                */
  323. /***************************************************************************/
  324. BOOL FAR PASCAL toolbarRectFromIndex(HWND hwnd, int iBtnPos, LPRECT lprc)
  325. {
  326. HANDLE h;
  327. TOOLBUTTON far *lpaButtons;
  329. /* Get the array of buttons */
  330. h = GETARRAYBUTT(hwnd);
  331. if (!h)
  332.     return FALSE;
  334. /* Validate the index passed in */
  335. if (iBtnPos > GETNUMBUTTONS(hwnd) || iBtnPos < 0)
  336.     return FALSE;
  338. lpaButtons = (TOOLBUTTON far *)GlobalLock(h);
  340. /* Read off the rect */
  341. *lprc = lpaButtons[iBtnPos].rc;
  343. GlobalUnlock(h);
  344.         return TRUE;
  345. }
  349. /***************************************************************************/
  350. /* toolbarFullStateFromButton: Given a button in our array of buttons,     */
  351. /*                             return the state of that button.            */
  352. /*                             (including the wierd state FULLDOWN). For   */
  353. /*                             just UP or DOWN or GRAYED,                  */
  354. /*                             call toolbarStateFromButton.    */
  355. /*                             Return -1 for an error.                     */
  356. /***************************************************************************/
  357. int FAR PASCAL toolbarFullStateFromButton(HWND hwnd, int iButton)
  358. {
  359. int iState, iBtnPos;
  360. HANDLE h;
  361. TOOLBUTTON far *lpaButtons;
  363. iBtnPos = toolbarIndexFromButton(hwnd, iButton);
  364. if (iBtnPos == -1)
  365. return -1;
  367. /* Get the array of buttons */
  368. h = GETARRAYBUTT(hwnd);
  369. if (!h)
  370. return -1;
  372. lpaButtons = (TOOLBUTTON far *)GlobalLock(h);
  374. /* Read off the state */
  375. iState = lpaButtons[iBtnPos].iState;
  377. GlobalUnlock(h);
  378. return iState;
  379. }
  383. /***************************************************************************/
  384. /* toolbarStateFromButton: This fn is called by the parent application     */
  385. /*                         to get the state of a button.  It will only     */
  386. /*                         return DOWN, or UP or GRAYED as opposed to      */
  387. /*                         toolbarFullStateFromButton which could return   */
  388. /*                         FULLDOWN.                                       */
  389. /***************************************************************************/
  390. int FAR PASCAL toolbarStateFromButton(HWND hwnd, int iButton)
  391. {
  392. int iState;
  394. /* If a checkbox button is all the way down, it's previous state is */
  395. /* the one we want.     */
  396. if ((iState = toolbarFullStateFromButton(hwnd, iButton))
  397. == BTNST_FULLDOWN) {
  398.     iState = toolbarPrevStateFromButton(hwnd, iButton);
  399.     return iState;
  400. } else
  401.     return iState;
  402. }
  406. /***************************************************************************/
  407. /* toolbarStringFromIndex: Given an index into our array of buttons, return*/
  408. /*                         the string resource associated with it.         */
  409. /*                         Return -1 for an error.                         */
  410. /***************************************************************************/
  411. int FAR PASCAL toolbarStringFromIndex(HWND hwnd, int iBtnPos)
  412. {
  413. int iString;
  414. HANDLE h;
  415. TOOLBUTTON far *lpaButtons;
  417. /* Get the array of buttons */
  418. h = GETARRAYBUTT(hwnd);
  419. if (!h)
  420. return -1;
  422. /* Validate the index passed in */
  423. if (iBtnPos > GETNUMBUTTONS(hwnd) || iBtnPos < 0)
  424. return -1;
  426. lpaButtons = (TOOLBUTTON far *)GlobalLock(h);
  428. /* Read off the ID */
  429. iString = lpaButtons[iBtnPos].iString;
  431. GlobalUnlock(h);
  432. return iString;
  433. }
  437. /***************************************************************************/
  438. /* toolbarTypeFromIndex:   Given an index into our array of buttons, return*/
  439. /*                         the type of button it is (PUSH, RADIO, etc.)    */
  440. /*                         Return -1 for an error.                         */
  441. /***************************************************************************/
  442. int FAR PASCAL toolbarTypeFromIndex(HWND hwnd, int iBtnPos)
  443. {
  444. int iType;
  445. HANDLE h;
  446. TOOLBUTTON far *lpaButtons;
  448. /* Get the Array of buttons */
  449. h = GETARRAYBUTT(hwnd);
  450. if (!h)
  451. return -1;
  453. /* Validate the index passed in */
  454. if (iBtnPos > GETNUMBUTTONS(hwnd) || iBtnPos < 0)
  455. return -1;
  457. lpaButtons = (TOOLBUTTON far *)GlobalLock(h);
  459. /* Read off the type */
  460. iType = lpaButtons[iBtnPos].iType;
  462. GlobalUnlock(h);
  463. return iType;
  464. }
  467. /***************************************************************************/
  468. /* toolbarAddTool:  Add a button to this toolbar.  Sort them by leftmost   */
  469. /*                  position in the window (for tabbing order).            */
  470. /*                  Return FALSE for an error.                             */
  471. /***************************************************************************/
  472. BOOL FAR PASCAL toolbarAddTool(HWND hwnd, TOOLBUTTON tb)
  473. {
  474. HANDLE h;
  475. TOOLBUTTON far  *lpaButtons;
  476. int cButtons, i, j;
  477. BOOL fInsert = FALSE;
  479. /* We better not have this button on the toolbar already */
  480. if (toolbarIndexFromButton(hwnd, tb.iButton) != -1)
  481. return FALSE;
  483. /* Get the array of buttons */
  484. h = GETARRAYBUTT(hwnd);
  485. if (!h)
  486. return FALSE;
  488. /* How many buttons are there already? */
  489. cButtons = GETNUMBUTTONS(hwnd);
  491. /* If we have filled our alloced memory for this array already, we */
  492. /* need to re-alloc some more memory    */
  493. if ( ((cButtons & (TOOLGROW - 1)) == 0) && (cButtons > 0) ) {
  495. /* Re-alloc it bigger */
  496. h = GlobalReAlloc(h,
  497. GlobalSize(h) + TOOLGROW * sizeof(TOOLBUTTON),
  498. GMEM_MOVEABLE | GMEM_SHARE);
  499. if (!h)
  500.     return FALSE;
  501. }
  503. lpaButtons = (TOOLBUTTON far *)GlobalLock(h);
  505. /* Look for the spot we need to insert this new guy at. */
  506.   /* Remember, we sort by left x position breaking ties   */
  507.   /* with top y position. */
  508. for (i = 0; i < cButtons; i++) {
  509. // Here it goes
  510.       if (lpaButtons[i].rc.left > tb.rc.left ||
  511.   (lpaButtons[i].rc.left == tb.rc.left &&
  512.   lpaButtons[i].rc.top > tb.rc.top)) {
  513. fInsert = TRUE;
  514. /* Open up a spot in the array */
  515. for (j = cButtons; j > i; j--)
  516.     lpaButtons[j] = lpaButtons[j-1];
  517. /* Add our new guy */
  518. lpaButtons[i] = tb; // redraw now
  519. InvalidateRect(hwnd, &(lpaButtons[i].rc), FALSE);
  520. break;
  521.     }
  522. }
  524. /* If our loop didn't insert it, we need to add it to the end */
  525. if (!fInsert)
  526.     lpaButtons[i] = tb;
  528. /* If we are told that this button has the focus, we better */
  529. /* change the focus to it.  Then use the normal state.          */
  530. if (tb.iState == BTNST_FOCUSUP) {
  531.     tb.iState = BTNST_UP;
  532.     SETWHICH(hwnd, i);
  533. } else if (tb.iState == BTNST_FOCUSDOWN || tb.iState == BTNST_FULLDOWN){
  534.     tb.iState = BTNST_DOWN; // nonsense to init to FULLDOWN
  535.     SETWHICH(hwnd, i);
  536. }
  538. cButtons++; // one more button now.
  539. GlobalUnlock(h);
  541. SETNUMBUTTONS(hwnd, cButtons); // new count
  542. SETARRAYBUTT(hwnd, h); // re-alloc might have changed it
  544. /* Just in case no one else makes this new button draw */
  545. InvalidateRect(hwnd, &(tb.rc), FALSE);
  547. return TRUE;
  548. }
  551.  /***************************************************************************/
  552.  /* toolbarRetrieveTool:  Get the TOOLBUTTON struct for the given button.   */
  553.  /*                       Return FALSE for an error.                        */
  554.  /***************************************************************************/
  555.  BOOL FAR PASCAL toolbarRetrieveTool(HWND hwnd, int iButton, LPTOOLBUTTON lptb)
  556.  {
  557.   int i;
  558.   HANDLE h;
  559.   TOOLBUTTON far *lpButton;
  560.   BOOL fFound = FALSE;
  561.  
  562.   /* Get the array of buttons */
  563.   h = GETARRAYBUTT(hwnd);
  564.   if (!h)
  565.   return FALSE;
  566.   lpButton = (TOOLBUTTON far *)GlobalLock(h);
  568.   /* look for what we need */
  569.   for(i = 0; i < GETNUMBUTTONS(hwnd); i++, lpButton++)
  570.   if (lpButton->iButton == iButton) {
  571.   *lptb = *lpButton;
  572.   fFound = TRUE;
  573.   break;
  574.   }
  576.   GlobalUnlock(h);
  577.   return fFound;
  578.  }
  582. /***************************************************************************/
  583. /* toolbarRemoveTool:  Remove this button ID from our array of buttons on  */
  584. /*                    the toolbar.  (only 1 of each button ID allowed).   */
  585. /*                     Return FALSE for an error.                          */
  586. /***************************************************************************/
  587. BOOL FAR PASCAL toolbarRemoveTool(HWND hwnd, int iButton)
  588. {
  589. HANDLE h;
  590. TOOLBUTTON far  *lpaButtons;
  591. int cButtons, i, j;
  592. BOOL fFound = FALSE;
  594. /* Get the array of buttons */
  595. h = GETARRAYBUTT(hwnd);
  596. if (!h)
  597. return FALSE;
  599. /* How many buttons are on there now? */
  600. cButtons = GETNUMBUTTONS(hwnd);
  602. lpaButtons = (TOOLBUTTON far *)GlobalLock(h);
  604. /* Find a match, remove it, and close the array around it. */
  605. for (i = 0; i < cButtons; i++)
  606. if (lpaButtons[i].iButton == iButton) {
  607. fFound = TRUE;
  608. // redraw now
  609. InvalidateRect(hwnd, &(lpaButtons[i].rc), FALSE);
  610. if (i != cButtons - 1) // Last button? Don't bother!
  611. for (j = i; j < cButtons; j++)
  612. lpaButtons[j] = lpaButtons[j + 1];
  613. break;
  614. }
  616. GlobalUnlock(h);
  618. /* Didn't find it! */
  619. if (!fFound)
  620.     return FALSE;
  622. /* One less button */
  623. cButtons--;
  625. /* Every once in a while, re-alloc a smaller array chunk to */
  626. /* save memory. */
  627. if ( ((cButtons & (TOOLGROW - 1)) == 0) && (cButtons > 0) ) {
  629. /* Re-alloc it smaller */
  630. h = GlobalReAlloc(h,
  631. GlobalSize(h) - TOOLGROW * sizeof(TOOLBUTTON),
  632. GMEM_MOVEABLE | GMEM_SHARE);
  633. if (!h)
  634.     return FALSE;
  635. }
  637. SETNUMBUTTONS(hwnd, cButtons); // new count
  638. SETARRAYBUTT(hwnd, h); // re-alloc could have changed it
  640. return TRUE;
  641. }
  643. /***************************************************************************/
  644. /* toolbarModifyString: Given a button ID on the toolbar, change it's      */
  645. /*                      string resource associated with it.                */
  646. /*                      returns FALSE for an error or if no such button    */
  647. /***************************************************************************/
  648. BOOL FAR PASCAL toolbarModifyString(HWND hwnd, int iButton, int iString)
  649. {
  650. HANDLE h;
  651. TOOLBUTTON far  *lpButton;
  652. int cButtons, i;
  653. BOOL fFound = FALSE;
  655. /* Get the array of buttons */
  656. h = GETARRAYBUTT(hwnd);
  657. if (!h)
  658. return FALSE;
  660. /* How many buttons? */
  661. cButtons = GETNUMBUTTONS(hwnd);
  662. lpButton = (TOOLBUTTON far *)GlobalLock(h);
  664. /* Find that button, and change it's state */
  665. for (i = 0; i < cButtons; i++, lpButton++)
  666. if (lpButton->iButton == iButton) {
  667. lpButton->iString = iString;
  668. fFound = TRUE; // redraw now
  669. break;
  670. }
  672. GlobalUnlock(h);
  673. return fFound;
  674. }
  676. /***************************************************************************/
  677. /* toolbarModifyState:  Given a button ID on the toolbar, change it's      */
  678. /*                      state.                                             */
  679. /*                      returns FALSE for an error or if no such button    */
  680. /***************************************************************************/
  681. BOOL FAR PASCAL toolbarModifyState(HWND hwnd, int iButton, int iState)
  682. {
  683. HANDLE h;
  684. TOOLBUTTON far  *lpButton;
  685. int cButtons, i;
  686. BOOL fFound = FALSE;
  688. /* Get the array of buttons */
  689. h = GETARRAYBUTT(hwnd);
  690. if (!h)
  691. return FALSE;
  693. /* How many buttons? */
  694. cButtons = GETNUMBUTTONS(hwnd);
  695. lpButton = (TOOLBUTTON far *)GlobalLock(h);
  697. /* Find that button, and change it's state */
  698. for (i = 0; i < cButtons; i++, lpButton++)
  699. if (lpButton->iButton == iButton) {
  700. if (lpButton->iState != iState) {
  701. lpButton->iState = iState;
  702. InvalidateRect(hwnd, &(lpButton->rc), FALSE);
  703. }
  704. fFound = TRUE; // redraw now
  706. /* if we're pushing a radio button down, bring */
  707. /* all others in its group up */
  708. if (lpButton->iType >= BTNTYPE_RADIO &&
  709. iState == BTNST_DOWN)
  710.     toolbarExclusiveRadio(hwnd, lpButton->iType,
  711. iButton);
  712. break;
  713. }
  715. GlobalUnlock(h);
  716. return fFound;
  717. }
  720. /***************************************************************************/
  721. /* toolbarModifyPrevState: Given a button on the toolbar, change it's prev-*/
  722. /*                      ious state. Used for non-PUSH buttons to remember  */
  723. /*                      what state a button was in before pressed all the  */
  724. /*                      way down, so that when you let go, you know what   */
  725. /*                      state to set it to (the opposite of what it was).  */
  726. /*                      returns FALSE for an error (no button array)       */
  727. /***************************************************************************/
  728. BOOL FAR PASCAL toolbarModifyPrevState(HWND hwnd, int iButton, int iPrevState)
  729. {
  730. HANDLE h;
  731. TOOLBUTTON far  *lpButton;
  732. int cButtons, i;
  734. /* Get button array */
  735. h = GETARRAYBUTT(hwnd);
  736. if (!h)
  737. return FALSE;
  739. /* How many buttons? */
  740. cButtons = GETNUMBUTTONS(hwnd);
  742. lpButton = (TOOLBUTTON far *)GlobalLock(h);
  744. /* Find the button, change the state */
  745. for (i = 0; i < cButtons; i++, lpButton++)
  746. if (lpButton->iButton == iButton) {
  747. lpButton->iPrevState = iPrevState;
  748. break;
  749. }
  751. GlobalUnlock(h);
  752. return TRUE;
  753. }
  756. /***************************************************************************/
  757. /* toolbarModifyActivity: Given a button ID on the toolbar, change it's    */
  758. /*                        activity.  This tells the app what just happened */
  759. /*                        to the button (ie. KEYUP, MOUSEDBLCLK, etc.)     */
  760. /*                        returns FALSE for an error or if no such button  */
  761. /***************************************************************************/
  762. BOOL FAR PASCAL toolbarModifyActivity(HWND hwnd, int iButton, int iActivity)
  763. {
  764. HANDLE h;
  765. TOOLBUTTON far  *lpButton;
  766. int cButtons, i;
  768. /* Get the button array */
  769. h = GETARRAYBUTT(hwnd);
  770. if (!h)
  771. return FALSE;
  773. /* How many buttons */
  774. cButtons = GETNUMBUTTONS(hwnd);
  776. lpButton = (TOOLBUTTON far *)GlobalLock(h);
  778. /* loop through and change the right one */
  779. for (i = 0; i < cButtons; i++, lpButton++)
  780. if (lpButton->iButton == iButton) {
  781. lpButton->iActivity = iActivity;
  782. break;
  783. }
  785. GlobalUnlock(h);
  786. return TRUE;
  787. }
  791. /***************************************************************************/
  792. /* toolbarFixFocus:  SETWHICH() has been called to tell us which button    */
  793. /*                   has the focus, but the states of all the buttons are  */
  794. /*                   not updated (ie. take focus away from the old button) */
  795. /*                   This routine is called from the Paint routine to fix  */
  796. /*                   the states of all the buttons before drawing them.    */
  797. /*                   Returns FALSE for an error.                           */
  798. /***************************************************************************/
  799. BOOL FAR PASCAL toolbarFixFocus(HWND hwnd)
  800. {
  801. int iFocus;
  802. HANDLE h;
  803. TOOLBUTTON far *lpaButtons;
  805. /* Get the array of buttons */
  806. h = GETARRAYBUTT(hwnd);
  807. if (!h)
  808. return FALSE;
  809. lpaButtons = (TOOLBUTTON far *)GlobalLock(h);
  811.         /* if focus is on an illegal button, default to the first one */
  812. iFocus = GETWHICH(hwnd);
  813. if (iFocus < 0 || iFocus >= GETNUMBUTTONS(hwnd))
  814.     SETWHICH(hwnd, 0);
  816. /* First of all, make sure that the focus in not on a grayed button. */
  817. /* if so, we advance focus.  If it runs out of buttons without       */
  818. /* finding a non-gray one, we start back at the beginning and start  */
  819. /* looking for a non-gray one from there.  If every button is grayed,*/
  820. /* we leave no focus anywhere.      */
  821. if (lpaButtons[GETWHICH(hwnd)].iState == BTNST_GRAYED) {
  822.     if (!toolbarMoveFocus(hwnd, FALSE)) {
  823. SETWHICH(hwnd, -1);
  824. toolbarMoveFocus(hwnd, FALSE);
  825.     }
  826. }
  828. GlobalUnlock(h);
  829. return TRUE;
  830. }
  834. /***************************************************************************/
  835. /* toolbarExclusiveRadio:  For radio buttons, we need to pop all others    */
  836. /*                         in the group up when one goes down.  Pass the   */
  837. /*                         button that is going down, and its group, and   */
  838. /*                         this routine will pop all others up.            */
  839. /*                         Returns FALSE for an error.                     */
  840. /***************************************************************************/
  841. BOOL FAR PASCAL toolbarExclusiveRadio(HWND hwnd, int iType, int iButton)
  842. {
  843. int i;
  844. HANDLE h;
  845. TOOLBUTTON far *lpButton;
  847. /* Get the array of buttons */
  848. h = GETARRAYBUTT(hwnd);
  849. if (!h)
  850. return FALSE;
  851. lpButton = (TOOLBUTTON far *)GlobalLock(h);
  853. /* all buttons with this type that aren't this button come up */
  854. /* if they are not grayed */
  855. for(i = 0; i < GETNUMBUTTONS(hwnd); i++, lpButton++)
  856.     if (lpButton->iType == iType)
  857. if (lpButton->iButton != iButton &&
  858. lpButton->iState != BTNST_GRAYED) {
  859.     toolbarModifyState(hwnd, lpButton->iButton, BTNST_UP);
  860. }
  862. GlobalUnlock(h);
  863. return TRUE;
  864. }
  867. /* NotifyParent()  of activity to a button  */
  869. static void NEAR PASCAL NotifyParent(HWND hwnd, int iButton)
  870. {
  871. #ifdef _WIN32
  872.         PostMessage(
  873.             GetParent(hwnd),
  874.             WM_COMMAND,
  875.             GET_WM_COMMAND_MPS(GetWindowLong(hwnd, GWL_ID), hwnd, iButton));
  876. #else
  877. PostMessage(GetParent(hwnd),WM_COMMAND,
  878. GetWindowWord(hwnd,GWW_ID),MAKELONG(hwnd,iButton));
  879. #endif
  880. }
  883. /***************************************************************************/
  884. /* toolbarPaintControl:  Handles paint messages by blitting each bitmap    */
  885. /*                       that is on the toolbar to its rect.               */
  886. /*                       First, it fixes the states of the buttons to give */
  887. /*                       the focus to the proper button.                   */
  888. /*                       Returns FALSE for an error.                       */
  889. /***************************************************************************/
  890. static BOOL NEAR PASCAL toolbarPaintControl(HWND hwnd, HDC hdc)
  891. {
  892.     int iBtnPos; /* 0 to toolbarGetNumButtons inclusive */
  893.     int iButton; /* 0 to NUMBUTTONS-1 inclusive */
  894.     int iState; /* 0 to NUMSTATES-1 inclusive */
  895.     HDC hdcBtn; /* DC onto button bitmap */
  897.     RECT rcDest;
  898.     POINT pt;
  899.     long l;
  900.     HANDLE hbm;
  902.     /* Make a source HDC for the button pictures, and select the button */
  903.     /* bitmap into it. */
  904.     hdcBtn = CreateCompatibleDC(hdc);
  905.     if (!hdcBtn)
  906. return FALSE;
  907.     hbm = GETBMPHANDLE(hwnd);
  908.     if (hbm) {
  909. if (!SelectObject(hdcBtn, GETBMPHANDLE(hwnd))) {
  910.     DeleteDC(hdcBtn);
  911.     return FALSE;
  912. }
  913.     }
  915.     toolbarFixFocus(hwnd); // set the focus field correctly
  917.     /* Go through all buttons on the toolbar */
  918.     for (iBtnPos = 0; iBtnPos < toolbarGetNumButtons(hwnd); iBtnPos++) {
  920. iButton = toolbarButtonFromIndex(hwnd, iBtnPos); // button
  921. iState = toolbarFullStateFromButton(hwnd, iButton); // state
  922. toolbarRectFromIndex(hwnd, iBtnPos, &rcDest); // Dest Rect
  924. /* If we have the focus, we should draw it that way */
  925.         if (GetFocus() == hwnd && GETWHICH(hwnd) == iBtnPos
  926. && iState == BTNST_UP)
  927.     iState = BTNST_FOCUSUP;
  928.         if (GetFocus() == hwnd && GETWHICH(hwnd) == iBtnPos
  929. && iState == BTNST_DOWN)
  930.     iState = BTNST_FOCUSDOWN;
  932. /* If we don't have the focus, we should take it away */
  933.         if ((GetFocus() != hwnd || GETWHICH(hwnd) != iBtnPos)
  934. && iState == BTNST_FOCUSUP)
  935.     iState = BTNST_UP;
  936.         if ((GetFocus() != hwnd || GETWHICH(hwnd) == iBtnPos)
  937. && iState == BTNST_FOCUSDOWN)
  938.     iState = BTNST_DOWN;
  940. /* The size of each button */
  941. l = GETBUTTONSIZE(hwnd);
  942. pt.x = HIWORD(l);
  943. pt.y = LOWORD(l);
  945. /* Blit from the button picture to the toolbar window */
  946. BitBlt(hdc, rcDest.left, rcDest.top,
  947.     rcDest.right - rcDest.left, rcDest.bottom - rcDest.top,
  948.     hdcBtn, pt.x * iButton, pt.y * iState,
  949.     SRCCOPY);
  950.     }
  952.     DeleteDC(hdcBtn);
  954.     return TRUE;
  955. }
  960. /***************************************************************************/
  961. /* toolbarMoveFocus:  Move Focus forward or backward one button.  You give */
  962. /*                    it the direction to move the focus.  The routine will*/
  963. /*                    stop at the end of the button list without wrapping  */
  964. /*                    around.                                              */
  965. /*                    Returns TRUE if focus moved, or FALSE if it ran out  */
  966. /*                    of buttons before finding a non-grayed one.          */
  967. /***************************************************************************/
  968. BOOL FAR PASCAL toolbarMoveFocus(HWND hwnd, BOOL fBackward)
  969. {
  970. int  iBtnPos, iButton, nOffset, nStopAt;
  971. RECT rc;
  972. int iPrevPos = GETWHICH(hwnd);  /* Who used to have focus? */
  974. /* Fix illegal value.  It's OK to be one less or greater than range */
  975. if (iPrevPos < -1 || iPrevPos > GETNUMBUTTONS(hwnd))
  976.     SETWHICH(hwnd, 0); // good a default as any
  978. if (fBackward) {
  979.     nOffset = -1;
  980.     nStopAt = -1;
  981. } else {
  982.     nOffset = 1;
  983.     nStopAt = GETNUMBUTTONS(hwnd);
  984. }
  986. /* look for next button that isn't grayed    */
  987. /* DON'T wrap around - future code will pass */
  988. /* the focus to another window (???)         */
  989. for (iBtnPos = GETWHICH(hwnd) + nOffset;
  990.     iBtnPos != nStopAt;
  991.     iBtnPos += nOffset) {
  992.     iButton = toolbarButtonFromIndex(hwnd, iBtnPos);
  993.     if (toolbarStateFromButton(hwnd, iButton) !=
  994.     BTNST_GRAYED) {
  995. SETWHICH(hwnd, iBtnPos); // set focus
  997. /* Redraw both old and new focused button */
  998. toolbarRectFromIndex(hwnd, iPrevPos, &rc);
  999. InvalidateRect(hwnd, &rc, FALSE);
  1000. toolbarRectFromIndex(hwnd, iBtnPos, &rc);
  1001. InvalidateRect(hwnd, &rc, FALSE);
  1002. break;
  1004.     }
  1005. }
  1007. if (GETWHICH(hwnd) != iPrevPos)
  1008.     return TRUE;
  1009. else
  1010.     return FALSE;
  1011. }
  1013. /***************************************************************************/
  1014. /* toolbarSetFocus :  Set the focus in the toolbar to the specified button.*/
  1015. /*                    If it's gray, it'll set focus to next ungrayed btn.  */
  1016. /*                    Returns TRUE if focus set, or FALSE if the button    */
  1017. /*                    doesn't exist or if it and all buttons after it were */
  1018. /*                    grayed...       You can use TB_FIRST or TB_LAST in   */
  1019. /*                    place of a button ID.  This uses the first or last   */
  1020. /*                    un-grayed button.                                    */
  1021. /***************************************************************************/
  1022. BOOL FAR PASCAL toolbarSetFocus(HWND hwnd, int iButton)
  1023. {
  1024.     int iBtnPos;
  1025.     RECT rc;
  1027.     /* Don't move focus while a button is down */
  1028.     if (GetCapture() != hwnd && !GETKEYPRESSED(hwnd)) {
  1030. /* redraw button with focus in case focus moves */
  1031. toolbarRectFromIndex(hwnd, GETWHICH(hwnd), &rc);
  1032. InvalidateRect(hwnd, &rc, FALSE);
  1034. if (iButton == TB_FIRST) {
  1035.     SETWHICH(hwnd, -1); // move forward to 1st button
  1036.     return toolbarMoveFocus(hwnd, FALSE);
  1037. } else if (iButton == TB_LAST) {
  1038.     SETWHICH(hwnd, GETNUMBUTTONS(hwnd));
  1039.     return toolbarMoveFocus(hwnd, TRUE);
  1040. } else {
  1041.     iBtnPos = toolbarIndexFromButton(hwnd, iButton);
  1042.     if (iBtnPos != -1) {
  1043. SETWHICH(hwnd, --iBtnPos);
  1044. return toolbarMoveFocus(hwnd, FALSE);
  1045.     } else
  1046. return FALSE;
  1047. }
  1048. return TRUE;
  1050.     } else
  1051. return FALSE;
  1052. }
  1054. //
  1055. //  LoadUIBitmap() - load a bitmap resource
  1056. //
  1057. //      load a bitmap resource from a resource file, converting all
  1058. //      the standard UI colors to the current user specifed ones.
  1059. //
  1060. //      this code is designed to load bitmaps used in "gray ui" or
  1061. //      "toolbar" code.
  1062. //
  1063. //      the bitmap must be a 4bpp windows 3.0 DIB, with the standard
  1064. //      VGA 16 colors.
  1065. //
  1066. //      the bitmap must be authored with the following colors
  1067. //
  1068. //          Button Text        Black        (index 0)
  1069. //          Button Face        lt gray      (index 7)
  1070. //          Button Shadow      gray         (index 8)
  1071. //          Button Highlight   white        (index 15)
  1072. //          Window Color       yellow       (index 11)
  1073. //          Window Frame       green        (index 10)
  1074. //
  1075. //      Example:
  1076. //
  1077. //          hbm = LoadUIBitmap(hInstance, "TestBmp",
  1078. //              GetSysColor(COLOR_BTNTEXT),
  1079. //              GetSysColor(COLOR_BTNFACE),
  1080. //              GetSysColor(COLOR_BTNSHADOW),
  1081. //              GetSysColor(COLOR_BTNHIGHLIGHT),
  1082. //              GetSysColor(COLOR_WINDOW),
  1083. //              GetSysColor(COLOR_WINDOWFRAME));
  1084. //
  1085. //      Author:     JimBov, ToddLa
  1086. //
  1087. //
  1089. HBITMAP FAR PASCAL  LoadUIBitmap(
  1090.     HANDLE      hInstance,          // EXE file to load resource from
  1091.     LPCSTR      szName,             // name of bitmap resource
  1092.     COLORREF    rgbText,            // color to use for "Button Text"
  1093.     COLORREF    rgbFace,            // color to use for "Button Face"
  1094.     COLORREF    rgbShadow,          // color to use for "Button Shadow"
  1095.     COLORREF    rgbHighlight,       // color to use for "Button Hilight"
  1096.     COLORREF    rgbWindow,          // color to use for "Window Color"
  1097.     COLORREF    rgbFrame)           // color to use for "Window Frame"
  1098. {
  1099.     LPBYTE              lpb;
  1100.     HBITMAP             hbm;
  1101.     LPBITMAPINFOHEADER  lpbi;
  1102.     HANDLE              h;
  1103.     HDC                 hdc;
  1104.     LPDWORD             lprgb;
  1105.     int isize;
  1106.     HANDLE hmem;
  1107.     LPBYTE lpCopy;
  1109.     // convert a RGB into a RGBQ
  1110.     #define RGBQ(dw) RGB(GetBValue(dw),GetGValue(dw),GetRValue(dw))
  1112.     h = LoadResource (hInstance,FindResource(hInstance, szName, RT_BITMAP));
  1114.     lpbi = (LPBITMAPINFOHEADER)LockResource(h);
  1116.     if (!lpbi)
  1117.         return(NULL);
  1119.     if (lpbi->biSize != sizeof(BITMAPINFOHEADER))
  1120.         return NULL;
  1122.     if (lpbi->biBitCount != 4)
  1123.         return NULL;
  1125.     /*
  1126.      * copy the resource since they are now loaded read-only
  1127.      */
  1128. #ifdef _WIN32
  1129.     isize = lpbi->biSize + lpbi->biSizeImage +
  1130.             ((int)lpbi->biClrUsed ?
  1131.                     (int)lpbi->biClrUsed :
  1132.                     (1 << (int)lpbi->biBitCount))
  1133.             * sizeof(RGBQUAD);
  1134.     hmem = GlobalAlloc(GHND, isize);
  1135.     lpCopy = GlobalLock(hmem);
  1136.     if ((hmem == NULL) || (lpCopy == NULL)) {
  1137.         UnlockResource(h);
  1138.         FreeResource(h);
  1139.         return(NULL);
  1140.     }
  1143.     CopyMemory(lpCopy, lpbi, isize);
  1144.     UnlockResource(h);
  1145.     FreeResource(h);
  1147.     lpbi = (LPBITMAPINFOHEADER)lpCopy;
  1148. #endif
  1150.     /* Calcluate the pointer to the Bits information */
  1151.     /* First skip over the header structure */
  1153.     lprgb = (LPDWORD)((LPBYTE)(lpbi) + lpbi->biSize);
  1155.     /* Skip the color table entries, if any */
  1156.     lpb = (LPBYTE)lprgb + ((int)lpbi->biClrUsed ? (int)lpbi->biClrUsed :
  1157.         (1 << (int)lpbi->biBitCount)) * sizeof(RGBQUAD);
  1159.     lprgb[0]  = RGBQ(rgbText);          // Black
  1160.     lprgb[7]  = RGBQ(rgbFace);          // lt gray
  1161.     lprgb[8]  = RGBQ(rgbShadow);        // gray
  1162.     lprgb[15] = RGBQ(rgbHighlight);     // white
  1163.     lprgb[11] = RGBQ(rgbWindow);        // yellow
  1164.     lprgb[10] = RGBQ(rgbFrame);         // green
  1166.     hdc = GetDC(NULL);
  1168.     hbm = CreateDIBitmap (hdc, lpbi, CBM_INIT, (LPVOID)lpb,
  1169.         (LPBITMAPINFO)lpbi, DIB_RGB_COLORS);
  1171.     ReleaseDC(NULL, hdc);
  1172.     UnlockResource(h);
  1173.     FreeResource(h);
  1175.     return(hbm);
  1176. }
  1178. /****************************************************************************
  1179. toolbarWndProc()
  1181. Window proc for toolbar.
  1183. Arguments:
  1184. Standard window proc
  1185. ****************************************************************************/
  1187. LONG FAR PASCAL toolbarWndProc(HWND hwnd, unsigned message,
  1188. UINT wParam, LONG lParam)
  1189. {
  1190.     PAINTSTRUCT ps;
  1191.     POINT pt;
  1192.     RECT rc;
  1193.     int iBtnPos, iButton, ibmp;
  1194.     HANDLE lpaButtons, hbm, hInst;
  1196.     switch (message) {
  1198.         case WM_CREATE: // do all initialization
  1200. /* What do these do? */
  1201. SetWindowPos(hwnd, NULL, 0, 0, 0, 0,
  1202.      SWP_NOZORDER | SWP_NOSIZE |
  1203. SWP_NOMOVE | SWP_NOACTIVATE);
  1204. SetWindowLong(hwnd,GWL_STYLE,lpCreate->style & 0xFFFF00FF);
  1206. /* Alloc some space for the array of buttons on this bar */
  1207. lpaButtons = GlobalAlloc(GMEM_MOVEABLE | GMEM_SHARE,
  1208. TOOLGROW * sizeof(TOOLBUTTON));
  1210. SETARRAYBUTT(hwnd, lpaButtons); // list of buttons on toolbar
  1211. SETNUMBUTTONS(hwnd, 0); // # buttons in toolbar
  1212. SETPRESSED(hwnd, FALSE); // mouse button being pressed?
  1213. SETKEYPRESSED(hwnd, FALSE); // is a key being pressed?
  1214. SETWHICH(hwnd, -1); // which button has the focus?
  1215. SETSHIFTED(hwnd, FALSE); // shift-click or right-click?
  1217. /* This wParam will be sent to the parent window to indentify */
  1218. /* that the toolbar sent the WM_COMMAND msg.  The hwnd of the */
  1219. /* toolbar that sent the msg will be in the lParam.       */
  1220. #ifdef _WIN32
  1221. SetWindowLong(hwnd, GWL_ID, IDC_TOOLBAR);
  1222. #else
  1223. SetWindowWord(hwnd, GWW_ID, (WORD)IDC_TOOLBAR);
  1224. #endif
  1226. /* later on, someone will set the bmp handle of the buttons */
  1227. SETBMPHANDLE(hwnd, NULL);
  1229. break;
  1231.         case WM_LBUTTONDOWN: // button goes down on a toolbar button
  1232.         case WM_RBUTTONDOWN:
  1233.         case WM_LBUTTONDBLCLK:
  1234.         case WM_RBUTTONDBLCLK:
  1236. /* If we don't give ourself focus, we'll never get KEYDOWN */
  1237. /* or KEYUP messages.    */
  1238. /* Get the focus only if we're a TABSTOP and the app wants */
  1239. /* us to take focus.    */
  1240. if ( (GetWindowLong(hwnd, GWL_STYLE) & WS_TABSTOP)
  1241. && GetFocus() != hwnd)
  1242.     SetFocus(hwnd);
  1244. /* ignore messages if window is disabled */
  1245. if (!IsWindowEnabled(hwnd))
  1246.     return 0L;
  1248. /* ignore multiple down messages (we set Capture here) */
  1249. /* also ignore if a key is down                        */
  1250. if (GetCapture() == hwnd || GETPRESSED(hwnd))
  1251.     return 0L;
  1253. /* Where did the mouse go down? */
  1254.                 pt.x = (short)LOWORD(lParam);
  1255.                 pt.y = (short)HIWORD(lParam);
  1257. /* which button was pressed? */
  1258. iBtnPos = toolbarIndexFromPoint(hwnd, pt);
  1260. /* If it was a valid button... */
  1261. if (iBtnPos >= 0) {
  1262.     int iOldPos;
  1263.     int iState, iType, iButton;
  1265.     /* Everything you wanted to know about this button */
  1266.     iType = toolbarTypeFromIndex(hwnd, iBtnPos);
  1267.     iButton = toolbarButtonFromIndex(hwnd, iBtnPos);
  1268.     iState = toolbarFullStateFromButton(hwnd, iButton);
  1270.     /* ignore downs on a grayed button, unless it's a */
  1271.     /* custom button, then tell them anyway */
  1272.     if (iType != BTNTYPE_CUSTOM && iState == BTNST_GRAYED)
  1273. return 0;
  1275.     /* We better get all mouse messages from now on */
  1276.     SetCapture(hwnd);
  1278.     /* Shift key or right button indicates a SHIFT down */
  1279.     SETSHIFTED(hwnd, (message == WM_RBUTTONDOWN) ||
  1280.     (wParam & MK_SHIFT));
  1282.     /* Yes, we've pressed the button down */
  1283.     SETPRESSED(hwnd, TRUE);
  1285.     /* Remember who used to have the focus, and we get it now */
  1286.     iOldPos = GETWHICH(hwnd);
  1287.     SETWHICH(hwnd, iBtnPos);
  1289.     /* For a push button, send it down */
  1290.     if (iType == BTNTYPE_PUSH)
  1291. toolbarModifyState(hwnd, iButton, BTNST_DOWN);
  1293.     /* for a checkbox or radio button (of any group),       */
  1294.     /* remember what state it was in, and send it FULL down */
  1295.     /* (with focus).     */
  1296.     if (iType == BTNTYPE_CHECKBOX || iType >= BTNTYPE_RADIO) {
  1297. toolbarModifyPrevState(hwnd, iButton, iState);
  1298. toolbarModifyState(hwnd,iButton,BTNST_FULLDOWN);
  1299.     }
  1301.     toolbarModifyActivity(hwnd, iButton, BTNACT_MOUSEDOWN);
  1303.     /* Set Double click flag appropriately */
  1304.     if (message == WM_LBUTTONDBLCLK ||
  1305. message == WM_RBUTTONDBLCLK)
  1306. NotifyParent(hwnd, (GETSHIFTED(hwnd) ? BTN_SHIFT : 0)
  1307.  + BTN_DBLCLICK + iButton);
  1308.     else
  1309. NotifyParent(hwnd, (GETSHIFTED(hwnd) ? BTN_SHIFT : 0)
  1310.  + iButton);
  1312.     /* Invalidate the Rect of the button being pressed */
  1313.     toolbarRectFromIndex(hwnd, iBtnPos, &rc);
  1314.     InvalidateRect(hwnd, &rc, FALSE);
  1316.     /* Invalidate the Rect of the button losing focus */
  1317.     toolbarRectFromIndex(hwnd, iOldPos, &rc);
  1318.     InvalidateRect(hwnd, &rc, FALSE);
  1320.     /* Force re-paint now */
  1321.     UpdateWindow(hwnd);
  1323.     /* Set a timer for repeated mouse downs */
  1324.     SetTimer(hwnd, TIMER_BUTTONREPEAT,
  1325.  MSEC_BUTTONREPEAT, NULL);
  1326. }
  1328. return 0L;
  1330.         case WM_MOUSEMOVE:
  1332. #if 0
  1333. /* This should be impossible - it means that the system lost */
  1334. /* a mouse up (maybe codeview is up?) We need to force a     */
  1335. /* mouse up at this point.      */
  1336. if (GetCapture() == hwnd &&
  1337. (wParam & (MK_LBUTTON | MK_RBUTTON) == 0))
  1338.     SendMessage(hwnd, WM_LBUTTONUP, 0, lParam);
  1339. #endif
  1341. /* Mouse moving while pressing a button?  If not, ignore. */
  1342. if (GetCapture() == hwnd) {
  1343.     int iPrevState, iState, iButton, iType;
  1344.     BOOL fPressed;
  1346.     /* Which button is being pressed down? */
  1347.     iBtnPos = GETWHICH(hwnd);
  1349.     /* Where is mouse cursor now? */
  1350.                     pt.x = (short)LOWORD(lParam);
  1351.                     pt.y = (short)HIWORD(lParam);
  1353.     /* where is button being pressed? Are we still on */
  1354.     /* top of that button or have we moved?       */
  1355.     toolbarRectFromIndex(hwnd, iBtnPos, &rc);
  1356.     fPressed = PtInRect(&rc, pt);
  1358.     /* Let go if we move off of the button, but don't */
  1359.     /* act like it was pressed.                       */
  1360.     /* Also, push it back down if we move back on top */
  1361.     /* of it (while the mouse button is STILL down).  */
  1362.     if (fPressed != GETPRESSED(hwnd)) {
  1364. /* update: is this button pressed anymore? */
  1365. SETPRESSED(hwnd, fPressed);
  1367. iType = toolbarTypeFromIndex(hwnd, iBtnPos);
  1368. iButton = toolbarButtonFromIndex(hwnd, iBtnPos);
  1369. iState = toolbarFullStateFromButton(hwnd, iButton);
  1371. /* The mouse moved back onto the button while */
  1372. /* the mouse button was still pressed.       */
  1373. if (fPressed) {
  1375.     /* Push the push button back down again */
  1376.       if (iType == BTNTYPE_PUSH)
  1377. toolbarModifyState(hwnd, iButton,
  1378. BTNST_DOWN);
  1380.     /* Push the radio or checkbox button ALL the */
  1381.     /* way down again.  */
  1382.     if (iType >= BTNTYPE_RADIO ||
  1383. iType == BTNTYPE_CHECKBOX)
  1384. toolbarModifyState(hwnd, iButton,
  1385. BTNST_FULLDOWN);
  1387.     toolbarModifyActivity(hwnd, iButton,
  1388. BTNACT_MOUSEMOVEON);
  1389.     NotifyParent(hwnd,
  1390. (GETSHIFTED(hwnd) ? BTN_SHIFT : 0) +
  1391. iButton);
  1393. /* We moved the mouse off of the toolbar button */
  1394. /* while still holding the mouse button down.   */
  1395. } else {
  1397.     /* lift the push button up */
  1398.       if (iType == BTNTYPE_PUSH)
  1399. toolbarModifyState(hwnd, iButton,
  1400. BTNST_UP);
  1402.     /* Restore radio button or checkbox button to */
  1403.     /* where it was before pressed   */
  1404.     if (iType >= BTNTYPE_RADIO ||
  1405. iType == BTNTYPE_CHECKBOX) {
  1406. iPrevState = toolbarPrevStateFromButton(hwnd,
  1407. iButton);
  1408. toolbarModifyState(hwnd, iButton, iPrevState);
  1409.     }
  1411.     toolbarModifyActivity(hwnd, iButton,
  1412. BTNACT_MOUSEMOVEOFF);
  1413.     NotifyParent(hwnd,
  1414. (GETSHIFTED(hwnd) ? BTN_SHIFT : 0) +
  1415. toolbarButtonFromIndex(hwnd, iBtnPos));
  1416. }
  1417.     }
  1418. }
  1419. return 0L;
  1421.         case WM_LBUTTONUP:
  1422.         case WM_RBUTTONUP:
  1424. /* If we don't have capture, we aren't expecting this. Ignore */
  1425. if (GetCapture() == hwnd) {
  1426.     int iPrevState, iState, iButton, iType;
  1428.     /* Who has the focus? */
  1429.     iBtnPos = GETWHICH(hwnd);
  1431.     /* Release the mouse */
  1432.     ReleaseCapture();
  1434.     /* No more repeats of the mouse button downs */
  1435.     KillTimer(hwnd, TIMER_BUTTONREPEAT);
  1437.     /* Everything you wanted to know about the button */
  1438.     toolbarRectFromIndex(hwnd, iBtnPos, &rc);
  1439.     iType = toolbarTypeFromIndex(hwnd, iBtnPos);
  1440.     iButton = toolbarButtonFromIndex(hwnd, iBtnPos);
  1441.     iState = toolbarFullStateFromButton(hwnd, iButton);
  1443.     /* Don't do anything if we've moved off the button */
  1444.     if (GETPRESSED(hwnd)) {
  1446. /* No longer down */
  1447. SETPRESSED(hwnd, FALSE);
  1449. /* Bring the push button up */
  1450. if (iType == BTNTYPE_PUSH)
  1451.     toolbarModifyState(hwnd, iButton, BTNST_UP);
  1453. /* Bring the checkbox to the opposite state it was in */
  1454. if (iType == BTNTYPE_CHECKBOX) {
  1455.     iPrevState = toolbarPrevStateFromButton(hwnd,
  1456. iButton);
  1457.     if (iPrevState == BTNST_DOWN)
  1458. toolbarModifyState(hwnd, iButton, BTNST_UP);
  1459.     if (iPrevState == BTNST_UP)
  1460. toolbarModifyState(hwnd, iButton, BTNST_DOWN);
  1461. }
  1463. /* Force a radio button down, and bring all   */
  1464. /* other radio buttons of this type up       */
  1465. if (iType >= BTNTYPE_RADIO) {
  1466.     toolbarModifyState(hwnd, iButton, BTNST_DOWN);
  1467.     toolbarExclusiveRadio(hwnd, iType, iButton);
  1468. }
  1470. /* Notify the parent that the mouse button came up */
  1471. /* on this button so the app can do something.     */
  1472. /* Every button should notify the app, not just a  */
  1473. /* custom button.    */
  1474. toolbarModifyActivity(hwnd, iButton, BTNACT_MOUSEUP);
  1475. NotifyParent(hwnd,
  1476.     (GETSHIFTED(hwnd) ? BTN_SHIFT : 0) + iButton);
  1477.     }
  1478. }
  1480. return 0L;
  1483. case WM_TIMER:
  1485. /* If we have a tool button down, send a repeat message */
  1486. if (GETPRESSED(hwnd)) {
  1487.     int iButton, iType;
  1489.     iBtnPos = GETWHICH(hwnd);
  1490.     iButton = toolbarButtonFromIndex(hwnd, iBtnPos);
  1491.     iType = toolbarTypeFromIndex(hwnd, iBtnPos);
  1493.     NotifyParent(hwnd, BTN_REPEAT +
  1494. (GETSHIFTED(hwnd) ? BTN_SHIFT : 0) +
  1495. toolbarButtonFromIndex(hwnd, iBtnPos));
  1496. }
  1497. break;
  1500.         case WM_DESTROY:
  1501. if (GETBMPHANDLE(hwnd))
  1502.     DeleteObject(GETBMPHANDLE(hwnd));
  1503. SETBMPHANDLE(hwnd, NULL);
  1504. if (GETARRAYBUTT(hwnd))
  1505.     GlobalFree(GETARRAYBUTT(hwnd));
  1506. SETARRAYBUTT(hwnd, NULL);
  1507. break;
  1509.         case WM_SETTEXT:
  1510. break;
  1512. /* MANY, MANY cases deleted */
  1514. case WM_SETFOCUS: // focus comes to toolbar window
  1515.     {
  1516. /* Remember who had the focus and give it back.  Of course, */
  1517. /* if by some wierdness that button is now grayed, give it  */
  1518. /* to the next person in line.     */
  1519. iBtnPos = GETWHICH(hwnd);
  1520. if (iBtnPos < 0 || iBtnPos >= toolbarGetNumButtons(hwnd)) {
  1521.     iBtnPos = 0;
  1522.     SETWHICH(hwnd, 0);
  1523. }
  1525. do {
  1526.     iButton = toolbarButtonFromIndex(hwnd, iBtnPos);
  1527.     if (toolbarFullStateFromButton(hwnd, iButton)
  1528. != BTNST_GRAYED)
  1529. break; // give it here
  1530.     iBtnPos++;
  1531.     if (iBtnPos >= toolbarGetNumButtons(hwnd))
  1532. iBtnPos = 0; // wrap around
  1533.     if (iBtnPos == GETWHICH(hwnd))
  1534. return 0L; // uh-oh! They're all gray!
  1535. } while (iBtnPos != GETWHICH(hwnd));
  1537. SETWHICH(hwnd, iBtnPos); // give focus here
  1539. /* And redraw! */
  1540. toolbarRectFromIndex(hwnd, iBtnPos, &rc);
  1541. InvalidateRect(hwnd, &rc, FALSE);
  1542. UpdateWindow(hwnd);
  1543. return 0;
  1544.     }
  1546. case WM_KILLFOCUS:
  1548. /* Send a KEYUP if one is pending */
  1549. if (GETKEYPRESSED(hwnd))
  1550.     SendMessage(hwnd, WM_KEYUP, VK_SPACE, 0L);
  1552. /* Redraw the focused button, because now that focus is gone */
  1553. /* from our toolbar window, the focused button won't be      */
  1554. /* focused anymore, although we remember which one it was.   */
  1555. toolbarRectFromIndex(hwnd, GETWHICH(hwnd), &rc);
  1556. InvalidateRect(hwnd, &rc, FALSE);
  1557. UpdateWindow(hwnd);
  1558. return 0;
  1560. case WM_SYSKEYDOWN:
  1561. /* Send a KEYUP if one is pending */
  1562. if (GETKEYPRESSED(hwnd))
  1563.     SendMessage(hwnd, WM_KEYUP, VK_SPACE, 0L);
  1564. break; // MUST LET DEFWNDPROC RUN!!! (to handle the key)
  1566.         case WM_GETDLGCODE:
  1567. return DLGC_WANTARROWS | DLGC_WANTTAB;
  1569. case WM_KEYDOWN:
  1571. /* Window disabled or a key is already down */
  1572. if (IsWindowEnabled(hwnd) && !GETPRESSED(hwnd)) {
  1574.     /* Tab forward to next button and move focus there */
  1575.     if (wParam == VK_TAB && GetKeyState(VK_SHIFT) >= 0 ) {
  1577. /* Move Focus forward one.  If */
  1578. /* we've tabbed off of the toolbar, it's time */
  1579. /* to go on to the next control. We need to invldte */
  1580. /* because we might be the only control and we need */
  1581. /* to repaint to show the new button with highlight */
  1582. /* after it wrapped around the end of the toolbar.  */
  1583. if (!toolbarMoveFocus(hwnd, FALSE)) {
  1584.     PostMessage(GetParent(hwnd), WM_NEXTDLGCTL, 0, 0L);
  1585.     toolbarRectFromIndex(hwnd, GETWHICH(hwnd), &rc);
  1586.     InvalidateRect(hwnd, &rc, FALSE);
  1587. }
  1589. return 0L;
  1590.     }
  1591.     if (wParam == VK_TAB && GetKeyState(VK_SHIFT) < 0 ) {
  1593. /* Move focus backward one.  If */
  1594. /* We've tabbed off of the toolbar, it's time    */
  1595. /* to go on to the next control. We need to invldte */
  1596. /* because we might be the only control and we need */
  1597. /* to repaint to show the new button with highlight */
  1598. /* after it wrapped around the end of the toolbar.  */
  1599. if (!toolbarMoveFocus(hwnd, TRUE)) {
  1600.     PostMessage(GetParent(hwnd), WM_NEXTDLGCTL, 1, 0L);
  1601.     toolbarRectFromIndex(hwnd, GETWHICH(hwnd), &rc);
  1602.     InvalidateRect(hwnd, &rc, FALSE);
  1603. }
  1605. return 0L;
  1606.     }
  1607.     if ((wParam == VK_SPACE) && (GetCapture() != hwnd)) {
  1609. int iButton, iType, iState;
  1611. /* Same as mouse button down -- Press the button! */
  1612. iBtnPos = GETWHICH(hwnd);
  1613. iType = toolbarTypeFromIndex(hwnd, iBtnPos);
  1614. iButton = toolbarButtonFromIndex(hwnd, iBtnPos);
  1615. iState = toolbarFullStateFromButton(hwnd, iButton);
  1617. /* ignore multiple key downs */
  1618. if (!GETKEYPRESSED(hwnd)) {
  1620.     SETKEYPRESSED(hwnd, TRUE); // a key is pressed
  1622.     SETSHIFTED(hwnd, FALSE); // NEVER shifted
  1623.     SETPRESSED(hwnd, TRUE); // a button is pressed
  1625.     /* Push button goes down - with focus */
  1626.     if (iType == BTNTYPE_PUSH)
  1627. toolbarModifyState(hwnd, iButton, BTNST_DOWN);
  1629.     /* Radio or checkbox button goes full down */
  1630.     /* with focus - and remember previous state*/
  1631.     if (iType >= BTNTYPE_RADIO ||
  1632. iType == BTNTYPE_CHECKBOX) {
  1633. toolbarModifyPrevState(hwnd, iButton, iState);
  1634. toolbarModifyState(hwnd, iButton,
  1635. BTNST_FULLDOWN);
  1636.     }
  1638.     toolbarModifyActivity(hwnd, iButton,
  1639. BTNACT_KEYDOWN);
  1640.     NotifyParent(hwnd, (GETSHIFTED(hwnd)
  1641. ? BTN_SHIFT : 0) + iButton);
  1643.     return 0L;
  1644. }
  1646. /* If this is another KEYDOWN msg, it's a REPEAT */
  1647. /* Notify parent.                                */
  1648. NotifyParent(hwnd, BTN_REPEAT +
  1649. (GETSHIFTED(hwnd) ? BTN_SHIFT : 0) +
  1650. toolbarButtonFromIndex(hwnd,
  1651. GETWHICH(hwnd)));
  1652.     }
  1653. }
  1654. break;
  1656. case WM_KEYUP:
  1658. /* A button was pressed and should come up now */
  1659. if ((wParam == VK_SPACE) && (GETKEYPRESSED(hwnd))) {
  1660.     int iButton, iState, iType, iPrevState;
  1662.     iBtnPos = GETWHICH(hwnd); // which button?
  1663.     SETKEYPRESSED(hwnd, FALSE); // let go
  1664.     SETPRESSED(hwnd, FALSE);
  1666.     /* Everything about this button */
  1667.     toolbarRectFromIndex(hwnd, iBtnPos, &rc);
  1668.     iType = toolbarTypeFromIndex(hwnd, iBtnPos);
  1669.     iButton = toolbarButtonFromIndex(hwnd, iBtnPos);
  1670.     iState = toolbarFullStateFromButton(hwnd, iButton);
  1672.     /* Bring a push button up */
  1673.     if (iType == BTNTYPE_PUSH)
  1674. toolbarModifyState(hwnd, iButton, BTNST_UP);
  1676.     /* Bring a checkbox to the opposite state it was in */
  1677.     if (iType == BTNTYPE_CHECKBOX) {
  1678. iPrevState = toolbarPrevStateFromButton(hwnd, iButton);
  1679. if (iPrevState == BTNST_DOWN)
  1680.     toolbarModifyState(hwnd, iButton, BTNST_UP);
  1681. if (iPrevState == BTNST_UP)
  1682.     toolbarModifyState(hwnd, iButton, BTNST_DOWN);
  1683.     }
  1685.     /* Bring a radio button down, and bring all others in */
  1686.     /* its group up.   */
  1687.     if (iType >= BTNTYPE_RADIO) {
  1688. toolbarModifyState(hwnd, iButton, BTNST_DOWN);
  1689. toolbarExclusiveRadio(hwnd, iType, iButton);
  1690.     }
  1692.     toolbarModifyActivity(hwnd, iButton, BTNACT_KEYUP);
  1693.     NotifyParent(hwnd, toolbarButtonFromIndex(hwnd,
  1694. (GETSHIFTED(hwnd) ? BTN_SHIFT : 0) +
  1695. GETWHICH(hwnd)));
  1696. }
  1697. break;
  1699. case WM_SYSCOLORCHANGE:
  1700. /* load the bitmap of what all the buttons look like */
  1701. /* and change the colours to the system colours.     */
  1702. hInst = GETHINST(hwnd);
  1703. ibmp = GETBMPINT(hwnd);
  1704. hbm = GETBMPHANDLE(hwnd);
  1705. if (hbm)
  1706.     DeleteObject(hbm);
  1707. hbm = LoadUIBitmap(hInst, MAKEINTRESOURCE(ibmp),
  1708.     GetSysColor(COLOR_BTNTEXT),
  1709.     GetSysColor(COLOR_BTNFACE),
  1710.     GetSysColor(COLOR_BTNSHADOW),
  1711.     GetSysColor(COLOR_BTNHIGHLIGHT),
  1712.     GetSysColor(COLOR_BTNFACE),
  1713.     GetSysColor(COLOR_WINDOWFRAME));
  1714. SETBMPHANDLE(hwnd, hbm);
  1715. #ifdef _WIN32
  1716. return (long) hbm;
  1717. #else
  1718. return MAKELONG(hbm, 0);
  1719. #endif
  1721.         case WM_ERASEBKGND:
  1722. break;
  1725.         case WM_PAINT:
  1727. /* Call our paint code */
  1728. BeginPaint(hwnd, &ps);
  1729. toolbarPaintControl(hwnd, ps.hdc);
  1730. EndPaint(hwnd, &ps);
  1732. return 0L;
  1733.     }
  1735.     return DefWindowProc(hwnd, message, wParam, lParam);
  1737. }