![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dlgedit.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / samples / sdktools / dlgedit|
Return to dlgedit.c CVS log | Up to [WindowsNT SDKs] / mstools / samples / sdktools / dlgedit |
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: dlgedit.c ! 14: * ! 15: * Main function and window procedure for the Dialog Box Editor. ! 16: * ! 17: * Functions: ! 18: * ! 19: * MainWndProc() ! 20: * ReadWindowPos() ! 21: * WriteWindowPos() ! 22: * InitApplication() ! 23: * InitInstance() ! 24: * PenWinRegister() ! 25: * GetSystemValues() ! 26: * ReadEnv() ! 27: * WriteEnv() ! 28: * LoadSysColorBitmaps() ! 29: * LoadAlterBitmap() ! 30: * RGBInvertRGB() ! 31: * SizeRibbons() ! 32: * DialogTerminate() ! 33: * ! 34: * Comments: ! 35: * ! 36: * Because of the need for a dialog in both work and test mode to be ! 37: * shown relative to the client area of its parent, and because the ! 38: * editor has a ribbon control along the top of its client area, there ! 39: * needed to be another window created that will be the actual parent ! 40: * of the dialog being edited. This window, called the ghwndSubClient ! 41: * window, is sized to be the size of the editors client area minus ! 42: * the height of the ribbon window at the top. This makes it so that ! 43: * a dialog that has an origin of 0,0 will have the top edge of its ! 44: * client area just below the bottom of the ribbon window in the ! 45: * editor. This window does not need any special processing. It simply ! 46: * paints its background with the app workspace color, and is used as ! 47: * the basis for coordinate conversion for the dialog. ! 48: * ! 49: ****************************************************************************/ ! 50: ! 51: #include "dlgedit.h" ! 52: #include "dlgfuncs.h" ! 53: #include "dlgextrn.h" ! 54: #include "dialogs.h" ! 55: ! 56: #include <commdlg.h> ! 57: ! 58: #include <stdlib.h> ! 59: #include <string.h> ! 60: ! 61: STATICFN BOOL InitApplication(HANDLE hInstance); ! 62: STATICFN BOOL InitInstance(HANDLE hInstance, INT nCmdShow); ! 63: STATICFN VOID PenWinRegister(VOID); ! 64: STATICFN VOID GetSystemValues(VOID); ! 65: STATICFN VOID ReadEnv(VOID); ! 66: STATICFN VOID WriteEnv(VOID); ! 67: STATICFN VOID LoadSysColorBitmaps(VOID); ! 68: STATICFN HBITMAP LoadAlterBitmap(INT idbm, DWORD rgbNew, DWORD rgbNew2); ! 69: STATICFN DWORD RGBInvertRGB(DWORD rgb); ! 70: STATICFN VOID SizeRibbons(HWND hwnd); ! 71: STATICFN VOID DialogTerminate(VOID); ! 72: ! 73: static RECT grcAppPos; // Saves the app's window pos. ! 74: static UINT gmsgHelp; // Registered help message from commdlg. ! 75: static BOOL fStartAsIcon = FALSE; // TRUE if app is started minimized. ! 76: ! 77: /* ! 78: * Contains the address of the Pen Windows callback. ! 79: */ ! 80: typedef VOID ( APIENTRY *LPFNPENWIN)(WORD, BOOL); ! 81: static LPFNPENWIN lpfnRegisterPenApp; ! 82: ! 83: ! 84: ! 85: /************************************************************************ ! 86: * WinMain ! 87: * ! 88: * This is the main function for the dialog editor. ! 89: * ! 90: ************************************************************************/ ! 91: ! 92: INT WINAPI WinMain( ! 93: HINSTANCE hInstance, ! 94: HINSTANCE hPrevInstance, ! 95: LPSTR lpCmdLine, ! 96: INT nCmdShow) ! 97: { ! 98: MSG msg; ! 99: ! 100: if (!hPrevInstance) { ! 101: if (!InitApplication(hInstance)) { ! 102: Message(MSG_NOINIT); ! 103: return FALSE; ! 104: } ! 105: } ! 106: ! 107: if (!InitInstance(hInstance, nCmdShow)) { ! 108: Message(MSG_NOINIT); ! 109: return FALSE; ! 110: } ! 111: ! 112: while (GetMessage(&msg, NULL, 0, 0)) { ! 113: if (!ghwndTestDlg || !IsDialogMessage(ghwndTestDlg, &msg)) { ! 114: if (!hwndStatus || !IsDialogMessage(hwndStatus, &msg)) { ! 115: if (!TranslateAccelerator(ghwndMain, ghAccTable, &msg)) { ! 116: TranslateMessage(&msg); ! 117: DispatchMessage(&msg); ! 118: } ! 119: } ! 120: } ! 121: } ! 122: ! 123: DialogTerminate(); ! 124: ! 125: /* ! 126: * Return the value from PostQuitMessage. ! 127: */ ! 128: return msg.wParam; ! 129: } ! 130: ! 131: ! 132: ! 133: /************************************************************************ ! 134: * InitApplication ! 135: * ! 136: * Registers the window classes. ! 137: * ! 138: * Arguments: ! 139: * HANDLE hInstance - Instance handle from WinMain. ! 140: * ! 141: * Returns: ! 142: * TRUE if all of the window classes were created; otherwise, FALSE. ! 143: * ! 144: ************************************************************************/ ! 145: ! 146: STATICFN BOOL InitApplication( ! 147: HANDLE hInstance) ! 148: { ! 149: WNDCLASS wc; ! 150: ! 151: wc.style = CS_DBLCLKS; ! 152: wc.lpfnWndProc = MainWndProc; ! 153: wc.cbClsExtra = 0; ! 154: wc.cbWndExtra = sizeof(DWORD); ! 155: wc.hInstance = hInstance; ! 156: wc.hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(IDICON_DLGEDIT)); ! 157: wc.hCursor = LoadCursor(NULL, IDC_ARROW); ! 158: wc.hbrBackground = (HBRUSH)(COLOR_APPWORKSPACE + 1); ! 159: wc.lpszMenuName = MAKEINTRESOURCE(IDMENU_MAIN); ! 160: wc.lpszClassName = szMainClass; ! 161: if (!RegisterClass(&wc)) ! 162: return FALSE; ! 163: ! 164: wc.style = 0; ! 165: wc.lpfnWndProc = DefWindowProc; ! 166: wc.cbClsExtra = 0; ! 167: wc.cbWndExtra = 0; ! 168: wc.hInstance = hInstance; ! 169: wc.hIcon = NULL; ! 170: wc.hCursor = LoadCursor(NULL, IDC_ARROW); ! 171: wc.hbrBackground = (HBRUSH)(COLOR_APPWORKSPACE + 1); ! 172: wc.lpszMenuName = NULL; ! 173: wc.lpszClassName = szSubClientClass; ! 174: if (!RegisterClass(&wc)) ! 175: return FALSE; ! 176: ! 177: wc.style = CS_DBLCLKS; ! 178: wc.lpfnWndProc = DragWndProc; ! 179: wc.cbClsExtra = 0; ! 180: wc.cbWndExtra = sizeof(DWORD); ! 181: wc.hInstance = hInstance; ! 182: wc.hIcon = NULL; ! 183: wc.hCursor = LoadCursor(NULL, IDC_ARROW); ! 184: wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1); ! 185: wc.lpszMenuName = NULL; ! 186: wc.lpszClassName = szDragClass; ! 187: if (!RegisterClass(&wc)) ! 188: return FALSE; ! 189: ! 190: wc.style = 0; ! 191: wc.lpfnWndProc = ToolboxWndProc; ! 192: wc.cbClsExtra = 0; ! 193: wc.cbWndExtra = 0; ! 194: wc.hInstance = hInstance; ! 195: wc.hIcon = NULL; ! 196: wc.hCursor = LoadCursor(NULL, IDC_ARROW); ! 197: wc.hbrBackground = GetStockObject(LTGRAY_BRUSH); ! 198: wc.lpszMenuName = NULL; ! 199: wc.lpszClassName = szToolboxClass; ! 200: if (!RegisterClass(&wc)) ! 201: return FALSE; ! 202: ! 203: wc.style = 0; ! 204: wc.lpfnWndProc = ToolBtnWndProc; ! 205: wc.cbClsExtra = 0; ! 206: wc.cbWndExtra = 0; ! 207: wc.hInstance = hInstance; ! 208: wc.hIcon = NULL; ! 209: wc.hCursor = LoadCursor(NULL, IDC_ARROW); ! 210: wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1); ! 211: wc.lpszMenuName = NULL; ! 212: wc.lpszClassName = szToolBtnClass; ! 213: if (!RegisterClass(&wc)) ! 214: return FALSE; ! 215: ! 216: wc.style = CS_DBLCLKS | CS_HREDRAW | CS_VREDRAW; ! 217: wc.lpfnWndProc = CustomWndProc; ! 218: wc.cbClsExtra = 0; ! 219: wc.cbWndExtra = 0; ! 220: wc.hInstance = hInstance; ! 221: wc.hIcon = NULL; ! 222: wc.hCursor = LoadCursor(NULL, IDC_ARROW); ! 223: wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1); ! 224: wc.lpszMenuName = NULL; ! 225: wc.lpszClassName = szCustomClass; ! 226: if (!RegisterClass(&wc)) ! 227: return FALSE; ! 228: ! 229: return TRUE; ! 230: } ! 231: ! 232: ! 233: ! 234: /************************************************************************ ! 235: * InitInstance ! 236: * ! 237: * Initializes the dialog editor by loading resources, etc. ! 238: * ! 239: * Arguments: ! 240: * HANDLE hInstance - Instance handle from WinMain. ! 241: * int nCmdShow - Show command from WinMain. ! 242: * ! 243: * Returns: ! 244: * FALSE if any errors occurred during initialization ! 245: * ! 246: ************************************************************************/ ! 247: ! 248: STATICFN BOOL InitInstance( ! 249: HANDLE hInstance, ! 250: INT nCmdShow) ! 251: { ! 252: HDC hDC; ! 253: TEXTMETRIC tm; ! 254: INT x; ! 255: INT y; ! 256: INT cx; ! 257: INT cy; ! 258: BOOL fMaximized; ! 259: INT i; ! 260: TCHAR szArg1[CCHTEXTMAX]; ! 261: ! 262: ghInst = hInstance; ! 263: ! 264: /* ! 265: * We need a mouse - make sure we have one. ! 266: */ ! 267: if (!GetSystemMetrics(SM_MOUSEPRESENT)) { ! 268: Message(MSG_NOMOUSE); ! 269: return FALSE; ! 270: } ! 271: ! 272: /* ! 273: * Register for Pen Windows, if it is present. ! 274: */ ! 275: PenWinRegister(); ! 276: ! 277: ghAccTable = LoadAccelerators(ghInst, MAKEINTRESOURCE(IDACCEL_MAIN)); ! 278: ! 279: /* ! 280: * Create a dark gray pen for use in borders later. ! 281: */ ! 282: if (!(hpenDarkGray = CreatePen(PS_SOLID, 1, DARKGRAY))) ! 283: return FALSE; ! 284: ! 285: /* ! 286: * Get some system constants. ! 287: */ ! 288: GetSystemValues(); ! 289: ! 290: /* ! 291: * Note that this must be done instead of using the text metrics, ! 292: * because Windows internally generates a better average value for ! 293: * proportional fonts, and we must match it or our dialogs will ! 294: * be out of proportion. ! 295: */ ! 296: gcxSysChar = LOWORD(GetDialogBaseUnits()); ! 297: gcySysChar = HIWORD(GetDialogBaseUnits()); ! 298: ! 299: /* ! 300: * Because some useful worker routines like WinToDUPoint use ! 301: * the values in gcd.c*Char, set them to be the default font right ! 302: * away. When a dialog is loaded with a different font, they ! 303: * will be modified. ! 304: */ ! 305: gcd.cxChar = gcxSysChar; ! 306: gcd.cyChar = gcySysChar; ! 307: ! 308: /* ! 309: * Build the help file name path. Assume the help file is in the ! 310: * same directory as the executable. ! 311: */ ! 312: GetModuleFileName(ghInst, gszHelpFile, CCHMAXPATH); ! 313: *FileInPath(gszHelpFile) = CHAR_NULL; ! 314: lstrcat(gszHelpFile, ids(IDS_HELPFILE)); ! 315: ! 316: /* ! 317: * Register the message for help from the common dialogs. ! 318: */ ! 319: gmsgHelp = RegisterWindowMessage(HELPMSGSTRING); ! 320: ! 321: /* ! 322: * Hook the message filter stream so that we can detect F1 keystrokes. ! 323: */ ! 324: ghhkMsgFilter = SetWindowsHook(WH_MSGFILTER, (HOOKPROC)MsgFilterHookFunc); ! 325: ! 326: /* ! 327: * Read the last position for the app. ! 328: */ ! 329: if (!ReadWindowPos(szAppPos, &x, &y, &cx, &cy, &fMaximized)) { ! 330: x = CW_USEDEFAULT; ! 331: y = CW_USEDEFAULT; ! 332: cx = CW_USEDEFAULT; ! 333: cy = CW_USEDEFAULT; ! 334: fMaximized = FALSE; ! 335: } ! 336: ! 337: /* ! 338: * Create the main window. ! 339: */ ! 340: if (!(ghwndMain = CreateWindow(szMainClass, NULL, ! 341: WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN, ! 342: x, y, cx, cy, NULL, NULL, hInstance, NULL))) ! 343: return FALSE; ! 344: ! 345: ShowFileStatus(TRUE); ! 346: ! 347: /* ! 348: * Read the Preferences data. ! 349: */ ! 350: ReadEnv(); ! 351: ! 352: /* ! 353: * If the app was saved when maximized (and they didn't start it up ! 354: * with some kind of an option to have it minimized or in some ! 355: * other funny initial state from the shell), then cause it to ! 356: * be maximized when shown. ! 357: */ ! 358: if (fMaximized && (nCmdShow == SW_SHOWNORMAL || nCmdShow == SW_SHOW)) ! 359: nCmdShow = SW_SHOWMAXIMIZED; ! 360: ! 361: ShowWindow(ghwndMain, nCmdShow); ! 362: UpdateWindow(ghwndMain); ! 363: ! 364: /* ! 365: * Did the user start this app minimized from the program manager? ! 366: */ ! 367: if (IsIconic(ghwndMain)) { ! 368: /* ! 369: * Set a flag. The showing of the toolbox will be deferred ! 370: * until the app is restored. ! 371: */ ! 372: fStartAsIcon = TRUE; ! 373: } ! 374: else { ! 375: /* ! 376: * If they had the Toolbox before, show it now. ! 377: */ ! 378: if (gfShowToolbox) ! 379: ToolboxShow(TRUE); ! 380: } ! 381: ! 382: hcurArrow = LoadCursor(NULL, IDC_ARROW); ! 383: hcurWait = LoadCursor(NULL, IDC_WAIT); ! 384: hcurOutSel = LoadCursor(ghInst, MAKEINTRESOURCE(IDCUR_OUTSEL)); ! 385: hcurMove = LoadCursor(ghInst, MAKEINTRESOURCE(IDCUR_MOVE)); ! 386: hcurInsert = LoadCursor(ghInst, MAKEINTRESOURCE(IDCUR_INSERT)); ! 387: hcurDropTool = LoadCursor(ghInst, MAKEINTRESOURCE(IDCUR_DROPTOOL)); ! 388: hcurSizeNESW = LoadCursor(NULL, IDC_SIZENESW); ! 389: hcurSizeNS = LoadCursor(NULL, IDC_SIZENS); ! 390: hcurSizeNWSE = LoadCursor(NULL, IDC_SIZENWSE); ! 391: hcurSizeWE = LoadCursor(NULL, IDC_SIZEWE); ! 392: ! 393: if (!hcurArrow || ! 394: !hcurWait || ! 395: !hcurOutSel || ! 396: !hcurMove || ! 397: !hcurDropTool || ! 398: !hcurInsert) ! 399: return FALSE; ! 400: ! 401: if ((hDC = GetDC(ghwndMain)) == NULL) ! 402: return FALSE; ! 403: ! 404: GetTextMetrics(hDC, &tm); ! 405: ! 406: gcyPixelsPerInch = GetDeviceCaps(hDC, LOGPIXELSY); ! 407: ! 408: /* ! 409: * Create a memory DC for drawing bitmaps. ! 410: */ ! 411: ghDCMem = CreateCompatibleDC(hDC); ! 412: ! 413: ReleaseDC(ghwndMain, hDC); ! 414: ! 415: /* ! 416: * Load the bitmaps that depend on system colors. ! 417: */ ! 418: LoadSysColorBitmaps(); ! 419: ! 420: fmtDlg = RegisterClipboardFormat(L"DIALOG"); ! 421: ! 422: /* ! 423: * Initialize the icon control ordinal to the icon id from our exe ! 424: * that we will use to show these kind of controls. ! 425: */ ! 426: WriteOrd(&gordIcon, IDICON_ICON); ! 427: ! 428: /* ! 429: * Initialize the default text fields in the awcd array. Because ! 430: * CCONTROLS does not include the dialog type, it has to be done ! 431: * separately. ! 432: */ ! 433: awcd[W_DIALOG].pszTextDefault = ids(awcd[W_DIALOG].idsTextDefault); ! 434: for (i = 0; i < CCONTROLS; i++) ! 435: awcd[i].pszTextDefault = ids(awcd[i].idsTextDefault); ! 436: ! 437: /* ! 438: * If there was a command line argument specified, try and open ! 439: * it as the initial file. ! 440: */ ! 441: if (__argc > 1) { ! 442: MultiByteToWideChar(CP_ACP, 0, __argv[1], -1, szArg1, CCHTEXTMAX); ! 443: OpenCmdLineFile(szArg1); ! 444: } ! 445: ! 446: /* ! 447: * Be sure the focus is on the main window. This corrects a ! 448: * problem where the accelerators don't initially work because ! 449: * the focus gets placed on the Properties Bar. ! 450: */ ! 451: SetFocus(ghwndMain); ! 452: ! 453: return TRUE; ! 454: } ! 455: ! 456: ! 457: ! 458: /************************************************************************ ! 459: * PenWinRegister ! 460: * ! 461: * This function will register for Pen Windows, if it is present. ! 462: * ! 463: ************************************************************************/ ! 464: ! 465: STATICFN VOID PenWinRegister(VOID) ! 466: { ! 467: HANDLE hmod; ! 468: ! 469: if (!(hmod = (HANDLE)GetSystemMetrics(SM_PENWINDOWS))) ! 470: return; ! 471: ! 472: if (lpfnRegisterPenApp = ! 473: (LPFNPENWIN)GetProcAddress(hmod, "RegisterPenApp")) ! 474: (*lpfnRegisterPenApp)(1, TRUE); // Be Pen-Enhanced! ! 475: } ! 476: ! 477: ! 478: ! 479: /************************************************************************ ! 480: * GetSystemValues ! 481: * ! 482: * This function reads various system values. It is called at init time, ! 483: * as well as if we are informed by a WM_SYSVALUECHANGED message that ! 484: * some of these values have been changed. ! 485: * ! 486: ************************************************************************/ ! 487: ! 488: STATICFN VOID GetSystemValues(VOID) ! 489: { ! 490: gcyBorder = GetSystemMetrics(SM_CYBORDER); ! 491: ! 492: /* ! 493: * The distance that the mouse can move during a pre-drag operation ! 494: * before starting to drag the control anyways is based on the ! 495: * mouse double-click movement distances in the system. ! 496: */ ! 497: gcxPreDragMax = GetSystemMetrics(SM_CXDOUBLECLK); ! 498: gcyPreDragMax = GetSystemMetrics(SM_CYDOUBLECLK); ! 499: ! 500: /* ! 501: * The number of milliseconds that the pre-drag debounce time lasts. ! 502: */ ! 503: gmsecPreDrag = 250; ! 504: } ! 505: ! 506: ! 507: ! 508: /************************************************************************ ! 509: * ReadWindowPos ! 510: * ! 511: * This function retrieves the saved window position for a window and ! 512: * returns it in the specified variables. It is used between sessions ! 513: * to restore the application windows to the position they had when ! 514: * the editor was last exited. ! 515: * ! 516: * Arguments: ! 517: * LPTSTR pszKeyName - KeyName the position was saved under. ! 518: * PINT px - Saved x position. ! 519: * PINT py - Saved y position. ! 520: * PINT pcx - Saved width. ! 521: * PINT pcy - Saved height. ! 522: * BOOL *pfMaximized - Set to TRUE if window was maximized when saved. ! 523: * ! 524: * Returns: ! 525: * TRUE if the position could be read, or FALSE otherwise. ! 526: * If FALSE is returned, the values in the specified variables are ! 527: * not valid! The caller must be able to handle a FALSE return and ! 528: * supply a default position for the window. ! 529: * ! 530: ************************************************************************/ ! 531: ! 532: BOOL ReadWindowPos( ! 533: LPTSTR pszKeyName, ! 534: PINT px, ! 535: PINT py, ! 536: PINT pcx, ! 537: PINT pcy, ! 538: BOOL *pfMaximized) ! 539: { ! 540: static CHAR szSep[] = " ,"; ! 541: TCHAR szBuf[CCHTEXTMAX]; ! 542: CHAR szBufAnsi[CCHTEXTMAX]; ! 543: PSTR psz; ! 544: BOOL fDefCharUsed; ! 545: ! 546: if (!GetPrivateProfileString(ids(IDS_APPNAME), ! 547: pszKeyName, szEmpty, szBuf, CCHTEXTMAX, ids(IDS_DLGEDITINI))) ! 548: return FALSE; ! 549: ! 550: WideCharToMultiByte(CP_ACP, 0, szBuf, -1, szBufAnsi, CCHTEXTMAX, ! 551: NULL, &fDefCharUsed); ! 552: ! 553: if (!(psz = strtok(szBufAnsi, szSep))) ! 554: return FALSE; ! 555: ! 556: *px = atoi(psz); ! 557: ! 558: if (!(psz = strtok(NULL, szSep))) ! 559: return FALSE; ! 560: ! 561: *py = atoi(psz); ! 562: ! 563: if (!(psz = strtok(NULL, szSep))) ! 564: return FALSE; ! 565: ! 566: *pcx = atoi(psz); ! 567: ! 568: if (!(psz = strtok(NULL, szSep))) ! 569: return FALSE; ! 570: ! 571: *pcy = atoi(psz); ! 572: ! 573: /* ! 574: * If there is a "1" following the coordinates, the window was ! 575: * maximized when it was saved. ! 576: */ ! 577: *pfMaximized = FALSE; ! 578: if ((psz = strtok(NULL, szSep)) && atoi(psz) == 1) ! 579: *pfMaximized = TRUE; ! 580: ! 581: /* ! 582: * Don't allow a zero sized window. ! 583: */ ! 584: if (*pcx == 0 || *pcy == 0) ! 585: return FALSE; ! 586: ! 587: /* ! 588: * Return success. ! 589: */ ! 590: return TRUE; ! 591: ! 592: } ! 593: ! 594: ! 595: ! 596: /************************************************************************ ! 597: * WriteWindowPos ! 598: * ! 599: * This function writes the position of a window to the ! 600: * editor's profile file under the specified keyname. ! 601: * The ReadWindowPos function is the counterpart of this ! 602: * function. ! 603: * ! 604: * Arguments: ! 605: * PRECT prc - Rectangle for the "restored" window size. ! 606: * BOOL fMaximized - TRUE if the window is maximized. ! 607: * LPTSTR pszKeyName - KeyName to save the position under. ! 608: * ! 609: ************************************************************************/ ! 610: ! 611: VOID WriteWindowPos( ! 612: PRECT prc, ! 613: BOOL fMaximized, ! 614: LPTSTR pszKeyName) ! 615: { ! 616: TCHAR szBuf[CCHTEXTMAX]; ! 617: ! 618: wsprintf(szBuf, L"%d %d %d %d", prc->left, prc->top, ! 619: prc->right - prc->left, prc->bottom - prc->top); ! 620: ! 621: if (fMaximized) ! 622: lstrcat(szBuf, L" 1"); ! 623: ! 624: WritePrivateProfileString(ids(IDS_APPNAME), ! 625: pszKeyName, szBuf, ids(IDS_DLGEDITINI)); ! 626: } ! 627: ! 628: ! 629: ! 630: /************************************************************************* ! 631: * ReadEnv ! 632: * ! 633: * This function initializes variables from their counterparts ! 634: * in the private profile file for DlgEdit. The application ! 635: * merely needs to construct an array of INIENTRY structures ! 636: * to describe the variables that must be initialized. ! 637: * ! 638: * Note that the original value read from the profile is saved when ! 639: * it is read. This allows us to optimize what needs to be written ! 640: * out with WriteEnv. ! 641: * ! 642: *************************************************************************/ ! 643: ! 644: STATICFN VOID ReadEnv(VOID) ! 645: { ! 646: register INT i; ! 647: ! 648: for (i = 0; gaie[i].pszKeyName; i++) { ! 649: *gaie[i].pnVar = gaie[i].nSave = ! 650: GetPrivateProfileInt(ids(IDS_APPNAME), ! 651: gaie[i].pszKeyName, gaie[i].nDefault, ! 652: ids(IDS_DLGEDITINI)); ! 653: } ! 654: ! 655: ReadCustomProfile(); ! 656: } ! 657: ! 658: ! 659: ! 660: /************************************************************************* ! 661: * WriteEnv ! 662: * ! 663: * This function is the counterpart to ReadEnv. It saves values ! 664: * in the profile file. ! 665: * ! 666: *************************************************************************/ ! 667: ! 668: STATICFN VOID WriteEnv(VOID) ! 669: { ! 670: register INT i; ! 671: TCHAR szBuf[17]; ! 672: ! 673: for (i = 0; gaie[i].pszKeyName; i++) { ! 674: /* ! 675: * Has the user changed the value since it was read? ! 676: */ ! 677: if (gaie[i].nSave != *gaie[i].pnVar) { ! 678: /* ! 679: * If the new value is the same as the default value, ! 680: * erase the entry from the ini file. Otherwise, ! 681: * write the user-specified value out. ! 682: */ ! 683: if (*gaie[i].pnVar == gaie[i].nDefault) { ! 684: WritePrivateProfileString(ids(IDS_APPNAME), ! 685: gaie[i].pszKeyName, NULL, ids(IDS_DLGEDITINI)); ! 686: } ! 687: else { ! 688: itoaw(*gaie[i].pnVar, szBuf, 10); ! 689: WritePrivateProfileString(ids(IDS_APPNAME), ! 690: gaie[i].pszKeyName, szBuf, ids(IDS_DLGEDITINI)); ! 691: } ! 692: } ! 693: } ! 694: ! 695: WriteCustomProfile(); ! 696: } ! 697: ! 698: ! 699: ! 700: /************************************************************************ ! 701: * MainWndProc ! 702: * ! 703: * This is the window procedure for the "dlgedit" class. This is the ! 704: * class of the main dialog editor "client" window. ! 705: * ! 706: ************************************************************************/ ! 707: ! 708: WINDOWPROC MainWndProc( ! 709: HWND hwnd, ! 710: UINT msg, ! 711: WPARAM wParam, ! 712: LPARAM lParam) ! 713: { ! 714: switch (msg) { ! 715: case WM_CREATE: ! 716: { ! 717: RECT rc; ! 718: ! 719: /* ! 720: * Create the status window. ! 721: */ ! 722: CreateDialog(ghInst, MAKEINTRESOURCE(DID_STATUS), ! 723: hwnd, StatusDlgProc); ! 724: ! 725: /* ! 726: * Save away its height for sizing later (like when ! 727: * the app is minimized then restored). ! 728: */ ! 729: GetWindowRect(hwndStatus, &rc); ! 730: gcyStatus = rc.bottom - rc.top; ! 731: ! 732: ghwndSubClient = CreateWindow(szSubClientClass, NULL, ! 733: WS_CHILD | WS_VISIBLE, 0, 0, 0, 0, ! 734: hwnd, NULL, ghInst, NULL); ! 735: ! 736: ghMenuMain = GetMenu(hwnd); ! 737: LoadMenuBitmaps(ghMenuMain); ! 738: } ! 739: ! 740: break; ! 741: ! 742: case WM_ACTIVATE: ! 743: /* ! 744: * If the main window is getting activated, there is no ! 745: * currently active dialog. ! 746: */ ! 747: if (LOWORD(wParam)) ! 748: gidCurrentDlg = 0; ! 749: ! 750: goto DoDefault; ! 751: ! 752: case WM_INITMENU: ! 753: if (GetMenu(ghwndMain) == (HMENU)wParam) ! 754: InitMenu((HMENU)wParam); ! 755: ! 756: break; ! 757: ! 758: case WM_MENUSELECT: ! 759: if (HIWORD(wParam) & ! 760: (MF_POPUP | MF_SYSMENU)) ! 761: gMenuSelected = 0; ! 762: else ! 763: gMenuSelected = LOWORD(wParam); ! 764: ! 765: break; ! 766: ! 767: case WM_COMMAND: ! 768: DialogMenu(LOWORD(wParam)); ! 769: break; ! 770: ! 771: case WM_KEYDOWN: ! 772: switch (wParam) { ! 773: case VK_UP: ! 774: case VK_DOWN: ! 775: case VK_LEFT: ! 776: case VK_RIGHT: ! 777: if ((GetKeyState(VK_SHIFT) & 0x8000) || ! 778: (GetKeyState(VK_CONTROL) & 0x8000)) ! 779: break; ! 780: ! 781: /* ! 782: * Ignore it if we are not in a normal state ! 783: * (don't allow when dragging). ! 784: */ ! 785: if (gState != STATE_NORMAL) ! 786: break; ! 787: ! 788: /* ! 789: * Be sure any outstanding changes get applied ! 790: * without errors. ! 791: */ ! 792: if (!StatusApplyChanges()) ! 793: break; ! 794: ! 795: /* ! 796: * Move the control in the specified direction. ! 797: */ ! 798: MoveControl(wParam); ! 799: break; ! 800: ! 801: case VK_TAB: ! 802: if (GetKeyState(VK_CONTROL) & 0x8000) ! 803: break; ! 804: ! 805: /* ! 806: * Ignore it if we are not in a normal state ! 807: * (don't allow when dragging). ! 808: */ ! 809: if (gState != STATE_NORMAL) ! 810: break; ! 811: ! 812: /* ! 813: * Be sure any outstanding changes get applied ! 814: * without errors. ! 815: */ ! 816: if (!StatusApplyChanges()) ! 817: break; ! 818: ! 819: /* ! 820: * Is the shift key pressed also? ! 821: */ ! 822: if (GetKeyState(VK_SHIFT) & 0x8000) ! 823: SelectPrevious(); ! 824: else ! 825: SelectNext(); ! 826: ! 827: break; ! 828: ! 829: case VK_ESCAPE: ! 830: if ((GetKeyState(VK_SHIFT) & 0x8000) || ! 831: (GetKeyState(VK_CONTROL) & 0x8000)) ! 832: break; ! 833: ! 834: /* ! 835: * Be sure any outstanding changes get applied ! 836: * without errors. ! 837: */ ! 838: if (!StatusApplyChanges()) ! 839: break; ! 840: ! 841: if (gState == STATE_SELECTING) ! 842: OutlineSelectCancel(); ! 843: ! 844: /* ! 845: * Cancel any drag operation they might have been doing. ! 846: */ ! 847: if (gState != STATE_NORMAL) ! 848: DragCancel(); ! 849: ! 850: break; ! 851: ! 852: case VK_RETURN: ! 853: if ((GetKeyState(VK_SHIFT) & 0x8000) || ! 854: (GetKeyState(VK_CONTROL) & 0x8000)) ! 855: break; ! 856: ! 857: /* ! 858: * Be sure any outstanding changes get applied ! 859: * without errors. ! 860: */ ! 861: if (!StatusApplyChanges()) ! 862: break; ! 863: ! 864: switch (gState) { ! 865: POINTS mpt; ! 866: POINT pt; ! 867: DWORD dwPos; ! 868: ! 869: case STATE_SELECTING: ! 870: /* ! 871: * In outline selection mode. Map the ! 872: * location of the mouse at the time that ! 873: * the user pressed Enter into a point ! 874: * relative to the dialog client and complete ! 875: * the selection operation. ! 876: */ ! 877: dwPos = GetMessagePos(); ! 878: mpt = (*((POINTS *)&(dwPos))); ! 879: ((pt).x = (mpt).x, (pt).y = (mpt).y); ! 880: ScreenToClient(gcd.npc->hwnd, &pt); ! 881: OutlineSelectEnd(pt.x, pt.y); ! 882: ! 883: break; ! 884: ! 885: case STATE_DRAGGING: ! 886: case STATE_DRAGGINGNEW: ! 887: /* ! 888: * We are dragging something. Map the ! 889: * location of the mouse at the time ! 890: * that the user pressed Enter into a ! 891: * point relative to the proper window ! 892: * and complete the drag operation. ! 893: */ ! 894: dwPos = GetMessagePos(); ! 895: mpt = (*((POINTS *)&(dwPos))); ! 896: ((pt).x = (mpt).x, (pt).y = (mpt).y); ! 897: ! 898: /* ! 899: * The point must be changed to be relative to ! 900: * the window that the ending mouse up message ! 901: * would have come through, which will be the ! 902: * capture window for the drag. This will be ! 903: * the dialog if we are adding a new control, ! 904: * or it will be the selected control if we are ! 905: * dragging an existing control. ! 906: */ ! 907: ScreenToClient((gState == STATE_DRAGGING) ? ! 908: gnpcSel->hwnd : gcd.npc->hwnd, &pt); ! 909: ! 910: /* ! 911: * If the dialog is selected, map the points from ! 912: * the client area to the window. ! 913: */ ! 914: if (gfDlgSelected) ! 915: MapDlgClientPoint(&pt, TRUE); ! 916: ! 917: DragEnd(pt.x, pt.y); ! 918: ! 919: break; ! 920: } ! 921: ! 922: break; ! 923: } ! 924: ! 925: break; ! 926: ! 927: case WM_NCCALCSIZE: ! 928: /* ! 929: * Save away what is going to be the new window position. ! 930: */ ! 931: if (!IsIconic(hwnd) && !IsZoomed(hwnd)) ! 932: grcAppPos = *((LPRECT)lParam); ! 933: ! 934: /* ! 935: * Now let the DefWindowProc calculate the client area normally. ! 936: */ ! 937: goto DoDefault; ! 938: ! 939: case WM_MOVE: ! 940: if (gfEditingDlg) ! 941: RepositionDialog(); ! 942: ! 943: break; ! 944: ! 945: case WM_SIZE: ! 946: SizeRibbons(hwnd); ! 947: ! 948: /* ! 949: * Did the app start minimized and is it being restored ! 950: * for the first time? If so, show the toolbox if ! 951: * the user has requested it. ! 952: */ ! 953: if (fStartAsIcon && !IsIconic(hwnd)) { ! 954: if (gfShowToolbox) ! 955: ToolboxShow(TRUE); ! 956: ! 957: fStartAsIcon = FALSE; ! 958: } ! 959: ! 960: break; ! 961: ! 962: case WM_SYSCOLORCHANGE: ! 963: LoadSysColorBitmaps(); ! 964: break; ! 965: ! 966: case WM_CLOSE: ! 967: if (ghwndTestDlg) ! 968: DestroyTestDialog(); ! 969: ! 970: if (DoWeSave(FILE_INCLUDE) == IDCANCEL || ! 971: DoWeSave(FILE_RESOURCE) == IDCANCEL) ! 972: break; ! 973: ! 974: /* ! 975: * First destroy the Properties Bar. ! 976: */ ! 977: DestroyWindow(hwndStatus); ! 978: hwndStatus = NULL; ! 979: ! 980: DestroyWindow(hwnd); ! 981: break; ! 982: ! 983: case WM_QUERYENDSESSION: ! 984: if (ghwndTestDlg) ! 985: DestroyTestDialog(); ! 986: ! 987: if (DoWeSave(FILE_INCLUDE) == IDCANCEL || ! 988: DoWeSave(FILE_RESOURCE) == IDCANCEL) ! 989: return FALSE; ! 990: else ! 991: return TRUE; ! 992: ! 993: case WM_DESTROY: ! 994: /* ! 995: * Save the position of the app's window. ! 996: */ ! 997: WriteWindowPos(&grcAppPos, IsZoomed(hwnd), szAppPos); ! 998: ! 999: WinHelp(hwnd, gszHelpFile, HELP_QUIT, 0L); ! 1000: FreeMenuBitmaps(); ! 1001: PostQuitMessage(0); ! 1002: break; ! 1003: ! 1004: default: ! 1005: /* ! 1006: * Is this the registered help message from one of the common ! 1007: * dialogs? If so, show the help for it. ! 1008: * ! 1009: * The check to be sure gmsgHelp is non-zero is just in ! 1010: * case the call to register the help message failed ! 1011: * (it will return zero) and there happens to be a zero ! 1012: * message that gets sent to this window somehow. ! 1013: */ ! 1014: if (msg == gmsgHelp && gmsgHelp) { ! 1015: ShowHelp(FALSE); ! 1016: return 0; ! 1017: } ! 1018: ! 1019: DoDefault: ! 1020: return DefWindowProc(hwnd, msg, wParam, lParam); ! 1021: } ! 1022: ! 1023: return 0; ! 1024: } ! 1025: ! 1026: ! 1027: ! 1028: /************************************************************************ ! 1029: * LoadSysColorBitmaps ! 1030: * ! 1031: * This function loads bitmaps that depend on the system window and ! 1032: * highlight colors. As it loads them, it replaces two special colors ! 1033: * in them with some system colors. ! 1034: * This is used for the control type bitmaps that appear in lines ! 1035: * in the listbox in the Order/Group dialog. ! 1036: * ! 1037: ************************************************************************/ ! 1038: ! 1039: STATICFN VOID LoadSysColorBitmaps(VOID) ! 1040: { ! 1041: DWORD rgbWindow; ! 1042: DWORD rgbWindowText; ! 1043: DWORD rgbHighlight; ! 1044: DWORD rgbHighlightText; ! 1045: INT i; ! 1046: ! 1047: rgbWindow = GetSysColor(COLOR_WINDOW); ! 1048: rgbWindowText = GetSysColor(COLOR_WINDOWTEXT); ! 1049: rgbHighlight = GetSysColor(COLOR_HIGHLIGHT); ! 1050: rgbHighlightText = GetSysColor(COLOR_HIGHLIGHTTEXT); ! 1051: ! 1052: if (hbmTabStop) ! 1053: DeleteObject(hbmTabStop); ! 1054: ! 1055: hbmTabStop = LoadAlterBitmap(IDBM_TABSTOP, rgbWindow, rgbWindowText); ! 1056: ! 1057: if (hbmTabStopSel) ! 1058: DeleteObject(hbmTabStopSel); ! 1059: ! 1060: hbmTabStopSel = LoadAlterBitmap(IDBM_TABSTOP, ! 1061: rgbHighlight, rgbHighlightText); ! 1062: ! 1063: for (i = 0; i < CCONTROLS; i++) { ! 1064: if (awcd[i].hbmCtrlType) ! 1065: DeleteObject(awcd[i].hbmCtrlType); ! 1066: ! 1067: awcd[i].hbmCtrlType = LoadAlterBitmap( ! 1068: awcd[i].idbmCtrlType, rgbWindow, rgbWindowText); ! 1069: ! 1070: if (awcd[i].hbmCtrlTypeSel) ! 1071: DeleteObject(awcd[i].hbmCtrlTypeSel); ! 1072: ! 1073: awcd[i].hbmCtrlTypeSel = LoadAlterBitmap( ! 1074: awcd[i].idbmCtrlType, rgbHighlight, rgbHighlightText); ! 1075: } ! 1076: ! 1077: if (ghbmDragHandle) ! 1078: DeleteObject(ghbmDragHandle); ! 1079: ! 1080: ghbmDragHandle = LoadAlterBitmap(IDBM_DRAGHANDLE, ! 1081: rgbWindow, rgbHighlight); ! 1082: ! 1083: if (ghbmDragHandle2) ! 1084: DeleteObject(ghbmDragHandle2); ! 1085: ! 1086: ghbmDragHandle2 = LoadAlterBitmap(IDBM_DRAGHANDLE2, ! 1087: rgbWindow, rgbHighlight); ! 1088: } ! 1089: ! 1090: ! 1091: ! 1092: /************************************************************************ ! 1093: * LoadAlterBitmap ! 1094: * ! 1095: * This function loads a single bitmap. As it does, it replaces a ! 1096: * couple special RGB colors (REPLACECOLOR1 and REPLACECOLOR2) with ! 1097: * the passed in RGB colors. ! 1098: * ! 1099: * Arguments: ! 1100: * INT idbm - Integer ID of the bitmap to load. ! 1101: * DWORD rgbNew - Color to replace the special color with. ! 1102: * DWORD rgbNew2 - A second color to replace the second special color with. ! 1103: * ! 1104: * Returns: ! 1105: * The handle to the bitmap, or NULL if an error occurs. ! 1106: * ! 1107: ************************************************************************/ ! 1108: ! 1109: STATICFN HBITMAP LoadAlterBitmap( ! 1110: INT idbm, ! 1111: DWORD rgbNew, ! 1112: DWORD rgbNew2) ! 1113: { ! 1114: register INT i; ! 1115: LPBITMAPINFOHEADER lpbihInfo; ! 1116: HDC hdcScreen; ! 1117: HANDLE hresLoad; ! 1118: HANDLE hres; ! 1119: DWORD FAR *qlng; ! 1120: LPBYTE lpbBits; ! 1121: HANDLE hbmp; ! 1122: DWORD rgbReplace1; ! 1123: DWORD rgbReplace2; ! 1124: ! 1125: hresLoad = FindResource(ghInst, MAKEINTRESOURCE(idbm), RT_BITMAP); ! 1126: if (!hresLoad) ! 1127: return NULL; ! 1128: ! 1129: hres = LoadResource(ghInst, hresLoad); ! 1130: if (!hresLoad) ! 1131: return NULL; ! 1132: ! 1133: rgbNew = RGBInvertRGB(rgbNew); ! 1134: rgbNew2 = RGBInvertRGB(rgbNew2); ! 1135: rgbReplace1 = RGBInvertRGB(REPLACECOLOR1); ! 1136: rgbReplace2 = RGBInvertRGB(REPLACECOLOR2); ! 1137: lpbihInfo = (LPBITMAPINFOHEADER)LockResource(hres); ! 1138: qlng = (LPDWORD)((PBYTE)(lpbihInfo) + lpbihInfo->biSize); ! 1139: ! 1140: for (i = 0; i < (1 << lpbihInfo->biBitCount); i++, qlng++) { ! 1141: if (*qlng == rgbReplace1) ! 1142: *qlng = rgbNew; ! 1143: else if (*qlng == rgbReplace2) ! 1144: *qlng = rgbNew2; ! 1145: } ! 1146: ! 1147: /* ! 1148: * First skip over the header structure. ! 1149: */ ! 1150: lpbBits = (LPBYTE)(lpbihInfo + 1); ! 1151: ! 1152: /* ! 1153: * Skip the color table entries, if any. ! 1154: */ ! 1155: lpbBits += (1 << (lpbihInfo->biBitCount)) * sizeof(RGBQUAD); ! 1156: ! 1157: /* ! 1158: * Create a color bitmap compatible with the display device. ! 1159: */ ! 1160: if (hdcScreen = GetDC(NULL)) { ! 1161: hbmp = CreateDIBitmap(hdcScreen, lpbihInfo, (LONG)CBM_INIT, ! 1162: lpbBits, (LPBITMAPINFO)lpbihInfo, DIB_RGB_COLORS); ! 1163: ReleaseDC(NULL, hdcScreen); ! 1164: } ! 1165: ! 1166: UnlockResource(hres); ! 1167: FreeResource(hres); ! 1168: ! 1169: return hbmp; ! 1170: } ! 1171: ! 1172: ! 1173: ! 1174: /************************************************************************ ! 1175: * RGBInvertRGB ! 1176: * ! 1177: * Reverses the RGB order of a color. This needs to be done to match ! 1178: * the resource file format of the color table. ! 1179: * ! 1180: ************************************************************************/ ! 1181: ! 1182: STATICFN DWORD RGBInvertRGB( ! 1183: DWORD rgb) ! 1184: { ! 1185: return (DWORD)RGB(GetBValue(rgb), GetGValue(rgb), GetRValue(rgb)); ! 1186: } ! 1187: ! 1188: ! 1189: ! 1190: /************************************************************************ ! 1191: * SizeRibbons ! 1192: * ! 1193: * This function positions and sizes the child ribbon and subclient ! 1194: * windows in the dialog editor. It needs to be called any time the ! 1195: * size of the main windows changes. ! 1196: * ! 1197: * Arguments: ! 1198: * HWND hwnd - Parent window handle. ! 1199: * ! 1200: ************************************************************************/ ! 1201: ! 1202: STATICFN VOID SizeRibbons( ! 1203: HWND hwnd) ! 1204: { ! 1205: RECT rcClient; ! 1206: ! 1207: if (hwndStatus && !IsIconic(hwnd)) { ! 1208: /* ! 1209: * Get the client area. ! 1210: */ ! 1211: GetClientRect(hwnd, &rcClient); ! 1212: ! 1213: /* ! 1214: * Size/move the status and subclient window to fit ! 1215: * the new client area. ! 1216: */ ! 1217: SetWindowPos(hwndStatus, NULL, ! 1218: 0, 0, ! 1219: rcClient.right - rcClient.left, ! 1220: min(rcClient.bottom - rcClient.top, gcyStatus), ! 1221: SWP_NOACTIVATE | SWP_NOZORDER); ! 1222: ! 1223: SetWindowPos(ghwndSubClient, NULL, ! 1224: 0, gcyStatus, ! 1225: rcClient.right - rcClient.left, ! 1226: max((rcClient.bottom - rcClient.top) - gcyStatus, 0), ! 1227: SWP_NOACTIVATE | SWP_NOZORDER); ! 1228: } ! 1229: } ! 1230: ! 1231: ! 1232: ! 1233: /**************************************************************************** ! 1234: * DialogTerminate ! 1235: * ! 1236: * This undoes what DialogInit does. It should be called before terminating ! 1237: * and after a DialogInit. ! 1238: * ! 1239: ****************************************************************************/ ! 1240: ! 1241: STATICFN VOID DialogTerminate(VOID) ! 1242: { ! 1243: register INT i; ! 1244: ! 1245: /* ! 1246: * Save the Preferences data. ! 1247: */ ! 1248: WriteEnv(); ! 1249: ! 1250: if (hbmTabStop) ! 1251: DeleteObject(hbmTabStop); ! 1252: ! 1253: if (hbmTabStopSel) ! 1254: DeleteObject(hbmTabStopSel); ! 1255: ! 1256: if (ghbmDragHandle) ! 1257: DeleteObject(ghbmDragHandle); ! 1258: ! 1259: if (ghbmDragHandle2) ! 1260: DeleteObject(ghbmDragHandle2); ! 1261: ! 1262: if (ghDCMem) ! 1263: DeleteDC(ghDCMem); ! 1264: ! 1265: /* ! 1266: * Free the control type bitmaps. ! 1267: */ ! 1268: for (i = 0; i < CCONTROLS; i++) { ! 1269: if (awcd[i].hbmCtrlType) ! 1270: DeleteObject(awcd[i].hbmCtrlType); ! 1271: ! 1272: if (awcd[i].hbmCtrlTypeSel) ! 1273: DeleteObject(awcd[i].hbmCtrlTypeSel); ! 1274: } ! 1275: ! 1276: /* ! 1277: * Free all the custom control links. This must be done before the ! 1278: * app exits so that any loaded DLL's get unloaded! ! 1279: */ ! 1280: while (gpclHead) ! 1281: RemoveCustomLink(gpclHead); ! 1282: ! 1283: if (hpenDarkGray) ! 1284: DeleteObject(hpenDarkGray); ! 1285: ! 1286: if (ghhkMsgFilter) ! 1287: UnhookWindowsHookEx(ghhkMsgFilter); ! 1288: ! 1289: if (lpfnRegisterPenApp) ! 1290: (*lpfnRegisterPenApp)((WORD)1, FALSE); ! 1291: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.