![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to multipad.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / samples / multipad|
Return to multipad.c CVS log | Up to [WindowsNT SDKs] / mstools / samples / multipad |
1.1 ! root 1: /*************************************************************************** ! 2: * * ! 3: * PROGRAM : MultiPad.c * ! 4: * * ! 5: * PURPOSE : To give a multi-Notepad demonstration of the new MDI * ! 6: * API in Windows 3.0 * ! 7: * * ! 8: * FUNCTIONS : WinMain() - Calls the initialization function * ! 9: * and processes message loop * ! 10: * * ! 11: * MPFrameWndProc() - Window function for the "frame" * ! 12: * window, which controls the menu * ! 13: * and contains the MDI document * ! 14: * windows as child windows. * ! 15: * * ! 16: * MPMDIChildWndProc() - Window function for the individual * ! 17: * document windows * ! 18: * * ! 19: * InitializeMenu() - Handles enabling/greying of menu * ! 20: * items according to the app's state.* ! 21: * * ! 22: * CloseAllChildren - Destroys all MDI child windows. * ! 23: * * ! 24: * CommandHandler() - Processes the "frame" window's * ! 25: * WM_COMMAND messages. * ! 26: * * ! 27: * AboutDlgProc() - Dialog function for the ubiquitous * ! 28: * About.. dialog. * ! 29: * * ! 30: * SetWrap() - Alters word wrapping in the edit * ! 31: * control. * ! 32: * * ! 33: * MPError() - Flashes an error messagebox. * ! 34: * * ! 35: * QueryCloseChild - Prompts for saving current MDI * ! 36: * child window. * ! 37: * * ! 38: * QueryCloseAllChildren() - Asks whether it is OK to close * ! 39: * down app. * ! 40: * * ! 41: ***************************************************************************/ ! 42: ! 43: #include "multipad.h" ! 44: #include <string.h> ! 45: #include <stdio.h> ! 46: ! 47: ! 48: /* global variables used in this module or among more than one module */ ! 49: HANDLE hInst; /* Program instance handle */ ! 50: HANDLE hAccel; /* Main accelerator resource */ ! 51: HWND hwndFrame = NULL; /* Handle to main window */ ! 52: HWND hwndMDIClient = NULL; /* Handle to MDI client */ ! 53: HWND hwndActive = NULL; /* Handle to currently activated child */ ! 54: HWND hwndActiveEdit = NULL; /* Handle to edit control */ ! 55: LONG styleDefault = WS_MAXIMIZE; /* Default style bits for child windows */ ! 56: /* The first window is created maximized */ ! 57: /* to resemble Notepad. Later children */ ! 58: /* are normal windows. */ ! 59: LPSTR lpMenu = IDMULTIPAD; /* Contains the resource id of the */ ! 60: /* current frame menu */ ! 61: ! 62: ! 63: /* Forward declarations of helper functions in this module */ ! 64: VOID NEAR PASCAL InitializeMenu (HANDLE); ! 65: VOID NEAR PASCAL CommandHandler (HWND, UINT, LONG); ! 66: BOOL NEAR PASCAL SetWrap (HWND,BOOL); ! 67: BOOL NEAR PASCAL QueryCloseAllChildren ( VOID ); ! 68: INT NEAR PASCAL QueryCloseChild (HWND); ! 69: LPSTR GetCmdLine( VOID ); ! 70: ! 71: /**************************************************************************** ! 72: * * ! 73: * FUNCTION : WinMain(HANDLE, HANDLE, LPSTR, int) * ! 74: * * ! 75: * PURPOSE : Creates the "frame" window, does some initialization and * ! 76: * enters the message loop. * ! 77: * * ! 78: ****************************************************************************/ ! 79: int PASCAL WinMain(hInstance, hPrevInstance, lpCmdLine, nCmdShow) ! 80: HANDLE hInstance; /* current instance */ ! 81: HANDLE hPrevInstance; /* previous instance */ ! 82: LPSTR lpCmdLine; /* command line */ ! 83: int nCmdShow; /* show-window type (open/icon) */ ! 84: { ! 85: MSG msg; ! 86: ! 87: hInst = hInstance; ! 88: ! 89: /* If this is the first instance of the app. register window classes */ ! 90: if (!hPrevInstance){ ! 91: if (!InitializeApplication ()) ! 92: return 0; ! 93: } ! 94: ! 95: lpCmdLine = GetCmdLine(); ! 96: ! 97: /* Create the frame and do other initialization */ ! 98: if (!InitializeInstance (lpCmdLine, nCmdShow)) ! 99: return 0; ! 100: ! 101: /* Enter main message loop */ ! 102: while (GetMessage (&msg, NULL, 0, 0)){ ! 103: /* If a keyboard message is for the MDI , let the MDI client ! 104: * take care of it. Otherwise, check to see if it's a normal ! 105: * accelerator key (like F3 = find next). Otherwise, just handle ! 106: * the message as usual. ! 107: */ ! 108: if ( !TranslateMDISysAccel (hwndMDIClient, &msg) && ! 109: !TranslateAccelerator (hwndFrame, hAccel, &msg)){ ! 110: TranslateMessage (&msg); ! 111: DispatchMessage (&msg); ! 112: } ! 113: } ! 114: return 0; ! 115: } ! 116: ! 117: /**************************************************************************** ! 118: * * ! 119: * FUNCTION : MPFrameWndProc (hwnd, msg, wParam, lParam ) * ! 120: * * ! 121: * PURPOSE : The window function for the "frame" window, which controls * ! 122: * the menu and encompasses all the MDI child windows. Does * ! 123: * the major part of the message processing. Specifically, in * ! 124: * response to: * ! 125: * * ! 126: * WM_CREATE : Creates and displays the "frame". * ! 127: * * ! 128: * WM_INITMENU : Sets up the state of the menu. * ! 129: * * ! 130: * WM_WININICHANGE & : If default printer characteristics* ! 131: * WM_DEVMODECHANGE have been changed, reinitialises * ! 132: * printer DC. * ! 133: * * ! 134: * WM_COMMAND : Passes control to a command- * ! 135: * handling function. * ! 136: * * ! 137: * WM_CLOSE : Quits the app. if all the child * ! 138: * windows agree. * ! 139: * * ! 140: * WM_QUERYENDSESSION : Checks that all child windows * ! 141: * agree to quit. * ! 142: * * ! 143: * WM_DESTROY : Destroys frame window and quits * ! 144: * app. * ! 145: * * ! 146: ****************************************************************************/ ! 147: LONG APIENTRY MPFrameWndProc ( ! 148: register HWND hwnd, ! 149: UINT msg, ! 150: UINT wParam, ! 151: LONG lParam) ! 152: ! 153: { ! 154: switch (msg){ ! 155: case WM_CREATE:{ ! 156: ! 157: CLIENTCREATESTRUCT ccs; ! 158: HDC hdc; ! 159: ! 160: /* Find window menu where children will be listed */ ! 161: ccs.hWindowMenu = GetSubMenu (GetMenu(hwnd),WINDOWMENU); ! 162: ccs.idFirstChild = IDM_WINDOWCHILD; ! 163: ! 164: /* Create the MDI client filling the client area */ ! 165: hwndMDIClient = CreateWindow ("mdiclient", ! 166: NULL, ! 167: WS_CHILD | WS_CLIPCHILDREN | ! 168: WS_VSCROLL | WS_HSCROLL, ! 169: 0, ! 170: 0, ! 171: 0, ! 172: 0, ! 173: hwnd, ! 174: (HMENU)0xCAC, ! 175: hInst, ! 176: (LPSTR)&ccs); ! 177: ! 178: ! 179: ShowWindow (hwndMDIClient,SW_SHOW); ! 180: ! 181: /* Check if printer can be initialized */ ! 182: if (hdc = GetPrinterDC (TRUE)){ ! 183: DeleteDC (hdc); ! 184: } ! 185: ! 186: break; ! 187: } ! 188: ! 189: case WM_INITMENU: ! 190: /* Set up the menu state */ ! 191: InitializeMenu ((HMENU)wParam); ! 192: break; ! 193: ! 194: case WM_WININICHANGE: ! 195: case WM_DEVMODECHANGE:{ ! 196: ! 197: /* If control panel changes default printer characteristics, ! 198: * reinitialize our printer information... ! 199: */ ! 200: HDC hdc; ! 201: ! 202: if (hdc = GetPrinterDC (TRUE)){ ! 203: DeleteDC (hdc); ! 204: } ! 205: break; ! 206: } ! 207: ! 208: ! 209: case WM_COMMAND: ! 210: /* Direct all menu selection or accelerator commands to another ! 211: * function ! 212: */ ! 213: CommandHandler(hwnd, wParam, lParam); ! 214: break; ! 215: ! 216: case WM_CLOSE: ! 217: /* don't close if any children cancel the operation */ ! 218: if (!QueryCloseAllChildren ()) ! 219: break; ! 220: DestroyWindow (hwnd); ! 221: break; ! 222: ! 223: case WM_QUERYENDSESSION: ! 224: /* Before session ends, check that all files are saved */ ! 225: return QueryCloseAllChildren (); ! 226: ! 227: case WM_DESTROY: ! 228: PostQuitMessage (0); ! 229: break; ! 230: ! 231: default: ! 232: /* use DefFrameProc() instead of DefWindowProc() since there ! 233: * are things that have to be handled differently because of MDI ! 234: */ ! 235: return DefFrameProc (hwnd,hwndMDIClient,msg,wParam,lParam); ! 236: } ! 237: return 0; ! 238: } ! 239: ! 240: /**************************************************************************** ! 241: * * ! 242: * FUNCTION : MPMDIWndProc ( hwnd, msg, wParam, lParam ) * ! 243: * * ! 244: * PURPOSE : The window function for the individual document windows, * ! 245: * each of which has a "note". Each of these windows contain * ! 246: * one multi-line edit control filling their client area. * ! 247: * In response to the following: * ! 248: * * ! 249: * WM_CREATE : Creates & diplays an edit control * ! 250: * and does some initialization. * ! 251: * * ! 252: * WM_MDIACTIVATE : Activates/deactivates the child. * ! 253: * * ! 254: * WM_SETFOCUS : Sets focus on the edit control. * ! 255: * * ! 256: * WM_SIZE : Resizes the edit control. * ! 257: * * ! 258: * WM_COMMAND : Processes some of the edit * ! 259: * commands, saves files and alters * ! 260: * the edit wrap state. * ! 261: * * ! 262: * WM_CLOSE : Closes child if it is ok to do so.* ! 263: * * ! 264: * WM_QUERYENDSESSION : Same as above. * ! 265: * * ! 266: ****************************************************************************/ ! 267: ! 268: LONG APIENTRY MPMDIChildWndProc ( ! 269: register HWND hwnd, ! 270: UINT msg, ! 271: register UINT wParam, ! 272: LONG lParam) ! 273: ! 274: { ! 275: HWND hwndEdit; ! 276: ! 277: switch (msg){ ! 278: case WM_CREATE: ! 279: /* Create an edit control */ ! 280: hwndEdit = CreateWindow ("edit", ! 281: NULL, ! 282: WS_CHILD|WS_HSCROLL|WS_MAXIMIZE|WS_VISIBLE|WS_VSCROLL|ES_AUTOHSCROLL|ES_AUTOVSCROLL|ES_MULTILINE, ! 283: 0, ! 284: 0, ! 285: 0, ! 286: 0, ! 287: hwnd, ! 288: (HMENU)ID_EDIT, ! 289: hInst, ! 290: NULL); ! 291: ! 292: /* Remember the window handle and initialize some window attributes */ ! 293: SetWindowLong (hwnd, GWL_HWNDEDIT, (LONG) hwndEdit); ! 294: SetWindowWord (hwnd, GWW_CHANGED, FALSE); ! 295: SetWindowWord (hwnd, GWL_WORDWRAP, FALSE); ! 296: SetWindowWord (hwnd, GWW_UNTITLED, TRUE); ! 297: SetFocus (hwndEdit); ! 298: break; ! 299: ! 300: case WM_MDIACTIVATE: ! 301: /* If we're activating this child, remember it */ ! 302: if (GET_WM_MDIACTIVATE_FACTIVATE(hwnd, wParam, lParam)){ ! 303: hwndActive = hwnd; ! 304: hwndActiveEdit = (HWND)GetWindowLong (hwnd, GWL_HWNDEDIT); ! 305: } ! 306: else{ ! 307: hwndActive = NULL; ! 308: hwndActiveEdit = NULL; ! 309: } ! 310: break; ! 311: ! 312: case WM_QUERYENDSESSION: ! 313: /* Prompt to save the child */ ! 314: return !QueryCloseChild (hwnd); ! 315: ! 316: case WM_CLOSE: ! 317: /* If its OK to close the child, do so, else ignore */ ! 318: if (QueryCloseChild (hwnd)) ! 319: goto CallDCP; ! 320: else ! 321: break; ! 322: ! 323: case WM_SIZE:{ ! 324: RECT rc; ! 325: ! 326: /* On creation or resize, size the edit control. */ ! 327: hwndEdit = (HWND)GetWindowLong (hwnd, GWL_HWNDEDIT); ! 328: GetClientRect (hwnd, &rc); ! 329: MoveWindow (hwndEdit, ! 330: rc.left, ! 331: rc.top, ! 332: rc.right-rc.left, ! 333: rc.bottom-rc.top, ! 334: TRUE); ! 335: goto CallDCP; ! 336: } ! 337: ! 338: case WM_SETFOCUS: ! 339: SetFocus ((HWND)GetWindowLong (hwnd, GWL_HWNDEDIT)); ! 340: break; ! 341: ! 342: case WM_COMMAND: ! 343: switch (LOWORD(wParam)){ ! 344: case ID_EDIT: ! 345: switch (GET_WM_COMMAND_CMD(wParam, lParam)){ ! 346: case EN_CHANGE: ! 347: ! 348: /* If the contents of the edit control have changed, ! 349: set the changed flag ! 350: */ ! 351: SetWindowWord (hwnd, GWW_CHANGED, TRUE); ! 352: break; ! 353: ! 354: case EN_ERRSPACE: ! 355: /* If the control is out of space, honk */ ! 356: MessageBeep (0); ! 357: break; ! 358: ! 359: default: ! 360: goto CallDCP; ! 361: } ! 362: break; ! 363: ! 364: case IDM_FILESAVE: ! 365: /* If empty file, ignore save */ ! 366: if ((GetWindowWord(hwnd, GWW_UNTITLED)) && (!ChangeFile(hwnd))) ! 367: break; ! 368: ! 369: /* Save the contents of the edit control and reset the ! 370: * changed flag ! 371: */ ! 372: SaveFile (hwnd); ! 373: SetWindowWord (hwnd, GWW_CHANGED, FALSE); ! 374: break; ! 375: ! 376: case IDM_EDITWRAP: { ! 377: INT fWrap = GetWindowWord (hwnd, GWL_WORDWRAP); ! 378: ! 379: /* Set the wrap state, or report it */ ! 380: if (GET_WM_COMMAND_HWND(wParam, lParam)){ ! 381: fWrap = !fWrap; ! 382: if(!SetWrap (hwnd, fWrap)){ ! 383: fWrap = !fWrap; /* call failed, restore original fWrap */ ! 384: } ! 385: } ! 386: ! 387: /* return wrap state */ ! 388: return fWrap; ! 389: } ! 390: ! 391: default: ! 392: goto CallDCP; ! 393: } ! 394: break; ! 395: ! 396: default: ! 397: CallDCP: ! 398: /* Again, since the MDI default behaviour is a little different, ! 399: * call DefMDIChildProc instead of DefWindowProc() ! 400: */ ! 401: return DefMDIChildProc (hwnd, msg, wParam, lParam); ! 402: } ! 403: return FALSE; ! 404: } ! 405: ! 406: ! 407: /**************************************************************************** ! 408: * * ! 409: * FUNCTION : AboutDlgProc ( hwnd, msg, wParam, lParam ) * ! 410: * * ! 411: * PURPOSE : Dialog function for the About MultiPad... dialog. * ! 412: * * ! 413: ****************************************************************************/ ! 414: BOOL APIENTRY AboutDlgProc ( ! 415: HWND hwnd, ! 416: register UINT msg, ! 417: register UINT wParam, ! 418: LONG lParam) ! 419: { ! 420: switch (msg){ ! 421: case WM_INITDIALOG: ! 422: /* nothing to initialize */ ! 423: break; ! 424: ! 425: case WM_COMMAND: ! 426: switch (LOWORD(wParam)){ ! 427: case IDOK: ! 428: case IDCANCEL: ! 429: EndDialog(hwnd, 0); ! 430: break; ! 431: ! 432: default: ! 433: return FALSE; ! 434: } ! 435: break; ! 436: ! 437: default: ! 438: return FALSE; ! 439: } ! 440: ! 441: return TRUE; ! 442: UNREFERENCED_PARAMETER(lParam); ! 443: } ! 444: ! 445: /**************************************************************************** ! 446: * * ! 447: * FUNCTION : Initializemenu ( hMenu ) * ! 448: * * ! 449: * PURPOSE : Sets up greying, enabling and checking of main menu items * ! 450: * based on the app's state. * ! 451: * * ! 452: ****************************************************************************/ ! 453: VOID NEAR PASCAL InitializeMenu (register HANDLE hmenu) ! 454: { ! 455: register WORD status; ! 456: WORD i; ! 457: INT j; ! 458: LONG l; ! 459: ! 460: /* Is there any active child to talk to? */ ! 461: if (hwndActiveEdit){ ! 462: /* If edit control can respond to an undo request, enable the ! 463: * undo selection. ! 464: */ ! 465: if (SendMessage (hwndActiveEdit, EM_CANUNDO, 0, 0L)) ! 466: ! 467: status = MF_ENABLED; ! 468: else ! 469: status = MF_GRAYED; ! 470: EnableMenuItem (hmenu, IDM_EDITUNDO, status); ! 471: ! 472: /* If edit control is non-empty, allow cut/copy/clear */ ! 473: l = (LONG)SendMessage(hwndActiveEdit, EM_GETSEL, NULL, NULL); ! 474: ! 475: ! 476: status = (WORD) ((HIWORD(l) == LOWORD(l)) ? MF_GRAYED : MF_ENABLED); ! 477: EnableMenuItem (hmenu, IDM_EDITCUT, status); ! 478: EnableMenuItem (hmenu, IDM_EDITCOPY, status); ! 479: EnableMenuItem (hmenu, IDM_EDITCLEAR, status); ! 480: ! 481: status=MF_GRAYED; ! 482: /* If the clipboard contains some CF_TEXT data, allow paste */ ! 483: if (OpenClipboard (hwndFrame)){ ! 484: UINT wFmt = 0; ! 485: ! 486: while (wFmt = EnumClipboardFormats (wFmt)) ! 487: if (wFmt == CF_TEXT){ ! 488: status = MF_ENABLED; ! 489: break; ! 490: } ! 491: ! 492: CloseClipboard (); ! 493: } ! 494: EnableMenuItem (hmenu, IDM_EDITPASTE, status); ! 495: ! 496: /* Set the word wrap state for the window */ ! 497: if ((WORD) SendMessage(hwndActive, WM_COMMAND, GET_WM_COMMAND_MPS(IDM_EDITWRAP, 0, 0))) ! 498: status = MF_CHECKED; ! 499: else ! 500: status = MF_UNCHECKED; ! 501: CheckMenuItem (hmenu, IDM_EDITWRAP, status); ! 502: ! 503: /* Enable search menu items only if there is a search string */ ! 504: if (*szSearch) ! 505: status = MF_ENABLED; ! 506: else ! 507: status = MF_GRAYED; ! 508: EnableMenuItem (hmenu, IDM_SEARCHNEXT, status); ! 509: EnableMenuItem (hmenu, IDM_SEARCHPREV, status); ! 510: ! 511: /* Enable File/Print only if a printer is available */ ! 512: status = (WORD) (iPrinter ? MF_ENABLED : MF_GRAYED); ! 513: EnableMenuItem (hmenu, IDM_FILEPRINT, status); ! 514: ! 515: /* select all and wrap toggle always enabled */ ! 516: status = MF_ENABLED; ! 517: EnableMenuItem(hmenu, IDM_EDITSELECT, status); ! 518: EnableMenuItem(hmenu, IDM_EDITWRAP, status); ! 519: EnableMenuItem(hmenu, IDM_SEARCHFIND, status); ! 520: } ! 521: else { ! 522: /* There are no active child windows */ ! 523: status = MF_GRAYED; ! 524: ! 525: /* No active window, so disable everything */ ! 526: for (i = IDM_EDITFIRST; i <= IDM_EDITLAST; i++) ! 527: EnableMenuItem (hmenu, i, status); ! 528: ! 529: CheckMenuItem (hmenu, IDM_EDITWRAP, MF_UNCHECKED); ! 530: ! 531: for (i = IDM_SEARCHFIRST; i <= IDM_SEARCHLAST; i++) ! 532: EnableMenuItem (hmenu, i, status); ! 533: ! 534: EnableMenuItem (hmenu, IDM_FILEPRINT, status); ! 535: ! 536: } ! 537: ! 538: /* The following menu items are enabled if there is an active window */ ! 539: EnableMenuItem (hmenu, IDM_FILESAVE, status); ! 540: EnableMenuItem (hmenu, IDM_FILESAVEAS, status); ! 541: EnableMenuItem (hmenu, IDM_WINDOWTILE, status); ! 542: EnableMenuItem (hmenu, IDM_WINDOWCASCADE, status); ! 543: EnableMenuItem (hmenu, IDM_WINDOWICONS, status); ! 544: EnableMenuItem (hmenu, IDM_WINDOWCLOSEALL, status); ! 545: ! 546: /* Allow printer setup only if printer driver supports device initialization */ ! 547: if (iPrinter < 2) ! 548: status = MF_GRAYED; ! 549: EnableMenuItem ( hmenu, IDM_FILESETUP, status); ! 550: UNREFERENCED_PARAMETER(j); ! 551: ! 552: } ! 553: ! 554: /**************************************************************************** ! 555: * * ! 556: * FUNCTION : CloseAllChildren () * ! 557: * * ! 558: * PURPOSE : Destroys all MDI child windows. * ! 559: * * ! 560: ****************************************************************************/ ! 561: VOID NEAR PASCAL CloseAllChildren () ! 562: { ! 563: register HWND hwndT; ! 564: ! 565: /* hide the MDI client window to avoid multiple repaints */ ! 566: ShowWindow(hwndMDIClient,SW_HIDE); ! 567: ! 568: /* As long as the MDI client has a child, destroy it */ ! 569: while ( hwndT = GetWindow (hwndMDIClient, GW_CHILD)){ ! 570: ! 571: /* Skip the icon title windows */ ! 572: while (hwndT && GetWindow (hwndT, GW_OWNER)) ! 573: hwndT = GetWindow (hwndT, GW_HWNDNEXT); ! 574: ! 575: if (!hwndT) ! 576: break; ! 577: ! 578: SendMessage (hwndMDIClient, WM_MDIDESTROY, (UINT)hwndT, 0L); ! 579: } ! 580: } ! 581: ! 582: /**************************************************************************** ! 583: * * ! 584: * FUNCTION : CommandHandler () * ! 585: * * ! 586: * PURPOSE : Processes all "frame" WM_COMMAND messages. * ! 587: * * ! 588: ****************************************************************************/ ! 589: VOID NEAR PASCAL CommandHandler ( ! 590: register HWND hwnd, ! 591: register UINT wParam, ! 592: LONG lParam) ! 593: ! 594: { ! 595: switch (LOWORD(wParam)){ ! 596: case IDM_FILENEW: ! 597: /* Add a new, empty MDI child */ ! 598: AddFile (NULL); ! 599: break; ! 600: ! 601: case IDM_FILEOPEN: ! 602: MyReadFile (hwnd); ! 603: break; ! 604: ! 605: case IDM_FILESAVE: ! 606: /* Save the active child MDI */ ! 607: SendMessage(hwndActive, WM_COMMAND, GET_WM_COMMAND_MPS(IDM_FILESAVE, 0, 0)); ! 608: break; ! 609: ! 610: case IDM_FILESAVEAS: ! 611: /* Save active child MDI under another name */ ! 612: if (ChangeFile (hwndActive)) ! 613: SendMessage(hwndActive, WM_COMMAND, GET_WM_COMMAND_MPS(IDM_FILESAVE, 0, 0)); ! 614: break; ! 615: ! 616: case IDM_FILEPRINT: ! 617: /* Print the active child MDI */ ! 618: PrintFile (hwndActive); ! 619: break; ! 620: ! 621: case IDM_FILESETUP: ! 622: /* Set up the printer environment for this app */ ! 623: GetInitializationData (hwnd); ! 624: break; ! 625: ! 626: case IDM_FILEMENU:{ ! 627: ! 628: /* lengthen / shorten the size of the MDI menu */ ! 629: HMENU hMenu; ! 630: HMENU hWindowMenu; ! 631: INT i; ! 632: ! 633: if (lpMenu == IDMULTIPAD){ ! 634: lpMenu = IDMULTIPAD2; ! 635: i = SHORTMENU; ! 636: } ! 637: else{ ! 638: lpMenu = IDMULTIPAD; ! 639: i = WINDOWMENU; ! 640: } ! 641: ! 642: hMenu = LoadMenu (hInst, lpMenu); ! 643: hWindowMenu = GetSubMenu (hMenu, i); ! 644: ! 645: /* Set the new menu */ ! 646: hMenu = (HMENU)SendMessage (hwndMDIClient, ! 647: WM_MDISETMENU, ! 648: (UINT)hMenu, ! 649: (LONG)hWindowMenu); ! 650: ! 651: DestroyMenu (hMenu); ! 652: DrawMenuBar (hwndFrame); ! 653: break; ! 654: } ! 655: ! 656: case IDM_FILEEXIT: ! 657: /* Close Multipad */ ! 658: SendMessage (hwnd, WM_CLOSE, 0, 0L); ! 659: break; ! 660: ! 661: case IDM_HELPABOUT:{ ! 662: ! 663: DialogBox(hInst, (LPSTR)IDD_ABOUT, hwnd, (WNDPROC)AboutDlgProc); ! 664: break; ! 665: } ! 666: ! 667: /* The following are edit commands. Pass these off to the active ! 668: * child's edit control window. ! 669: */ ! 670: case IDM_EDITCOPY: ! 671: SendMessage (hwndActiveEdit, WM_COPY, 0, 0L); ! 672: break; ! 673: ! 674: case IDM_EDITPASTE: ! 675: SendMessage (hwndActiveEdit, WM_PASTE, 0, 0L); ! 676: break; ! 677: ! 678: case IDM_EDITCUT: ! 679: SendMessage (hwndActiveEdit, WM_CUT, 0, 0L); ! 680: break; ! 681: ! 682: case IDM_EDITCLEAR: ! 683: SendMessage (hwndActiveEdit, EM_REPLACESEL, 0,( LONG)(LPSTR)""); ! 684: break; ! 685: ! 686: case IDM_EDITSELECT: ! 687: SendMessage(hwndActiveEdit, EM_SETSEL, GET_EM_SETSEL_MPS(0, 0xe000)); ! 688: break; ! 689: ! 690: case IDM_EDITUNDO: ! 691: SendMessage (hwndActiveEdit, EM_UNDO, 0, 0L); ! 692: break; ! 693: ! 694: case IDM_EDITWRAP: ! 695: SendMessage(hwndActive, WM_COMMAND, GET_WM_COMMAND_MPS(IDM_EDITWRAP, 1, 0)); ! 696: break; ! 697: ! 698: case IDM_SEARCHFIND: ! 699: /* Put up the find dialog box */ ! 700: Find (); ! 701: break; ! 702: ! 703: case IDM_SEARCHNEXT: ! 704: /* Find next occurence */ ! 705: FindNext (); ! 706: break; ! 707: ! 708: case IDM_SEARCHPREV: ! 709: /* Find previous occurence */ ! 710: FindPrev (); ! 711: break; ! 712: ! 713: /* The following are window commands - these are handled by the ! 714: * MDI Client. ! 715: */ ! 716: case IDM_WINDOWTILE: ! 717: /* Tile MDI windows */ ! 718: SendMessage (hwndMDIClient, WM_MDITILE, 0, 0L); ! 719: break; ! 720: ! 721: case IDM_WINDOWCASCADE: ! 722: /* Cascade MDI windows */ ! 723: SendMessage (hwndMDIClient, WM_MDICASCADE, 0, 0L); ! 724: break; ! 725: ! 726: case IDM_WINDOWICONS: ! 727: /* Auto - arrange MDI icons */ ! 728: SendMessage (hwndMDIClient, WM_MDIICONARRANGE, 0, 0L); ! 729: break; ! 730: ! 731: case IDM_WINDOWCLOSEALL: ! 732: /* Abort operation if something is not saved */ ! 733: if (!QueryCloseAllChildren()) ! 734: break; ! 735: ! 736: CloseAllChildren(); ! 737: ! 738: /* Show the window since CloseAllChilren() hides the window ! 739: * for fewer repaints. ! 740: */ ! 741: ShowWindow( hwndMDIClient, SW_SHOW); ! 742: ! 743: break; ! 744: ! 745: default: ! 746: /* ! 747: * This is essential, since there are frame WM_COMMANDS generated ! 748: * by the MDI system for activating child windows via the ! 749: * window menu. ! 750: */ ! 751: DefFrameProc(hwnd, hwndMDIClient, WM_COMMAND, wParam, lParam); ! 752: } ! 753: } ! 754: /**************************************************************************** ! 755: * * ! 756: * FUNCTION : SetWrap () * ! 757: * * ! 758: * PURPOSE : Changes the word wrapping in an edit control. Since this * ! 759: * cannot be done by direct means, the function creates a new * ! 760: * edit control, moves data from the old control to the new * ! 761: * control and destroys the original control. Note that the * ! 762: * function assumes that the child being modified is currently* ! 763: * active. * * ! 764: * * ! 765: ****************************************************************************/ ! 766: ! 767: BOOL NEAR PASCAL SetWrap( ! 768: HWND hwnd, ! 769: BOOL fWrap) ! 770: ! 771: { ! 772: LONG dws; ! 773: HANDLE hT; ! 774: HANDLE hTT; ! 775: HWND hwndOld; ! 776: HWND hwndNew; ! 777: RECT rc; ! 778: ! 779: /* Change word wrap mode */ ! 780: SetWindowLong (hwnd, GWL_WORDWRAP, fWrap); ! 781: ! 782: /* Create the appropriate window style, adding a horizontal scroll ! 783: * facility if wrapping is not present. ! 784: */ ! 785: dws = WS_CHILD | WS_VSCROLL | ES_AUTOVSCROLL | ES_MULTILINE; ! 786: if (!fWrap) ! 787: dws |= WS_HSCROLL | ES_AUTOHSCROLL; ! 788: ! 789: /* Create a new child window */ ! 790: hwndNew = CreateWindow ( "edit", ! 791: NULL, ! 792: dws, ! 793: 0, ! 794: SW_SHOW, ! 795: 0, ! 796: 0, ! 797: hwnd, ! 798: (HMENU)ID_EDIT, ! 799: hInst, ! 800: NULL); ! 801: ! 802: /* Get handle to current edit control */ ! 803: hwndOld = (HWND)GetWindowLong (hwnd, GWL_HWNDEDIT); ! 804: ! 805: /* Get the data handle of the old control */ ! 806: hT = (HANDLE)SendMessage (hwndOld, EM_GETHANDLE, 0, 0L); ! 807: ! 808: /* Create a dummy data handle and make it the handle to ! 809: * the old edit control( hT still references the text of ! 810: * old control). ! 811: */ ! 812: hTT = LocalAlloc (LHND, 0); ! 813: if(!hTT){ ! 814: MessageBox(hwnd, "<SetWrap> Not enough memory. Can't Change Wrap Mode!", NULL, MB_OK | MB_ICONHAND); ! 815: return(FALSE); ! 816: } ! 817: ! 818: SendMessage (hwndOld, EM_SETHANDLE, (UINT)hTT, 0L); ! 819: ! 820: /* Make the new window the window of interest and destroy the ! 821: * old control. ! 822: */ ! 823: SetWindowLong (hwnd, GWL_HWNDEDIT, (LONG)hwndNew); ! 824: hwndActiveEdit = hwndNew; ! 825: DestroyWindow (hwndOld); ! 826: ! 827: /* Cause the window to be properly sized */ ! 828: SendMessage (hwnd, WM_SIZE, 0, 0L); ! 829: ! 830: /* Free the new window's old data handle and set it to ! 831: * hT (text of old edit control) ! 832: */ ! 833: LocalFree ((HANDLE)SendMessage (hwndNew, EM_GETHANDLE, 0, 0L)); ! 834: SendMessage (hwndNew, EM_SETHANDLE, (UINT)hT, 0L); ! 835: ! 836: ShowWindow (hwndNew, SW_SHOW); ! 837: ! 838: /* Set focus to the new edit control */ ! 839: SetFocus (hwndNew); ! 840: ! 841: UNREFERENCED_PARAMETER(rc); ! 842: } ! 843: ! 844: ! 845: /**************************************************************************** ! 846: * * ! 847: * FUNCTION : MPError ( hwnd, flags, id, ...) * ! 848: * * ! 849: * PURPOSE : Flashes a Message Box to the user. The format string is * ! 850: * taken from the STRINGTABLE. * ! 851: * * ! 852: * RETURNS : Returns value returned by MessageBox() to the caller. * ! 853: * * ! 854: ****************************************************************************/ ! 855: SHORT MPError( ! 856: HWND hwnd, ! 857: WORD bFlags, ! 858: WORD id, ! 859: char *psz ) ! 860: { ! 861: CHAR sz[160]; ! 862: CHAR szFmt[128]; ! 863: ! 864: LoadString (hInst, id, szFmt, sizeof (szFmt)); ! 865: sprintf (sz, szFmt, psz ); ! 866: LoadString (hInst, (WORD)IDS_APPNAME, (LPSTR)szFmt, sizeof (szFmt)); ! 867: return( (SHORT)MessageBox (hwndFrame, sz, szFmt, bFlags)); ! 868: UNREFERENCED_PARAMETER(hwnd); ! 869: } ! 870: ! 871: ! 872: /**************************************************************************** ! 873: * * ! 874: * FUNCTION : QueryCloseAllChildren() * ! 875: * * ! 876: * PURPOSE : Asks the child windows if it is ok to close up app. Nothing* ! 877: * is destroyed at this point. The z-order is not changed. * ! 878: * * ! 879: * RETURNS : TRUE - If all children agree to the query. * ! 880: * FALSE- If any one of them disagrees. * ! 881: * * ! 882: ****************************************************************************/ ! 883: ! 884: BOOL NEAR PASCAL QueryCloseAllChildren() ! 885: { ! 886: register HWND hwndT; ! 887: ! 888: for ( hwndT = GetWindow (hwndMDIClient, GW_CHILD); ! 889: hwndT; ! 890: hwndT = GetWindow (hwndT, GW_HWNDNEXT) ){ ! 891: ! 892: /* Skip if an icon title window */ ! 893: if (GetWindow (hwndT, GW_OWNER)) ! 894: continue; ! 895: ! 896: if (SendMessage (hwndT, WM_QUERYENDSESSION, 0, 0L)) ! 897: return FALSE; ! 898: } ! 899: return TRUE; ! 900: } ! 901: ! 902: /**************************************************************************** ! 903: * * ! 904: * FUNCTION : QueryCloseChild (hwnd) * ! 905: * * ! 906: * PURPOSE : If the child MDI is unsaved, allow the user to save, not * ! 907: * save, or cancel the close operation. * ! 908: * * ! 909: * RETURNS : TRUE - if user chooses save or not save, or if the file * ! 910: * has not changed. * ! 911: * FALSE - otherwise. * ! 912: * * ! 913: ****************************************************************************/ ! 914: ! 915: BOOL NEAR PASCAL QueryCloseChild(register HWND hwnd) ! 916: { ! 917: CHAR sz [64]; ! 918: register INT i; ! 919: ! 920: /* Return OK if edit control has not changed. */ ! 921: if (!GetWindowWord (hwnd, GWW_CHANGED)) ! 922: return TRUE; ! 923: ! 924: GetWindowText (hwnd, sz, sizeof(sz)); ! 925: ! 926: /* Ask user whether to save / not save / cancel */ ! 927: i = MPError (hwnd, ! 928: MB_YESNOCANCEL|MB_ICONQUESTION,IDS_CLOSESAVE, ! 929: (LPSTR)sz); ! 930: ! 931: switch (i){ ! 932: case IDYES: ! 933: /* User wants file saved */ ! 934: SaveFile(hwnd); ! 935: break; ! 936: ! 937: case IDNO: ! 938: /* User doesn't want file saved */ ! 939: break; ! 940: ! 941: default: ! 942: /* We couldn't do the messagebox, or not ok to close */ ! 943: return FALSE; ! 944: } ! 945: return TRUE; ! 946: } ! 947: ! 948: ! 949: LPSTR GetCmdLine( VOID ) ! 950: { ! 951: LPSTR lpCmdLine, lpT; ! 952: ! 953: lpCmdLine = GetCommandLine(); ! 954: ! 955: // on Win32, lpCmdLine's first string includes its own name, remove this ! 956: // to make it exactly like the windows command line. ! 957: ! 958: if (*lpCmdLine) { ! 959: lpT = strchr(lpCmdLine, ' '); // skip self name ! 960: if (lpT) { ! 961: lpCmdLine = lpT; ! 962: while (*lpCmdLine == ' ') { ! 963: lpCmdLine++; // skip spaces to end or first cmd ! 964: } ! 965: } else { ! 966: lpCmdLine += strlen(lpCmdLine); // point to NULL ! 967: } ! 968: } ! 969: return(lpCmdLine); ! 970: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.