Return to toolbox.c CVS log

Up to [WindowsNT SDKs] / mstools / samples / sdktools / dlgedit

Annotation of mstools/samples/sdktools/dlgedit/toolbox.c, revision 1.1

1.1     ! root        1: 
        !             2: /******************************************************************************\
        !             3: *       This is a part of the Microsoft Source Code Samples. 
        !             4: *       Copyright (C) 1993 Microsoft Corporation.
        !             5: *       All rights reserved. 
        !             6: *       This source code is only intended as a supplement to 
        !             7: *       Microsoft Development Tools and/or WinHelp documentation.
        !             8: *       See these sources for detailed information regarding the 
        !             9: *       Microsoft samples programs.
        !            10: \******************************************************************************/
        !            11: 
        !            12: /****************************** Module Header *******************************
        !            13: * Module Name: toolbox.c
        !            14: *
        !            15: * Contains routines that handle the toolbox.
        !            16: *
        !            17: * Functions:
        !            18: *
        !            19: *    ToolboxShow()
        !            20: *    ToolboxOnTop()
        !            21: *    ToolboxWndProc()
        !            22: *    ToolBtnWndProc()
        !            23: *    ToolboxSelectTool()
        !            24: *    ToolboxCreate()
        !            25: *    ToolboxDrawBitmap()
        !            26: *
        !            27: * Comments:
        !            28: *
        !            29: ****************************************************************************/
        !            30: 
        !            31: #include "dlgedit.h"
        !            32: #include "dlgfuncs.h"
        !            33: #include "dlgextrn.h"
        !            34: 
        !            35: #include "dialogs.h"
        !            36: 
        !            37: 
        !            38: #define TOOLBOXMARGIN   2       // Pixels around the buttons in the Toolbox.
        !            39: #define TOOLBOXCOLUMNS  2       // Columns in the Toolbox.
        !            40: 
        !            41: /*
        !            42:  * Style of the toolbox window.
        !            43:  */
        !            44: #define TOOLBOXSTYLE    (WS_POPUP | WS_CLIPSIBLINGS | WS_CAPTION | WS_SYSMENU)
        !            45: 
        !            46: STATICFN VOID ToolboxCreate(VOID);
        !            47: STATICFN VOID ToolboxDrawBitmap(HDC hDC, INT type);
        !            48: 
        !            49: /*
        !            50:  * Dimensions of a tool button bitmap.
        !            51:  */
        !            52: static INT cxToolBtn;
        !            53: static INT cyToolBtn;
        !            54: 
        !            55: 
        !            56: 
        !            57: /****************************************************************************
        !            58: * ToolboxShow
        !            59: *
        !            60: * This function shows or hides the toolbox window.  It will create
        !            61: * the Toolbox if necessary.
        !            62: *
        !            63: * Arguments:
        !            64: *   BOOL fShow - whether to show or hide the toolbox window.
        !            65: *
        !            66: ****************************************************************************/
        !            67: 
        !            68: VOID ToolboxShow(
        !            69:     BOOL fShow)
        !            70: {
        !            71:     if (fShow) {
        !            72:         /*
        !            73:          * Don't allow a toolbox to be shown in Translate mode.
        !            74:          */
        !            75:         if (gfTranslateMode)
        !            76:             return;
        !            77: 
        !            78:         /*
        !            79:          * Create it if it doesn't exist yet.
        !            80:          */
        !            81:         if (!ghwndToolbox)
        !            82:             ToolboxCreate();
        !            83: 
        !            84:         if (ghwndToolbox)
        !            85:             ShowWindow(ghwndToolbox, SW_SHOWNA);
        !            86:     }
        !            87:     else {
        !            88:         if (ghwndToolbox)
        !            89:             ShowWindow(ghwndToolbox, SW_HIDE);
        !            90:     }
        !            91: }
        !            92: 
        !            93: 
        !            94: 
        !            95: /****************************************************************************
        !            96: * ToolboxOnTop
        !            97: *
        !            98: * This function positions the toolbox window on top.  It needs to be
        !            99: * called any time that a new dialog window is created to be sure the
        !           100: * dialog does not cover the toolbox.
        !           101: *
        !           102: * It can be called even if the toolbox is not created yet (it will
        !           103: * be a noop in that case).
        !           104: *
        !           105: ****************************************************************************/
        !           106: 
        !           107: VOID ToolboxOnTop(VOID)
        !           108: {
        !           109:    if (ghwndToolbox) {
        !           110:        SetWindowPos(ghwndToolbox, NULL, 0, 0, 0, 0,
        !           111:                SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE);
        !           112:    }
        !           113: }
        !           114: 
        !           115: 
        !           116: 
        !           117: /****************************************************************************
        !           118: * ToolboxCreate
        !           119: *
        !           120: * This function creates the toolbox window.
        !           121: *
        !           122: ****************************************************************************/
        !           123: 
        !           124: STATICFN VOID ToolboxCreate(VOID)
        !           125: {
        !           126:     BITMAP bmp;
        !           127:     INT i;
        !           128:     INT x;
        !           129:     INT y;
        !           130:     INT cx;
        !           131:     INT cy;
        !           132:     INT cxDummy;
        !           133:     INT cyDummy;
        !           134:     RECT rc;
        !           135:     RECT rcSubClient;
        !           136:     BOOL fMaximized;
        !           137: 
        !           138:     /*
        !           139:      * Load the bitmaps.
        !           140:      */
        !           141:     if (!(ghbmPointerToolUp = LoadBitmap(ghInst,
        !           142:             MAKEINTRESOURCE(IDBM_TUPOINTR))) ||
        !           143:             !(ghbmPointerToolDown = LoadBitmap(ghInst,
        !           144:             MAKEINTRESOURCE(IDBM_TDPOINTR))))
        !           145:         return;
        !           146: 
        !           147:     for (i = 0; i < CCONTROLS; i++) {
        !           148:         if (!(awcd[i].hbmToolBtnUp = LoadBitmap(ghInst,
        !           149:                 MAKEINTRESOURCE(awcd[i].idbmToolBtnUp))))
        !           150:             return;
        !           151: 
        !           152:         if (!(awcd[i].hbmToolBtnDown = LoadBitmap(ghInst,
        !           153:                 MAKEINTRESOURCE(awcd[i].idbmToolBtnDown))))
        !           154:             return;
        !           155:     }
        !           156: 
        !           157:     /*
        !           158:      * Get the dimensions of the tool button bitmaps.
        !           159:      */
        !           160:     GetObject(awcd[0].hbmToolBtnUp, sizeof(BITMAP), &bmp);
        !           161:     cxToolBtn = bmp.bmWidth;
        !           162:     cyToolBtn = bmp.bmHeight;
        !           163: 
        !           164:     /*
        !           165:      * Calculate the required window size for the client area
        !           166:      * size we want.  The size leaves room for a margin, and
        !           167:      * assumes that adjacent buttons overlap their borders by
        !           168:      * one pixel.
        !           169:      */
        !           170:     rc.left = 0;
        !           171:     rc.top = 0;
        !           172:     rc.right = TOOLBOXMARGIN + ((cxToolBtn - 1) * 2) + 1 + TOOLBOXMARGIN;
        !           173:     rc.bottom = TOOLBOXMARGIN + ((cyToolBtn - 1) *
        !           174:             ((CCONTROLS / 2) + 1)) + 1 + TOOLBOXMARGIN;
        !           175:     AdjustWindowRect(&rc, TOOLBOXSTYLE, FALSE);
        !           176:     cx = rc.right - rc.left;
        !           177:     cy = rc.bottom - rc.top;
        !           178: 
        !           179:     /*
        !           180:      * Get the saved position of the Toolbox.  Note that we throw away
        !           181:      * the size fields, because we just calculated the required size.
        !           182:      */
        !           183:     if (!ReadWindowPos(szTBPos, &x, &y, &cxDummy, &cyDummy, &fMaximized)) {
        !           184:         /*
        !           185:          * The previous position of the Toolbox  couldn't be found.
        !           186:          * Position the toolbox to the upper right corner of the
        !           187:          * "client" area of the editor, but make sure it is completely
        !           188:          * visible.
        !           189:          */
        !           190:         GetWindowRect(ghwndSubClient, &rcSubClient);
        !           191:         x = rcSubClient.right - cx - (2 * TOOLBOXMARGIN);
        !           192:         y = rcSubClient.top + (2 * TOOLBOXMARGIN);
        !           193:         SetRect(&rc, x, y, x + cx, y + cy);
        !           194:         FitRectToScreen(&rc);
        !           195:         x = rc.left;
        !           196:         y = rc.top;
        !           197:     }
        !           198: 
        !           199:     /*
        !           200:      * Create the toolbox window.
        !           201:      */
        !           202:     if (!(ghwndToolbox = CreateWindow(szToolboxClass, NULL, TOOLBOXSTYLE,
        !           203:             x, y, cx, cy, ghwndMain, NULL, ghInst, NULL)))
        !           204:         return;
        !           205: 
        !           206:     /*
        !           207:      * Create the Pointer (W_NOTHING) button.
        !           208:      */
        !           209:     CreateWindow(szToolBtnClass, NULL,
        !           210:             WS_CHILD | WS_VISIBLE,
        !           211:             TOOLBOXMARGIN, TOOLBOXMARGIN, (cxToolBtn * 2) - 1, cyToolBtn,
        !           212:             ghwndToolbox, (HMENU)W_NOTHING, ghInst, NULL);
        !           213: 
        !           214:     /*
        !           215:      * Create the other buttons.
        !           216:      */
        !           217:     x = TOOLBOXMARGIN;
        !           218:     y = TOOLBOXMARGIN + cyToolBtn - 1;
        !           219:     for (i = 0; i < CCONTROLS; i++) {
        !           220:         CreateWindow(szToolBtnClass, NULL,
        !           221:                 WS_CHILD | WS_VISIBLE,
        !           222:                 x, y, cxToolBtn, cyToolBtn,
        !           223:                 ghwndToolbox, (HMENU)i, ghInst, NULL);
        !           224: 
        !           225:         if (x == TOOLBOXMARGIN) {
        !           226:             x += cxToolBtn - 1;
        !           227:         }
        !           228:         else {
        !           229:             x = TOOLBOXMARGIN;
        !           230:             y += cyToolBtn - 1;
        !           231:         }
        !           232:     }
        !           233: }
        !           234: 
        !           235: 
        !           236: 
        !           237: /****************************************************************************
        !           238: * ToolboxWndProc
        !           239: *
        !           240: * This is the window procedure for the toolbox window.
        !           241: *
        !           242: ****************************************************************************/
        !           243: 
        !           244: WINDOWPROC ToolboxWndProc(
        !           245:     HWND hwnd,
        !           246:     UINT msg,
        !           247:     WPARAM wParam,
        !           248:     LPARAM lParam)
        !           249: {
        !           250:     switch (msg) {
        !           251:         case WM_CREATE:
        !           252:             {
        !           253:                 HMENU hmenu = GetSystemMenu(hwnd, FALSE);
        !           254: 
        !           255:                 RemoveMenu(hmenu, 7, MF_BYPOSITION);    // Second separator.
        !           256:                 RemoveMenu(hmenu, 5, MF_BYPOSITION);    // First separator.
        !           257: 
        !           258:                 RemoveMenu(hmenu, SC_RESTORE, MF_BYCOMMAND);
        !           259:                 RemoveMenu(hmenu, SC_SIZE, MF_BYCOMMAND);
        !           260:                 RemoveMenu(hmenu, SC_MINIMIZE, MF_BYCOMMAND);
        !           261:                 RemoveMenu(hmenu, SC_MAXIMIZE, MF_BYCOMMAND);
        !           262:                 RemoveMenu(hmenu, SC_TASKLIST, MF_BYCOMMAND);
        !           263:             }
        !           264: 
        !           265:             return 0;
        !           266: 
        !           267:         case WM_KEYDOWN:
        !           268:             {
        !           269:                 INT iToolNext;
        !           270: 
        !           271:                 switch (wParam) {
        !           272:                     case VK_UP:
        !           273:                         if ((GetKeyState(VK_SHIFT) & 0x8000) ||
        !           274:                                 (GetKeyState(VK_CONTROL) & 0x8000))
        !           275:                             break;
        !           276: 
        !           277:                         /*
        !           278:                          * Go up a row, but don't go beyond the top.
        !           279:                          */
        !           280:                         iToolNext = gCurTool - TOOLBOXCOLUMNS;
        !           281:                         if (iToolNext < 0)
        !           282:                             iToolNext = W_NOTHING;
        !           283: 
        !           284:                         ToolboxSelectTool(iToolNext, FALSE);
        !           285: 
        !           286:                         break;
        !           287: 
        !           288:                     case VK_DOWN:
        !           289:                         if ((GetKeyState(VK_SHIFT) & 0x8000) ||
        !           290:                                 (GetKeyState(VK_CONTROL) & 0x8000))
        !           291:                             break;
        !           292: 
        !           293:                         if (gCurTool == W_NOTHING) {
        !           294:                             iToolNext = 0;
        !           295:                         }
        !           296:                         else {
        !           297:                             /*
        !           298:                              * Go down a row, but don't go beyond the bottom.
        !           299:                              */
        !           300:                             iToolNext = gCurTool + TOOLBOXCOLUMNS;
        !           301:                             if (iToolNext >= CCONTROLS)
        !           302:                                 break;
        !           303:                         }
        !           304: 
        !           305:                         ToolboxSelectTool(iToolNext, FALSE);
        !           306: 
        !           307:                         break;
        !           308: 
        !           309:                     case VK_LEFT:
        !           310:                         if ((GetKeyState(VK_SHIFT) & 0x8000) ||
        !           311:                                 (GetKeyState(VK_CONTROL) & 0x8000))
        !           312:                             break;
        !           313: 
        !           314:                         if (gCurTool == W_NOTHING ||
        !           315:                                 !(gCurTool % TOOLBOXCOLUMNS))
        !           316:                             break;
        !           317: 
        !           318:                         /*
        !           319:                          * Go left a column.
        !           320:                          */
        !           321:                         ToolboxSelectTool(gCurTool - 1, FALSE);
        !           322: 
        !           323:                         break;
        !           324: 
        !           325:                     case VK_RIGHT:
        !           326:                         if ((GetKeyState(VK_SHIFT) & 0x8000) ||
        !           327:                                 (GetKeyState(VK_CONTROL) & 0x8000))
        !           328:                             break;
        !           329: 
        !           330:                         if (gCurTool == W_NOTHING ||
        !           331:                                 (gCurTool % TOOLBOXCOLUMNS) ==
        !           332:                                 TOOLBOXCOLUMNS - 1)
        !           333:                             break;
        !           334: 
        !           335:                         /*
        !           336:                          * Go right a column.
        !           337:                          */
        !           338:                         ToolboxSelectTool(gCurTool + 1, FALSE);
        !           339: 
        !           340:                         break;
        !           341: 
        !           342:                     case VK_TAB:
        !           343:                         if (GetKeyState(VK_CONTROL) & 0x8000)
        !           344:                             break;
        !           345: 
        !           346:                         /*
        !           347:                          * Is the shift key pressed also?
        !           348:                          */
        !           349:                         if (GetKeyState(VK_SHIFT) & 0x8000) {
        !           350:                             if (gCurTool == W_NOTHING)
        !           351:                                 iToolNext = CCONTROLS - 1;
        !           352:                             else if (gCurTool == 0)
        !           353:                                 iToolNext = W_NOTHING;
        !           354:                             else
        !           355:                                 iToolNext = gCurTool - 1;
        !           356:                         }
        !           357:                         else {
        !           358:                             if (gCurTool == W_NOTHING)
        !           359:                                 iToolNext = 0;
        !           360:                             else if (gCurTool == CCONTROLS - 1)
        !           361:                                 iToolNext = W_NOTHING;
        !           362:                             else
        !           363:                                 iToolNext = gCurTool + 1;
        !           364:                         }
        !           365: 
        !           366:                         ToolboxSelectTool(iToolNext, FALSE);
        !           367: 
        !           368:                         break;
        !           369: 
        !           370:                     case VK_END:
        !           371:                         if ((GetKeyState(VK_SHIFT) & 0x8000) ||
        !           372:                                 (GetKeyState(VK_CONTROL) & 0x8000))
        !           373:                             break;
        !           374: 
        !           375:                         ToolboxSelectTool(CCONTROLS - 1, FALSE);
        !           376: 
        !           377:                         break;
        !           378: 
        !           379:                     case VK_HOME:
        !           380:                     case VK_ESCAPE:
        !           381:                         if ((GetKeyState(VK_SHIFT) & 0x8000) ||
        !           382:                                 (GetKeyState(VK_CONTROL) & 0x8000))
        !           383:                             break;
        !           384: 
        !           385:                         ToolboxSelectTool(W_NOTHING, FALSE);
        !           386: 
        !           387:                         break;
        !           388:                 }
        !           389:             }
        !           390: 
        !           391:             break;
        !           392: 
        !           393:         case WM_ACTIVATE:
        !           394:             if (LOWORD(wParam))
        !           395:                 gidCurrentDlg = DID_TOOLBOX;
        !           396: 
        !           397:             break;
        !           398: 
        !           399:         case WM_CLOSE:
        !           400:             /*
        !           401:              * The user closed the toolbox from the system menu.
        !           402:              * Hide the toolbox (we don't actually destroy it so
        !           403:              * that it will appear in the same spot when they show
        !           404:              * it again).
        !           405:              */
        !           406:             ToolboxShow(FALSE);
        !           407:             gfShowToolbox = FALSE;
        !           408:             break;
        !           409: 
        !           410:         case WM_DESTROY:
        !           411:             {
        !           412:                 INT i;
        !           413:                 RECT rc;
        !           414: 
        !           415:                 DeleteObject(ghbmPointerToolUp);
        !           416:                 ghbmPointerToolUp = NULL;
        !           417:                 DeleteObject(ghbmPointerToolDown);
        !           418:                 ghbmPointerToolDown = NULL;
        !           419: 
        !           420:                 for (i = 0; i < CCONTROLS; i++) {
        !           421:                     DeleteObject(awcd[i].hbmToolBtnUp);
        !           422:                     awcd[i].hbmToolBtnUp = NULL;
        !           423:                     DeleteObject(awcd[i].hbmToolBtnDown);
        !           424:                     awcd[i].hbmToolBtnDown = NULL;
        !           425:                 }
        !           426: 
        !           427:                 /*
        !           428:                  * Save the position of the toolbox.
        !           429:                  */
        !           430:                 GetWindowRect(hwnd, &rc);
        !           431:                 WriteWindowPos(&rc, FALSE, szTBPos);
        !           432: 
        !           433:                 /*
        !           434:                  * Null out the global window handle for the toolbox
        !           435:                  * for safety's sake.
        !           436:                  */
        !           437:                 ghwndToolbox = NULL;
        !           438:             }
        !           439: 
        !           440:             break;
        !           441: 
        !           442:         default:
        !           443:             return DefWindowProc(hwnd, msg, wParam, lParam);
        !           444:     }
        !           445: 
        !           446:     return 0;
        !           447: }
        !           448: 
        !           449: 
        !           450: 
        !           451: /****************************************************************************
        !           452: * ToolBtnWndProc
        !           453: *
        !           454: * This is the window procedure for the buttons in the toolbox window.
        !           455: *
        !           456: ****************************************************************************/
        !           457: 
        !           458: WINDOWPROC ToolBtnWndProc(
        !           459:     HWND hwnd,
        !           460:     UINT msg,
        !           461:     WPARAM wParam,
        !           462:     LPARAM lParam)
        !           463: {
        !           464:     switch (msg) {
        !           465:         case WM_LBUTTONDOWN:
        !           466:             /*
        !           467:              * Be sure any outstanding changes get applied
        !           468:              * without errors.
        !           469:              */
        !           470:             if (!StatusApplyChanges())
        !           471:                 return TRUE;
        !           472: 
        !           473:             /*
        !           474:              * Select the tool that was clicked on.  If the Ctrl
        !           475:              * key is down, lock the tool also.
        !           476:              */
        !           477:             ToolboxSelectTool((UINT)GetWindowLong((hwnd), GWL_ID),
        !           478:                     (GetKeyState(VK_CONTROL) & 0x8000) ? TRUE : FALSE);
        !           479: 
        !           480:             break;
        !           481: 
        !           482:         case WM_PAINT:
        !           483:             {
        !           484:                 HDC hDC;
        !           485:                 PAINTSTRUCT ps;
        !           486: 
        !           487:                 hDC = BeginPaint(hwnd, &ps);
        !           488:                 ToolboxDrawBitmap(hDC, (UINT)GetWindowLong((hwnd), GWL_ID));
        !           489:                 EndPaint(hwnd, &ps);
        !           490:             }
        !           491: 
        !           492:             break;
        !           493: 
        !           494:         default:
        !           495:             return DefWindowProc(hwnd, msg, wParam, lParam);
        !           496:     }
        !           497: 
        !           498:     return 0;
        !           499: }
        !           500: 
        !           501: 
        !           502: 
        !           503: /****************************************************************************
        !           504: * ToolboxDrawBitmap
        !           505: *
        !           506: * Draws the current tool bitmap.
        !           507: *
        !           508: * Arguments:
        !           509: *   HDC hDC - handle to the DC for the toolbox window.
        !           510: *   INR type - type of bitmap to draw.
        !           511: *
        !           512: ****************************************************************************/
        !           513: 
        !           514: STATICFN VOID ToolboxDrawBitmap(
        !           515:     HDC hDC,
        !           516:     INT type)
        !           517: {
        !           518:     HDC hMemDC;
        !           519:     HBITMAP hbm;
        !           520:     HBITMAP hbmOld;
        !           521:     INT cxBitmap;
        !           522: 
        !           523:     if (type == W_NOTHING) {
        !           524:         hbm = (type == gCurTool) ? ghbmPointerToolDown : ghbmPointerToolUp;
        !           525: 
        !           526:         /*
        !           527:          * Note that the size of the Pointer tool is twice the width
        !           528:          * of the other bitmaps, but less one pixel.  This is because
        !           529:          * the other tools overlap their adjacent borders.
        !           530:          */
        !           531:         cxBitmap = (cxToolBtn * 2) - 1;
        !           532:     }
        !           533:     else {
        !           534:         hbm = (type == gCurTool) ?
        !           535:                 awcd[type].hbmToolBtnDown : awcd[type].hbmToolBtnUp;
        !           536:         cxBitmap = cxToolBtn;
        !           537:     }
        !           538: 
        !           539:     /*
        !           540:      * Draw the image.
        !           541:      */
        !           542:     hMemDC = CreateCompatibleDC(hDC);
        !           543:     hbmOld = SelectObject(hMemDC, hbm);
        !           544:     BitBlt(hDC, 0, 0, cxBitmap, cyToolBtn, hMemDC, 0, 0, SRCCOPY);
        !           545:     SelectObject(hMemDC, hbmOld);
        !           546:     DeleteDC(hMemDC);
        !           547: }
        !           548: 
        !           549: 
        !           550: 
        !           551: /****************************************************************************
        !           552: * ToolboxSelectTool
        !           553: *
        !           554: * This function selects a tool to be the current tool.
        !           555: *
        !           556: * Arguments:
        !           557: *   INT type   - Type of control (one of the W_* defines).
        !           558: *   BOOL fLock - TRUE if the tool should be locked down.
        !           559: *
        !           560: ****************************************************************************/
        !           561: 
        !           562: VOID ToolboxSelectTool(
        !           563:     INT type,
        !           564:     BOOL fLock)
        !           565: {
        !           566:     PWINDOWCLASSDESC pwcd;
        !           567: 
        !           568:     if (gCurTool != type) {
        !           569:         /*
        !           570:          * Set the current wcd global for the current tool type.
        !           571:          * This will point to the WINDOWCLASSDESC structure of the
        !           572:          * current tool.  If the Custom tool was selected, the user
        !           573:          * is asked which of the installed custom controls that they
        !           574:          * really want.
        !           575:          */
        !           576:         if (type == W_CUSTOM) {
        !           577:             /*
        !           578:              * There are no custom controls installed.  Beep and
        !           579:              * return without doing anything.
        !           580:              */
        !           581:             if (!gpclHead) {
        !           582:                 MessageBeep(0);
        !           583:                 return;
        !           584:             }
        !           585: 
        !           586:             /*
        !           587:              * If there are multiple custom controls installed,
        !           588:              * ask the user which one they want.  Note that they
        !           589:              * can press Cancel and return NULL!
        !           590:              */
        !           591:             if (gpclHead->pclNext) {
        !           592:                 if (!(pwcd = SelCustDialog()))
        !           593:                     return;
        !           594: 
        !           595:                 gpwcdCurTool = pwcd;
        !           596:             }
        !           597:             else {
        !           598:                 /*
        !           599:                  * Since there is only one type of custom control
        !           600:                  * installed, there is no need to ask the user
        !           601:                  * which one they want.
        !           602:                  */
        !           603:                 gpwcdCurTool = gpclHead->pwcd;
        !           604:             }
        !           605:         }
        !           606:         else {
        !           607:             gpwcdCurTool = (type == W_NOTHING) ? NULL : &awcd[type];
        !           608:         }
        !           609: 
        !           610:         /*
        !           611:          * Force the previous and current buttons to repaint.
        !           612:          */
        !           613:         if (ghwndToolbox) {
        !           614:             InvalidateRect(GetDlgItem(ghwndToolbox, gCurTool), NULL, FALSE);
        !           615:             InvalidateRect(GetDlgItem(ghwndToolbox, type), NULL, FALSE);
        !           616:         }
        !           617: 
        !           618:         /*
        !           619:          * Set the current tool type global.  This will be W_CUSTOM for
        !           620:          * all custom controls.
        !           621:          */
        !           622:         gCurTool = type;
        !           623:     }
        !           624: 
        !           625:     gfToolLocked = fLock;
        !           626: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.