![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to menu.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / q_a / samples / menu|
Return to menu.c CVS log | Up to [WindowsNT SDKs] / q_a / samples / menu |
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: /*************************************************************************** ! 13: * * ! 14: * PROGRAM : Menu.c * ! 15: * * ! 16: * PURPOSE : To give a demonstration of the use of popup menus, user * ! 17: * defined menus and menu functions. * ! 18: * * ! 19: * FUNCTIONS : WinMain() - Calls the initialization function * ! 20: * and enters the message loop. * ! 21: * * ! 22: * MenuInit() - Registers the app. window class. * ! 23: * * ! 24: * About() - Dialog function for the About.. * ! 25: * dialog. * ! 26: * * ! 27: * ShrinkBitmap() - Shrinks a 64x64 bitmap to a size * ! 28: * useable for a user-defined menu * ! 29: * checkmark. * ! 30: * * ! 31: * HandleCreate() - Creates a new menu and appends it * ! 32: * to the main menu * ! 33: * * ! 34: * HandlePaint() - Handles repainting the app's client* ! 35: * area * ! 36: * * ! 37: * HandleChangeColors()- Changes the state of the "colors" * ! 38: * menu item. * ! 39: * * ! 40: * HandleDrawItem() - Redraws the menu items in the * ! 41: * "colors" menu * ! 42: * * ! 43: * HandlePopupMenu() - handles display of the "floating" * ! 44: * popup. * ! 45: * * ! 46: * MenuWndProc() - Window function for the app. * ! 47: * * ! 48: * * ! 49: ***************************************************************************/ ! 50: #include "windows.h" ! 51: #include "menu.h" ! 52: ! 53: ! 54: HANDLE hInst; ! 55: HMENU hBigMenu; ! 56: HBITMAP hbmCheckOn; ! 57: HBITMAP hbmCheckOff; ! 58: ! 59: /**************************************************************************** ! 60: * * ! 61: * FUNCTION : WinMain(HANDLE, HANDLE, LPSTR, int) * ! 62: * * ! 63: * PURPOSE : Creates the main app. window, calls an initialization * ! 64: * function and enters the message loop. * ! 65: * * ! 66: ****************************************************************************/ ! 67: int APIENTRY WinMain( ! 68: HANDLE hInstance, ! 69: HANDLE hPrevInstance, ! 70: LPSTR lpCmdLine, ! 71: int nCmdShow ! 72: ) ! 73: { ! 74: ! 75: HWND hWnd; ! 76: MSG msg; /* message */ ! 77: ! 78: UNREFERENCED_PARAMETER( lpCmdLine ); ! 79: ! 80: /* Register main window class if this is the first instance of the app. */ ! 81: if (!hPrevInstance) ! 82: if (!MenuInit (hInstance)) ! 83: return 0; ! 84: ! 85: hInst = hInstance; ! 86: ! 87: /* Create the app. window */ ! 88: hWnd = CreateWindow ("menu", ! 89: "Menu Example", ! 90: WS_OVERLAPPEDWINDOW, ! 91: CW_USEDEFAULT, ! 92: CW_USEDEFAULT, ! 93: CW_USEDEFAULT, ! 94: CW_USEDEFAULT, ! 95: (HWND) NULL, ! 96: NULL, ! 97: hInstance, ! 98: (LPSTR) NULL); ! 99: ! 100: if (!hWnd) ! 101: return 0; ! 102: ! 103: ShowWindow (hWnd, nCmdShow); ! 104: UpdateWindow (hWnd); ! 105: ! 106: while (GetMessage (&msg, NULL, 0, 0)){ ! 107: /* Since we have no accelerators, no need to call ! 108: * TranslateAccelerator here. ! 109: */ ! 110: TranslateMessage (&msg); ! 111: DispatchMessage (&msg); ! 112: } ! 113: return(msg.wParam); ! 114: } ! 115: ! 116: ! 117: /**************************************************************************** ! 118: * * ! 119: * FUNCTION : MenuInit (hInstance) * ! 120: * * ! 121: * PURPOSE : Registers the main window class. * ! 122: * * ! 123: * RETURNS : TRUE - if RegisterClass() went off ok * ! 124: * FALSE - otherwise. * ! 125: * * ! 126: ****************************************************************************/ ! 127: BOOL NEAR PASCAL MenuInit (HANDLE hInstance) ! 128: { ! 129: HANDLE hMemory; ! 130: PWNDCLASS pWndClass; ! 131: BOOL bSuccess; ! 132: ! 133: /* Initialize the menu window class */ ! 134: hMemory = LocalAlloc(LPTR, sizeof(WNDCLASS)); ! 135: if(!hMemory){ ! 136: MessageBox(NULL, "<MenuInit> Not enough memory.", NULL, MB_OK | MB_ICONHAND); ! 137: return(FALSE); ! 138: } ! 139: ! 140: pWndClass = (PWNDCLASS) LocalLock(hMemory); ! 141: ! 142: pWndClass->style = 0; ! 143: pWndClass->lpfnWndProc = (WNDPROC) MenuWndProc; ! 144: pWndClass->hInstance = hInstance; ! 145: pWndClass->hIcon = LoadIcon (hInstance, "menu"); ! 146: pWndClass->hCursor = LoadCursor (NULL, IDC_ARROW); ! 147: pWndClass->hbrBackground = GetStockObject (WHITE_BRUSH); ! 148: pWndClass->lpszMenuName = (LPSTR) "MenuMenu", ! 149: pWndClass->lpszClassName = (LPSTR) "menu"; ! 150: ! 151: bSuccess = RegisterClass (pWndClass); ! 152: LocalUnlock (hMemory); ! 153: LocalFree (hMemory); ! 154: ! 155: return bSuccess; ! 156: } ! 157: ! 158: ! 159: /**************************************************************************** ! 160: * * ! 161: * FUNCTION : About (hDlg, message, wParam, lParam) * ! 162: * * ! 163: * PURPOSE : Dialog function for the About menu... dialog. * ! 164: * * ! 165: ****************************************************************************/ ! 166: BOOL APIENTRY About( ! 167: HWND hDlg, ! 168: UINT message, ! 169: UINT wParam, ! 170: LONG lParam) ! 171: ! 172: { ! 173: switch (message){ ! 174: case WM_INITDIALOG: ! 175: return(TRUE); ! 176: ! 177: case WM_COMMAND: ! 178: // LOWORD added for portability ! 179: if (LOWORD(wParam) == IDOK){ ! 180: EndDialog(hDlg,0); ! 181: return(TRUE); ! 182: } ! 183: break; ! 184: } ! 185: return(FALSE); ! 186: UNREFERENCED_PARAMETER(lParam); ! 187: } ! 188: ! 189: ! 190: /**************************************************************************** ! 191: * * ! 192: * FUNCTION : ShrinkBitmap(hwnd, hbm) * ! 193: * * ! 194: * PURPOSE : This function shrinks a 64x64 bitmap into a bitmap useable * ! 195: * for the user-defined checkmark for menu items. This can be * ! 196: * easily generalized to shrink bitmaps of any size. * ! 197: * * ! 198: * RETURNS : HBITMAP - A handle to the new bitmap. * ! 199: * * ! 200: ****************************************************************************/ ! 201: HBITMAP APIENTRY ShrinkBitmap ( ! 202: HWND hwnd, ! 203: HBITMAP hbm) ! 204: { ! 205: HDC hdc; ! 206: HDC hmemorydcNew; ! 207: HDC hmemorydcOld; ! 208: LONG checkMarkSize; ! 209: HBITMAP hCheckBitmap; ! 210: HBITMAP hOldBitmapSave; ! 211: HBITMAP hNewBitmapSave; ! 212: ! 213: hdc = GetDC (hwnd); ! 214: ! 215: /* Create DCs for the source (old) and target (new) bitmaps */ ! 216: hmemorydcNew = CreateCompatibleDC (hdc); ! 217: hmemorydcOld = CreateCompatibleDC (hdc); ! 218: ! 219: /* Determine the dimensions of the default menu checkmark and ! 220: * create a target bitmap of the same dimensions ! 221: */ ! 222: checkMarkSize = GetMenuCheckMarkDimensions (); ! 223: hCheckBitmap = CreateCompatibleBitmap (hdc, ! 224: LOWORD (checkMarkSize), ! 225: HIWORD (checkMarkSize)); ! 226: ! 227: /* Select the source bitmap and the target bitmap into their ! 228: * respective DCs. ! 229: */ ! 230: hOldBitmapSave = SelectObject (hmemorydcNew, hCheckBitmap); ! 231: hNewBitmapSave = SelectObject (hmemorydcOld, hbm); ! 232: ! 233: /* Shrink the source bitmap into the target DC */ ! 234: StretchBlt (hmemorydcNew, ! 235: 0, ! 236: 0, ! 237: LOWORD(checkMarkSize), ! 238: HIWORD(checkMarkSize), ! 239: hmemorydcOld, ! 240: 0, ! 241: 0, ! 242: 64, ! 243: 64, ! 244: SRCCOPY); ! 245: ! 246: /* De-select the bitmaps and clean up .. */ ! 247: SelectObject (hmemorydcNew, hOldBitmapSave); ! 248: SelectObject (hmemorydcOld, hNewBitmapSave); ! 249: DeleteDC (hmemorydcNew); ! 250: DeleteDC (hmemorydcOld); ! 251: ReleaseDC (hwnd, hdc); ! 252: ! 253: /* .. and return a handle to the target bitmap */ ! 254: return hCheckBitmap; ! 255: } ! 256: ! 257: ! 258: /**************************************************************************** ! 259: * * ! 260: * FUNCTION : HandleCreate ( hwnd ) * ! 261: * * ! 262: * PURPOSE : Creates a new (empty) menu and appends to it the "State" * ! 263: * menu items. It sets up the user-defined checkmarks for the * ! 264: * menu. It then inserts this menu into the main menu bar. * ! 265: * * ! 266: ****************************************************************************/ ! 267: VOID APIENTRY HandleCreate (HWND hwnd) ! 268: { ! 269: HMENU hMenu; ! 270: HMENU hWndMenu; ! 271: ! 272: /* Create a new menu into the menubar on the fly */ ! 273: hMenu = CreateMenu (); ! 274: if (!hMenu) ! 275: return; ! 276: ! 277: /* Append the state menu items to it */ ! 278: AppendMenu (hMenu, MF_STRING, IDM_STATE1, "South Dakota"); ! 279: AppendMenu (hMenu, MF_STRING, IDM_STATE2, "Washington"); ! 280: AppendMenu (hMenu, MF_STRING, IDM_STATE3, "California"); ! 281: if (!AppendMenu (hMenu, MF_STRING, IDM_STATE4, "Oregon")){ ! 282: /* It is unlikely the other appends will fail and this will succeed. ! 283: * So just check this one. And if it fails, Destroy the menu for ! 284: * good measure and return. ! 285: */ ! 286: DestroyMenu(hMenu); ! 287: return; ! 288: } ! 289: hbmCheckOn = ShrinkBitmap (hwnd, LoadBitmap (hInst, "checkon")); ! 290: hbmCheckOff = ShrinkBitmap (hwnd, LoadBitmap (hInst, "checkoff")); ! 291: ! 292: /* Set up the user-defined check marks */ ! 293: SetMenuItemBitmaps (hMenu, 0, MF_BYPOSITION, hbmCheckOff, hbmCheckOn); ! 294: SetMenuItemBitmaps (hMenu, 1, MF_BYPOSITION, hbmCheckOff, hbmCheckOn); ! 295: SetMenuItemBitmaps (hMenu, 2, MF_BYPOSITION, hbmCheckOff, hbmCheckOn); ! 296: SetMenuItemBitmaps (hMenu, 3, MF_BYPOSITION, hbmCheckOff, hbmCheckOn); ! 297: ! 298: /* Now insert the menu into the main menu bar. */ ! 299: hWndMenu = GetMenu (hwnd); ! 300: InsertMenu (hWndMenu, 2, MF_POPUP|MF_BYPOSITION, (DWORD)hMenu, "States"); ! 301: ! 302: return; ! 303: } ! 304: ! 305: /**************************************************************************** ! 306: * * ! 307: * FUNCTION : HandlePaint ( hwnd ) * ! 308: * * ! 309: * PURPOSE : Handles the repainting of the main app's client area. * ! 310: * * ! 311: ****************************************************************************/ ! 312: VOID APIENTRY HandlePaint (HWND hwnd) ! 313: { ! 314: HDC hdc; ! 315: PAINTSTRUCT ps; ! 316: RECT rc; ! 317: ! 318: hdc = BeginPaint (hwnd, (LPPAINTSTRUCT)&ps); ! 319: ! 320: /* Center the text in the client area */ ! 321: GetClientRect (hwnd, (LPRECT)&rc); ! 322: DrawText (hdc, ! 323: "Down click in the window for a popup menu", ! 324: 41, ! 325: (LPRECT)&rc, ! 326: DT_CENTER | DT_WORDBREAK); ! 327: EndPaint(hwnd, (LPPAINTSTRUCT)&ps); ! 328: } ! 329: ! 330: ! 331: /**************************************************************************** ! 332: * * ! 333: * FUNCTION : HandleChangeColors (hwnd) * ! 334: * * ! 335: * PURPOSE : Toggles the state of the Owner Draw item in the Colors * ! 336: * menu. If it is on, the "Black", "Blue", "Red", and "Green" * ! 337: * individual menu text items are modified so that they will * ! 338: * contain bands of color. Otherwise, the colors are replaced * ! 339: * by the text. * ! 340: * * ! 341: ****************************************************************************/ ! 342: VOID APIENTRY HandleChangeColors(HWND hwnd) ! 343: { ! 344: HMENU hMenu; ! 345: BOOL fOwnerDraw; ! 346: ! 347: /* Get a handle to the Colors menu. This is at position 1. */ ! 348: hMenu = GetSubMenu (GetMenu (hwnd), IDCOLORS_POS); ! 349: ! 350: /* Get the current state of the item */ ! 351: fOwnerDraw = GetMenuState ( hMenu, ! 352: IDM_COLOROWNERDR, MF_BYCOMMAND) & MF_CHECKED; ! 353: ! 354: /* Toggle the state of the item. */ ! 355: CheckMenuItem ( hMenu, ! 356: IDM_COLOROWNERDR, ! 357: MF_BYCOMMAND | (fOwnerDraw ? MF_UNCHECKED : MF_CHECKED)); ! 358: ! 359: if (!fOwnerDraw){ ! 360: /* Change the items to owner-draw items. Pass the RGB value for the ! 361: * color as the application-supplied data. This makes it easier for ! 362: * us to draw the items. ! 363: */ ! 364: ModifyMenu(hMenu, ! 365: IDM_BLACK, ! 366: MF_OWNERDRAW | MF_BYCOMMAND, ! 367: IDM_BLACK, ! 368: (LPSTR)RGB (0,0,0)); ! 369: ! 370: ModifyMenu(hMenu, ! 371: IDM_BLUE, ! 372: MF_OWNERDRAW | MF_BYCOMMAND, ! 373: IDM_BLUE, ! 374: (LPSTR)RGB (0,0,255)); ! 375: ! 376: ModifyMenu(hMenu, ! 377: IDM_RED, ! 378: MF_OWNERDRAW | MF_BYCOMMAND, ! 379: IDM_RED, ! 380: (LPSTR)RGB (255,0,0)); ! 381: ! 382: ModifyMenu(hMenu, ! 383: IDM_GREEN, ! 384: MF_OWNERDRAW | MF_BYCOMMAND, ! 385: IDM_GREEN, ! 386: (LPSTR)RGB (0,255,0)); ! 387: } ! 388: else { ! 389: /* Change the items to normal text items. */ ! 390: ModifyMenu(hMenu, IDM_BLACK, MF_BYCOMMAND, IDM_BLACK, "Black"); ! 391: ! 392: ModifyMenu(hMenu, IDM_BLUE, MF_BYCOMMAND, IDM_BLUE, "Blue"); ! 393: ! 394: ModifyMenu(hMenu, IDM_RED, MF_BYCOMMAND, IDM_RED, "Red"); ! 395: ! 396: ModifyMenu(hMenu, IDM_GREEN, MF_BYCOMMAND, IDM_GREEN, "Green"); ! 397: } ! 398: } ! 399: ! 400: ! 401: /**************************************************************************** ! 402: * * ! 403: * FUNCTION : HandleDrawItem ( hwnd, lpdis) * ! 404: * * ! 405: * PURPOSE : Called in response to a WM_DRAWITEM message, i.e. when the * ! 406: * colors menu is being modified to an owner-draw menu, or * ! 407: * one of the items is selected. It sizes the checkmark bitmap* ! 408: * to fit next to a color band and draws the color bands and * ! 409: * the checkmark on the popup menu. * ! 410: * * ! 411: ****************************************************************************/ ! 412: VOID APIENTRY HandleDrawItem( ! 413: HWND hwnd, ! 414: LPDRAWITEMSTRUCT lpdis) ! 415: ! 416: { ! 417: HDC hdcBitmap; ! 418: HBITMAP hbmSave; ! 419: HBRUSH hbr; ! 420: RECT rc; ! 421: LONG checkMarkSize; ! 422: DWORD textColorSave; ! 423: DWORD bkColorSave; ! 424: ! 425: /* Get the size of the checkmark so we can leave room for it since we ! 426: * want to be able to check the selected color. ! 427: */ ! 428: checkMarkSize = GetMenuCheckMarkDimensions (); ! 429: ! 430: if (lpdis->itemAction == ODA_SELECT || ! 431: lpdis->itemAction == ODA_DRAWENTIRE){ ! 432: ! 433: CopyRect ((LPRECT)&rc, (LPRECT)&lpdis->rcItem); ! 434: InflateRect ((LPRECT)&rc, (-2 - LOWORD(checkMarkSize)), -2); ! 435: ! 436: if (lpdis->itemState & ODS_SELECTED) ! 437: { ! 438: /* Item has been selected -- hilite with a gray frame */ ! 439: hbr = GetStockObject (GRAY_BRUSH); ! 440: FrameRect (lpdis->hDC, (LPRECT)&rc, hbr); ! 441: } ! 442: else if (lpdis->itemAction == ODA_SELECT) ! 443: { ! 444: /* Item has been de-selected -- remove gray frame */ ! 445: hbr = CreateSolidBrush (GetSysColor (COLOR_MENU)); ! 446: FrameRect (lpdis->hDC, (LPRECT)&rc, hbr); ! 447: DeleteObject (hbr); ! 448: } ! 449: } ! 450: ! 451: if (lpdis->itemAction == ODA_DRAWENTIRE){ ! 452: ! 453: /* Paint the color item in the color requested. */ ! 454: hbr = CreateSolidBrush (lpdis->itemData); ! 455: CopyRect ((LPRECT)&rc, (LPRECT)&lpdis->rcItem); ! 456: InflateRect ((LPRECT)&rc, -10-LOWORD(checkMarkSize), -10); ! 457: FillRect (lpdis->hDC, (LPRECT)&rc, hbr); ! 458: DeleteObject (hbr); ! 459: ! 460: if (lpdis->itemState & ODS_CHECKED){ ! 461: /* Draw the check mark if the item is checked. */ ! 462: hdcBitmap = CreateCompatibleDC (lpdis->hDC); ! 463: hbmSave = SelectObject (hdcBitmap, hbmCheckOn); ! 464: ! 465: textColorSave = SetTextColor (lpdis->hDC, 0x00000000L); ! 466: bkColorSave = SetBkColor (lpdis->hDC, 0x00FFFFFFL); ! 467: ! 468: /* Use Magic bitblt op so that monochrome bitmaps preserve ! 469: background and foreground colors. */ ! 470: BitBlt (lpdis->hDC, ! 471: lpdis->rcItem.left, ! 472: lpdis->rcItem.top+ ! 473: (MEASUREITEMHEIGHT - HIWORD (checkMarkSize)) / 2, ! 474: LOWORD (checkMarkSize), ! 475: HIWORD (checkMarkSize), ! 476: hdcBitmap, ! 477: 0, ! 478: 0, ! 479: ROP_PSDPxax); ! 480: ! 481: /* Restore colors and bitmap and clean up */ ! 482: SetTextColor (lpdis->hDC, textColorSave); ! 483: SetBkColor (lpdis->hDC, bkColorSave); ! 484: SelectObject (hdcBitmap, hbmSave); ! 485: DeleteDC (hdcBitmap); ! 486: ! 487: } ! 488: } ! 489: UNREFERENCED_PARAMETER(hwnd); ! 490: } ! 491: ! 492: /**************************************************************************** ! 493: * * ! 494: * FUNCTION : HandlePopupMenu (hwnd, point) * ! 495: * * ! 496: * PURPOSE : Handles the display of the "floating" popup that appears * * ! 497: * on a mouse click in the app's client area. * ! 498: * * ! 499: ****************************************************************************/ ! 500: VOID APIENTRY HandlePopupMenu ( ! 501: HWND hwnd, ! 502: POINT point) ! 503: ! 504: { ! 505: HMENU hMenu; ! 506: HMENU hMenuTrackPopup; ! 507: ! 508: /* Get the menu for the popup from the resource file. */ ! 509: hMenu = LoadMenu (hInst, "PopupMenu"); ! 510: if (!hMenu) ! 511: return; ! 512: ! 513: /* Get the first menu in it which we will use for the call to ! 514: * TrackPopup(). This could also have been created on the fly using ! 515: * CreatePopupMenu and then we could have used InsertMenu() or ! 516: * AppendMenu. ! 517: */ ! 518: hMenuTrackPopup = GetSubMenu (hMenu, 0); ! 519: ! 520: /* Convert the mouse point to screen coordinates since that is what ! 521: * TrackPopup expects. ! 522: */ ! 523: ClientToScreen (hwnd, (LPPOINT)&point); ! 524: ! 525: /* Draw and track the "floating" popup */ ! 526: TrackPopupMenu (hMenuTrackPopup, 0, point.x, point.y, 0, hwnd, NULL); ! 527: ! 528: /* Destroy the menu since were are done with it. */ ! 529: DestroyMenu (hMenu); ! 530: } ! 531: ! 532: /**************************************************************************** ! 533: * * ! 534: * FUNCTION : MenuWndProc (hWnd, message, wParam, lParam) * ! 535: * * ! 536: * PURPOSE : Window function for the main app. window. Processes all the* ! 537: * menu selections and oter messages. * ! 538: * * ! 539: ****************************************************************************/ ! 540: LONG APIENTRY MenuWndProc ( ! 541: HWND hWnd, ! 542: UINT message, ! 543: UINT wParam, ! 544: LONG lParam) ! 545: ! 546: { ! 547: FARPROC lpProc; ! 548: HMENU hMenu; ! 549: RECT rc; ! 550: POINT pt; ! 551: ! 552: ! 553: switch (message){ ! 554: case WM_SYSCOMMAND: ! 555: /* Show the About ... dialog */ ! 556: if (wParam == ID_ABOUT){ ! 557: lpProc = MakeProcInstance ((FARPROC)About, hInst); ! 558: DialogBox (hInst, ! 559: "AboutBox", ! 560: hWnd, ! 561: lpProc); ! 562: ! 563: FreeProcInstance (lpProc); ! 564: break; ! 565: } ! 566: else ! 567: return DefWindowProc (hWnd, message, wParam, lParam); ! 568: ! 569: case WM_COMMAND: ! 570: // LOWORD added for portability ! 571: switch (LOWORD(wParam)){ ! 572: case IDM_EXIT: ! 573: DestroyWindow (hWnd); ! 574: break; ! 575: ! 576: case IDM_ABOUT: ! 577: /* Bring up the About.. dialog box */ ! 578: lpProc = MakeProcInstance ((FARPROC)About, hInst); ! 579: DialogBox (hInst, ! 580: "AboutBox", ! 581: hWnd, ! 582: lpProc); ! 583: ! 584: FreeProcInstance (lpProc); ! 585: break; ! 586: ! 587: case IDM_COLOROWNERDR: ! 588: /* Change colors in color menu depending on state of this ! 589: menu item. */ ! 590: HandleChangeColors (hWnd); ! 591: break; ! 592: ! 593: case IDM_STATE1: ! 594: case IDM_STATE2: ! 595: case IDM_STATE3: ! 596: case IDM_STATE4: ! 597: /* Get a handle to the states menu... */ ! 598: hMenu = GetSubMenu (GetMenu (hWnd), IDSTATES_POS); ! 599: ! 600: /* Uncheck all the items. */ ! 601: CheckMenuItem (hMenu, IDM_STATE1, ! 602: MF_BYCOMMAND | MF_UNCHECKED); ! 603: CheckMenuItem (hMenu, IDM_STATE2, ! 604: MF_BYCOMMAND | MF_UNCHECKED); ! 605: CheckMenuItem (hMenu, IDM_STATE3, ! 606: MF_BYCOMMAND | MF_UNCHECKED); ! 607: CheckMenuItem (hMenu, IDM_STATE4, ! 608: MF_BYCOMMAND | MF_UNCHECKED); ! 609: ! 610: /* ...and just check the selected one.*/ ! 611: CheckMenuItem (hMenu, (WORD)wParam, ! 612: MF_BYCOMMAND | MF_CHECKED); ! 613: break; ! 614: ! 615: case IDM_BLACK: ! 616: case IDM_RED: ! 617: case IDM_BLUE: ! 618: case IDM_GREEN: ! 619: /* Get a handle to the Colors menu. */ ! 620: hMenu = GetSubMenu (GetMenu (hWnd),IDCOLORS_POS); ! 621: ! 622: /* Uncheck all the items. */ ! 623: CheckMenuItem (hMenu, IDM_BLACK, ! 624: MF_BYCOMMAND | MF_UNCHECKED); ! 625: CheckMenuItem (hMenu, IDM_RED, ! 626: MF_BYCOMMAND | MF_UNCHECKED); ! 627: CheckMenuItem (hMenu, IDM_BLUE, ! 628: MF_BYCOMMAND | MF_UNCHECKED); ! 629: CheckMenuItem (hMenu, IDM_GREEN, ! 630: MF_BYCOMMAND | MF_UNCHECKED); ! 631: ! 632: /* ...and just check the selected one.*/ ! 633: CheckMenuItem (hMenu, (WORD)wParam, ! 634: MF_BYCOMMAND | MF_CHECKED); ! 635: break; ! 636: ! 637: case IDM_FONT: ! 638: /* Messages sent to us from TrackPopupMenu when ! 639: * items are selected from the "floating" popups ! 640: */ ! 641: MessageBox (hWnd, ! 642: "A font was selected", ! 643: "Popup Menu Alert", ! 644: MB_APPLMODAL|MB_OK); ! 645: break; ! 646: ! 647: case IDM_SIZE: ! 648: MessageBox (hWnd, ! 649: "A size was selected", ! 650: "Popup Menu Alert", ! 651: MB_APPLMODAL|MB_OK); ! 652: break; ! 653: ! 654: case IDM_STYLE: ! 655: MessageBox (hWnd, ! 656: "A style was selected", ! 657: "Popup Menu Alert", ! 658: MB_APPLMODAL|MB_OK); ! 659: break; ! 660: } ! 661: break; ! 662: ! 663: case WM_SIZE: ! 664: if (lParam){ ! 665: /* If window is being sized to a non zero value... ! 666: * invalidate it's client area. ! 667: */ ! 668: InvalidateRect (hWnd, NULL, TRUE); ! 669: } ! 670: break; ! 671: ! 672: case WM_PAINT: ! 673: HandlePaint (hWnd); ! 674: break; ! 675: ! 676: case WM_MEASUREITEM: ! 677: /* Use the same width for all items. We could examine the item id ! 678: and use different widths/heights for each item. */ ! 679: ((LPMEASUREITEMSTRUCT)lParam)->itemWidth = MEASUREITEMWIDTH; ! 680: ((LPMEASUREITEMSTRUCT)lParam)->itemHeight = MEASUREITEMHEIGHT; ! 681: return TRUE; ! 682: ! 683: case WM_DRAWITEM: ! 684: /* Redraw the "colors" menu in normal/ownerdrawmode */ ! 685: HandleDrawItem (hWnd,(LPDRAWITEMSTRUCT)lParam); ! 686: return TRUE; ! 687: break; ! 688: ! 689: case WM_CREATE: ! 690: /* Create the menu */ ! 691: HandleCreate (hWnd); ! 692: break; ! 693: ! 694: case WM_DESTROY: ! 695: /* Delete the on/off bitmaps so that they don't waste memory. */ ! 696: DeleteObject (hbmCheckOn); ! 697: DeleteObject (hbmCheckOff); ! 698: ! 699: PostQuitMessage (0); ! 700: break; ! 701: ! 702: case WM_LBUTTONDOWN: ! 703: /* Draw the "floating" popup in the app's client area */ ! 704: GetClientRect (hWnd, (LPRECT)&rc); ! 705: ! 706: // Temporary porting macro ! 707: LONG2POINT(lParam, pt); ! 708: if (PtInRect ((LPRECT)&rc, pt)) ! 709: HandlePopupMenu (hWnd, pt); ! 710: break; ! 711: ! 712: default: ! 713: return DefWindowProc(hWnd, message, wParam, lParam); ! 714: } ! 715: return(0); ! 716: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.