![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to srvrdemo.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / samples / ole / srvrdemo|
Return to srvrdemo.c CVS log | Up to [WindowsNT SDKs] / mstools / samples / ole / srvrdemo |
1.1 ! root 1: /* ! 2: OLE SERVER DEMO ! 3: SrvrDemo.c ! 4: ! 5: This file contains the window handlers, and various initialization and ! 6: utility functions. ! 7: ! 8: (c) Copyright Microsoft Corp. 1990 - 1992 All Rights Reserved ! 9: */ ! 10: ! 11: ! 12: #define SERVERONLY ! 13: #include <windows.h> ! 14: #include <ole.h> ! 15: ! 16: #include "srvrdemo.h" ! 17: ! 18: /* Global variable definitions */ ! 19: ! 20: HWND hwndMain = NULL; ! 21: ! 22: // Since this is a not an MDI app, there can be only one server and one doc. ! 23: SRVR srvrMain; ! 24: DOC docMain; ! 25: CHAR szClient[cchFilenameMax]; ! 26: CHAR szClientDoc[cchFilenameMax]; ! 27: ! 28: // Has the user made changes to the document? ! 29: BOOL fDocChanged = FALSE; ! 30: ! 31: // Is this the first instance of this application currently running? ! 32: BOOL fFirstInstance = TRUE; ! 33: ! 34: // This flag is used when OleRevokeServerDoc returns OLE_WAIT_FOR_RELEASE, ! 35: // and we must wait until DocRelease is called. ! 36: BOOL fWaitingForDocRelease = FALSE; ! 37: ! 38: // This flag is used when OleRevokeServer returns OLE_WAIT_FOR_RELEASE, ! 39: // and we must wait until SrvrRelease is called. ! 40: BOOL fWaitingForSrvrRelease = FALSE; ! 41: ! 42: // This flag is set to TRUE after an application has called OleBlockServer ! 43: // and now wishes to unblock the queued messages. See WinMain. ! 44: // Server Demo never sets fUnblock to TRUE because it never calls ! 45: // OleBlockServer. ! 46: BOOL fUnblock = FALSE; ! 47: ! 48: // Set this to FALSE if you want to guarantee that the server will not revoke ! 49: // itself when SrvrRelease is called. This is used in the IDM_NEW case and ! 50: // the IDM_OPEN case (in OpenDoc). ! 51: BOOL fRevokeSrvrOnSrvrRelease = TRUE; ! 52: ! 53: // Version number, which is stored in the native data. ! 54: VERSION version = 1; ! 55: ! 56: HBRUSH hbrColor[chbrMax]; ! 57: ! 58: // Clipboard formats ! 59: OLECLIPFORMAT cfObjectLink; ! 60: OLECLIPFORMAT cfOwnerLink; ! 61: OLECLIPFORMAT cfNative; ! 62: ! 63: // Method tables. ! 64: OLESERVERDOCVTBL docvtbl; ! 65: OLEOBJECTVTBL objvtbl; ! 66: OLESERVERVTBL srvrvtbl; ! 67: ! 68: HANDLE hInst; ! 69: HANDLE hAccelTable; ! 70: HMENU hMainMenu = NULL; ! 71: ! 72: // Window dimensions saved in private profile. ! 73: static struct ! 74: { ! 75: INT nX; ! 76: INT nY; ! 77: INT nWidth; ! 78: INT nHeight; ! 79: } dimsSaved, dimsCurrent; ! 80: ! 81: ! 82: static enum ! 83: { ! 84: // Corresponds to the order of the menus in the .rc file. ! 85: menuposFile, ! 86: menuposEdit, ! 87: menuposColor, ! 88: menuposObject ! 89: }; ! 90: ! 91: ! 92: // Static functions. ! 93: static VOID DeleteInstance (VOID); ! 94: static BOOL ExitApplication (BOOL); ! 95: static VOID GetWord (LPSTR *plpszSrc, LPSTR lpszDst); ! 96: static BOOL InitApplication( HANDLE hInstance); ! 97: static BOOL InitInstance (HANDLE hInstance); ! 98: static BOOL ProcessCmdLine (LPSTR,HWND); ! 99: static VOID SaveDimensions (VOID); ! 100: static VOID SkipBlanks (LPSTR *plpsz); ! 101: static VOID UpdateObjMenus (VOID); ! 102: static BOOL FailedUpdate(HWND); ! 103: ! 104: /* WinMain ! 105: * ------- ! 106: * ! 107: * Standard windows entry point ! 108: * ! 109: * CUSTOMIZATION: None ! 110: * ! 111: */ ! 112: int WinMain( ! 113: HANDLE hInstance, ! 114: HANDLE hPrevInstance, ! 115: LPSTR lpCmdLine, ! 116: INT nCmdShow ! 117: ){ ! 118: MSG msg; ! 119: ! 120: if (!InitApplication(hInstance)) ! 121: return FALSE; ! 122: ! 123: msg.wParam = FALSE; ! 124: ! 125: if (!InitInstance(hInstance)) ! 126: goto errRtn; ! 127: ! 128: if (!InitServer (hwndMain, hInstance)) ! 129: goto errRtn; ! 130: ! 131: if (!ProcessCmdLine(lpCmdLine,hwndMain)) ! 132: { ! 133: ExitApplication(FALSE); ! 134: goto errRtn; ! 135: } ! 136: ! 137: for (;;) ! 138: { ! 139: // Your application should set fUnblock to TRUE when it decides ! 140: // to unblock. ! 141: if (fUnblock) ! 142: { ! 143: BOOL fMoreMsgs = TRUE; ! 144: while (fMoreMsgs) ! 145: { ! 146: OleUnblockServer (srvrMain.lhsrvr, &fMoreMsgs); ! 147: } ! 148: // We have taken care of all the messages in the OLE queue ! 149: fUnblock = FALSE; ! 150: } ! 151: ! 152: if (!GetMessage(&msg, NULL, NULL, NULL)) ! 153: break; ! 154: if( !TranslateAccelerator(hwndMain, hAccelTable, &msg)) ! 155: { ! 156: TranslateMessage(&msg); ! 157: DispatchMessage(&msg); ! 158: } ! 159: } ! 160: ! 161: ! 162: errRtn: ! 163: ! 164: DeleteInstance (); ! 165: return (msg.wParam); ! 166: } ! 167: ! 168: ! 169: ! 170: /* InitApplication ! 171: * --------------- ! 172: * ! 173: * Initialize the application - register the window classes ! 174: * ! 175: * HANDLE hInstance ! 176: * ! 177: * RETURNS: TRUE if classes are properly registered. ! 178: * FALSE otherwise ! 179: * ! 180: * CUSTOMIZATION: Re-implement ! 181: * ! 182: */ ! 183: static BOOL InitApplication( HANDLE hInstance ) ! 184: { ! 185: WNDCLASS wc; ! 186: ! 187: wc.lpszClassName = "MainClass"; ! 188: wc.lpfnWndProc = (WNDPROC)MainWndProc; ! 189: wc.style = NULL; ! 190: wc.cbClsExtra = 4; ! 191: wc.cbWndExtra = 0; ! 192: wc.hInstance = hInstance; ! 193: wc.hIcon = LoadIcon(hInstance, "DocIcon"); ! 194: wc.hCursor = LoadCursor(NULL, IDC_ARROW); ! 195: wc.hbrBackground = GetStockObject(WHITE_BRUSH); ! 196: wc.lpszMenuName = "MainMenu"; ! 197: ! 198: if (!RegisterClass(&wc)) ! 199: return FALSE; ! 200: ! 201: wc.lpszClassName = "ObjClass"; ! 202: wc.lpfnWndProc = (WNDPROC)ObjWndProc; ! 203: wc.hIcon = NULL; ! 204: wc.cbWndExtra = cbWindExtra; ! 205: wc.lpszMenuName = NULL; ! 206: wc.hCursor = LoadCursor(NULL, IDC_CROSS); ! 207: ! 208: if (!RegisterClass(&wc)) ! 209: return FALSE; ! 210: ! 211: return TRUE; ! 212: } ! 213: ! 214: ! 215: ! 216: /* InitInstance ! 217: * ------------ ! 218: * ! 219: * Create brushes used by the program, the main window, and ! 220: * do any other per-instance initialization. ! 221: * ! 222: * HANDLE hInstance ! 223: * ! 224: * RETURNS: TRUE if successful ! 225: * FALSE otherwise. ! 226: * ! 227: * CUSTOMIZATION: Re-implement ! 228: * ! 229: */ ! 230: static BOOL InitInstance (HANDLE hInstance) ! 231: { ! 232: LONG rglColor [chbrMax] = ! 233: { ! 234: 0x000000ff, // Red ! 235: 0x0000ff00, // Green ! 236: 0x00ff0000, // Blue ! 237: 0x00ffffff, // White ! 238: 0x00808080, // Gray ! 239: 0x00ffff00, // Cyan ! 240: 0x00ff00ff, // Magenta ! 241: 0x0000ffff // Yellow ! 242: }; ! 243: ! 244: ! 245: INT iColor; ! 246: ! 247: hInst = hInstance; ! 248: ! 249: // Initialize the method tables. ! 250: InitVTbls (); ! 251: ! 252: // Initialize the brushes used. ! 253: for (iColor = 0; iColor < chbrMax; iColor++) ! 254: hbrColor[iColor] = CreateSolidBrush (rglColor[iColor]); ! 255: ! 256: // Register clipboard formats. ! 257: cfObjectLink= RegisterClipboardFormat ("ObjectLink"); ! 258: cfOwnerLink = RegisterClipboardFormat ("OwnerLink"); ! 259: cfNative = RegisterClipboardFormat ("Native"); ! 260: ! 261: hAccelTable = LoadAccelerators(hInst, "Accelerators"); ! 262: // hMainMenu = LoadMenu(hInst, "MainMenu"); ! 263: ! 264: ! 265: hwndMain = CreateWindow( ! 266: "MainClass", ! 267: szAppName, ! 268: WS_OVERLAPPEDWINDOW, ! 269: CW_USEDEFAULT, CW_USEDEFAULT, ! 270: 3*OBJECT_WIDTH, 3*OBJECT_HEIGHT, ! 271: NULL, ! 272: NULL, ! 273: hInstance, ! 274: NULL ! 275: ); ! 276: ! 277: ! 278: if (!hwndMain) ! 279: return FALSE; ! 280: ! 281: szClient[0] = NULL; ! 282: lstrcpy (szClientDoc, "Client Document"); ! 283: ! 284: // Initialize global variables with LOGPIXELSX and LOGPIXELSY ! 285: ! 286: return TRUE; ! 287: ! 288: } ! 289: ! 290: ! 291: ! 292: /* DeleteInstance ! 293: * -------------- ! 294: * ! 295: * Deallocate the VTables, and the brushes created for this instance ! 296: * ! 297: * ! 298: * CUSTOMIZATION: The call to FreeVTbls must remain. ! 299: * ! 300: */ ! 301: static VOID DeleteInstance (VOID) ! 302: { ! 303: INT i; ! 304: ! 305: for (i = 0; i < chbrMax; i++) ! 306: DeleteObject (hbrColor[i]); ! 307: ! 308: } ! 309: ! 310: ! 311: ! 312: /* ExitApplication ! 313: * --------------- ! 314: * ! 315: * Handles the WM_CLOSE and WM_COMMAND/IDM_EXIT messages. ! 316: * ! 317: * RETURNS: TRUE if application should really terminate ! 318: * FALSE if not ! 319: * ! 320: * ! 321: * CUSTOMIZATION: None ! 322: * ! 323: */ ! 324: static BOOL ExitApplication (BOOL fUpdateLater) ! 325: { ! 326: ! 327: if (fUpdateLater) ! 328: { ! 329: // The non-standard OLE client did not accept the update ! 330: // when we requested it, so we are sending the client ! 331: // OLE_CLOSED now that we are closing the document. ! 332: SendDocMsg (OLE_CLOSED); ! 333: } ! 334: ! 335: if (StartRevokingServer() == OLE_WAIT_FOR_RELEASE) ! 336: Wait (&fWaitingForSrvrRelease); ! 337: /* SrvrRelease will not necessarily post a WM_QUIT message. ! 338: If the document is not embedded, SrvrRelease by itself does ! 339: not cause the application to terminate. But now we want it to. ! 340: */ ! 341: if (docMain.doctype != doctypeEmbedded) ! 342: PostQuitMessage(0); ! 343: SaveDimensions(); ! 344: return TRUE; ! 345: } ! 346: ! 347: ! 348: ! 349: /* MainWndProc ! 350: * ----------- ! 351: * ! 352: * Main window message handler. ! 353: * ! 354: * ! 355: * CUSTOMIZATION: Remove the color menu and the object menu entirely. ! 356: * Add handlers for your application's menu items and any ! 357: * Windows messages your application needs to handle. ! 358: * The handlers for the menu items that involve OLE ! 359: * can be added to, but no logic should be removed. ! 360: * ! 361: * ! 362: */ ! 363: LONG APIENTRY MainWndProc ! 364: (HWND hwnd, UINT message, DWORD wParam, LONG lParam ) ! 365: { ! 366: LPOBJ lpobj; ! 367: ! 368: switch (message) ! 369: { ! 370: case WM_COMMAND: ! 371: { ! 372: WORD wID = LOWORD(wParam); ! 373: ! 374: if (fWaitingForDocRelease) ! 375: { ! 376: ErrorBox ("Waiting for a document to be revoked.\n\rPlease wait."); ! 377: return NULL; ! 378: } ! 379: ! 380: switch (wID) ! 381: { ! 382: case IDM_EXIT: ! 383: SendMessage(hwnd, WM_SYSCOMMAND, SC_CLOSE, 0L); ! 384: break; ! 385: ! 386: case IDM_ABOUT: ! 387: DialogBox(hInst, "AboutBox", hwnd, (DLGPROC)About); ! 388: break; ! 389: ! 390: case IDM_NEW: ! 391: { ! 392: BOOL fUpdateLater; ! 393: OLESTATUS olestatus; ! 394: ! 395: if (SaveChangesOption (&fUpdateLater) == IDCANCEL) ! 396: break; ! 397: else if (fUpdateLater) ! 398: SendDocMsg (OLE_CLOSED); ! 399: ! 400: // We want to revoke the doc but not the server, so if ! 401: // SrvrRelease is called, do not revoke server. ! 402: fRevokeSrvrOnSrvrRelease = FALSE; ! 403: ! 404: if ((olestatus = RevokeDoc()) > OLE_WAIT_FOR_RELEASE) ! 405: { ! 406: ErrorBox ("Serious Error: Cannot revoke document."); ! 407: break; ! 408: } ! 409: else if (olestatus == OLE_WAIT_FOR_RELEASE) ! 410: Wait (&fWaitingForDocRelease); ! 411: ! 412: fRevokeSrvrOnSrvrRelease = TRUE; ! 413: ! 414: if (!CreateNewDoc (NULL, "(Untitled)", doctypeNew)) ! 415: { ! 416: ErrorBox ("Serious Error: Cannot create new document."); ! 417: break; ! 418: } ! 419: // Your application need not create a default object. ! 420: CreateNewObj (FALSE); ! 421: EmbeddingModeOff(); ! 422: break; ! 423: } ! 424: case IDM_OPEN: ! 425: OpenDoc(); ! 426: UpdateObjMenus(); ! 427: break; ! 428: ! 429: case IDM_SAVE: ! 430: SaveDoc(); ! 431: break; ! 432: ! 433: case IDM_SAVEAS: ! 434: if (!SaveDocAs ()) ! 435: break; ! 436: if (docMain.doctype != doctypeEmbedded) ! 437: EmbeddingModeOff(); ! 438: break; ! 439: ! 440: case IDM_UPDATE: ! 441: switch (OleSavedServerDoc (docMain.lhdoc)) ! 442: { ! 443: case OLE_ERROR_CANT_UPDATE_CLIENT: ! 444: if (!FailedUpdate(hwnd)) ! 445: ExitApplication(TRUE); ! 446: break; ! 447: case OLE_OK: ! 448: break; ! 449: default: ! 450: ErrorBox ("Serious Error: Cannot update."); ! 451: } ! 452: break; ! 453: ! 454: /* Color menu */ ! 455: ! 456: case IDM_RED: ! 457: case IDM_GREEN: ! 458: case IDM_BLUE: ! 459: case IDM_WHITE: ! 460: case IDM_GRAY: ! 461: case IDM_CYAN: ! 462: case IDM_MAGENTA: ! 463: case IDM_YELLOW: ! 464: lpobj = SelectedObject(); ! 465: lpobj->native.idmColor = wID; ! 466: // Recolor the object on the screen. ! 467: InvalidateRect (lpobj->hwnd, (LPRECT)NULL, TRUE); ! 468: UpdateWindow (lpobj->hwnd); ! 469: fDocChanged = TRUE; ! 470: if (docMain.doctype == doctypeFromFile) ! 471: // If object is linked, update it in client now. ! 472: SendObjMsg (lpobj, OLE_CHANGED); ! 473: break; ! 474: ! 475: /* Edit menu */ ! 476: ! 477: case IDM_COPY: ! 478: CutOrCopyObj (TRUE); ! 479: break; ! 480: ! 481: case IDM_CUT: ! 482: CutOrCopyObj (FALSE); ! 483: // Fall through. ! 484: ! 485: case IDM_DELETE: ! 486: RevokeObj (SelectedObject()); ! 487: DestroyWindow (SelectedObjectWindow()); ! 488: UpdateObjMenus(); ! 489: break; ! 490: ! 491: /* Object menu */ ! 492: ! 493: case IDM_NEXTOBJ: ! 494: lpobj = SelectedObject(); ! 495: /* The 1 in the second parameter puts the current window ! 496: at the bottom of the current window list. */ ! 497: SetWindowPos(lpobj->hwnd, (HANDLE)1, 0,0,0,0, ! 498: SWP_NOMOVE | SWP_NOSIZE); ! 499: break; ! 500: ! 501: case IDM_NEWOBJ: ! 502: lpobj = CreateNewObj (TRUE); ! 503: BringWindowToTop(lpobj->hwnd); ! 504: break; ! 505: ! 506: default: ! 507: ErrorBox ("Unknown Command."); ! 508: break; ! 509: } ! 510: break; ! 511: } ! 512: ! 513: case WM_NCCALCSIZE: ! 514: if (!IsIconic(hwnd) && !IsZoomed(hwnd)) ! 515: { ! 516: dimsCurrent.nX = ((LPRECT)lParam)->left; ! 517: dimsCurrent.nWidth = ((LPRECT)lParam)->right - dimsCurrent.nX; ! 518: dimsCurrent.nY = ((LPRECT)lParam)->top; ! 519: dimsCurrent.nHeight = ((LPRECT)lParam)->bottom - dimsCurrent.nY; ! 520: } ! 521: return DefWindowProc(hwnd, message, wParam, lParam); ! 522: break; ! 523: ! 524: case WM_QUERYENDSESSION: ! 525: { ! 526: BOOL fUpdateLater; ! 527: ! 528: if (SaveChangesOption(&fUpdateLater) == IDCANCEL) ! 529: return FALSE; ! 530: ! 531: if (fUpdateLater) ! 532: { ! 533: // The non-standard OLE client did not accept the update ! 534: // when we requested it, so we are sending the client ! 535: // OLE_CLOSED now that we are closing the document. ! 536: SendDocMsg (OLE_CLOSED); ! 537: } ! 538: return TRUE; ! 539: } ! 540: ! 541: case WM_CLOSE: ! 542: { ! 543: BOOL fUpdateLater; ! 544: ! 545: if (SaveChangesOption(&fUpdateLater) != IDCANCEL) ! 546: ExitApplication(fUpdateLater); ! 547: break; ! 548: } ! 549: ! 550: default: ! 551: return DefWindowProc(hwnd, message, wParam, lParam); ! 552: } ! 553: return NULL; ! 554: } ! 555: ! 556: ! 557: ! 558: /* About ! 559: * ----- ! 560: * ! 561: * "About Box" dialog handler. ! 562: * ! 563: * CUSTOMIZATION: None ! 564: * ! 565: */ ! 566: BOOL APIENTRY About (HWND hDlg, UINT message, DWORD wParam, LONG lParam) ! 567: { ! 568: switch (message) ! 569: { ! 570: case WM_INITDIALOG: ! 571: return TRUE; ! 572: ! 573: case WM_COMMAND: ! 574: { ! 575: WORD wID = LOWORD(wParam); ! 576: ! 577: if (wID == IDOK || wID == IDCANCEL) ! 578: { ! 579: EndDialog(hDlg, TRUE); ! 580: return TRUE; ! 581: } ! 582: break; ! 583: } ! 584: } ! 585: return FALSE; ! 586: } ! 587: ! 588: ! 589: ! 590: ! 591: /* ObjWndProc ! 592: * ---------- ! 593: * ! 594: * Message handler for the object windows. ! 595: * ! 596: * ! 597: * CUSTOMIZATION: Server Demo specific ! 598: * ! 599: */ ! 600: LONG APIENTRY ObjWndProc ! 601: (HWND hwnd, UINT message, DWORD wParam, LONG lParam) ! 602: { ! 603: static BOOL fCapture = FALSE; ! 604: static struct {RECT rect; POINT pt;} drag; ! 605: static RECT rectMain; ! 606: ! 607: switch (message) ! 608: { ! 609: case WM_CREATE: ! 610: { ! 611: LPOBJ lpobj; ! 612: LPCREATESTRUCT lpcs; ! 613: // The call to CreateWindow puts lpobj into lpCreateParams ! 614: lpcs = (LPCREATESTRUCT) lParam; ! 615: lpobj = (LPOBJ) lpcs->lpCreateParams; ! 616: // Associate the window just created with the object. ! 617: lpobj->hwnd = hwnd; ! 618: /* Store pointer to object in the window structure. */ ! 619: SetWindowLong(hwnd, ibLpobj, (LONG) lpobj); ! 620: UpdateObjMenus (); ! 621: break; ! 622: } ! 623: case WM_SIZE: ! 624: { ! 625: RECT rect; ! 626: if (fWaitingForDocRelease) ! 627: { ! 628: ErrorBox ("Waiting for a document to be revoked.\n\rPlease wait."); ! 629: return NULL; ! 630: } ! 631: // Get coordinates of object relative to main window's client area. ! 632: GetWindowRect (hwnd, (LPRECT)&rect); ! 633: ScreenToClient (hwndMain, (LPPOINT)&rect); ! 634: ScreenToClient (hwndMain, (LPPOINT)&rect.right); ! 635: SizeObj (hwnd, rect, TRUE); ! 636: // Fall through. ! 637: } ! 638: case WM_PAINT: ! 639: PaintObj (hwnd); ! 640: break; ! 641: ! 642: case WM_LBUTTONDOWN: ! 643: if (fWaitingForDocRelease) ! 644: { ! 645: ErrorBox ("Waiting for a document to be revoked.\n\rPlease wait."); ! 646: return NULL; ! 647: } ! 648: BringWindowToTop (hwnd); ! 649: ! 650: GetWindowRect (hwnd, (LPRECT) &drag.rect); ! 651: ScreenToClient (hwndMain, (LPPOINT)&drag.rect.left); ! 652: ScreenToClient (hwndMain, (LPPOINT)&drag.rect.right); ! 653: ! 654: drag.pt.x = LOWORD(lParam); ! 655: drag.pt.y = HIWORD(lParam); ! 656: ! 657: // Convert drag.pt to the main window's client coordinates. ! 658: ClientToScreen (hwnd, (LPPOINT)&drag.pt); ! 659: ScreenToClient (hwndMain, (LPPOINT)&drag.pt); ! 660: ! 661: // Remember the coordinates of the main window so we do not drag ! 662: // an object outside the main window. ! 663: GetClientRect (hwndMain, (LPRECT) &rectMain); ! 664: ! 665: SetCapture (hwnd); ! 666: fCapture = TRUE; ! 667: break; ! 668: ! 669: case WM_MOUSEMOVE: ! 670: { ! 671: HDC hdc; ! 672: POINT pt; ! 673: ! 674: if (!fCapture) ! 675: break; ! 676: ! 677: fDocChanged = TRUE; ! 678: pt.x = LOWORD(lParam); ! 679: pt.y = HIWORD(lParam); ! 680: ! 681: // Convert pt to the main window's client coordinates. ! 682: ClientToScreen (hwnd, (LPPOINT)&pt); ! 683: ScreenToClient (hwndMain, (LPPOINT)&pt); ! 684: ! 685: if (!PtInRect (&rectMain, pt)) ! 686: break; ! 687: ! 688: hdc = GetDC(hwndMain); ! 689: ! 690: // Erase old drag rectangle ! 691: InvertRect (hdc, (LPRECT)&drag.rect); ! 692: ! 693: // Update drag.rect ! 694: OffsetRect (&drag.rect, pt.x - drag.pt.x, pt.y - drag.pt.y); ! 695: ! 696: // Update drag.pt ! 697: drag.pt.x = pt.x; ! 698: drag.pt.y = pt.y; ! 699: ! 700: // Show new drag rectangle ! 701: InvertRect (hdc, (LPRECT)&drag.rect); ! 702: ReleaseDC (hwndMain, hdc); ! 703: break; ! 704: } ! 705: ! 706: case WM_LBUTTONUP: ! 707: { ! 708: LPOBJ lpobj; ! 709: if (!fCapture) ! 710: return TRUE; ! 711: ! 712: fCapture = FALSE; ! 713: ReleaseCapture (); ! 714: ! 715: MoveWindow (hwnd, drag.rect.left, drag.rect.top, ! 716: drag.rect.right - drag.rect.left, ! 717: drag.rect.bottom - drag.rect.top, TRUE); ! 718: InvalidateRect (hwnd, (LPRECT)NULL, TRUE); ! 719: lpobj = HwndToLpobj (hwnd); ! 720: lpobj->native.nX = drag.rect.left; ! 721: lpobj->native.nY = drag.rect.top; ! 722: break; ! 723: } ! 724: case WM_DESTROY: ! 725: DestroyObj (hwnd); ! 726: return DefWindowProc(hwnd, message, wParam, lParam); ! 727: ! 728: default: ! 729: return DefWindowProc(hwnd, message, wParam, lParam); ! 730: } ! 731: return NULL; ! 732: } ! 733: ! 734: ! 735: ! 736: /* DeviceToHiMetric ! 737: * ---------------- ! 738: * ! 739: * Converts a point from device units to HiMetric units. ! 740: * This function is designed to be generic enough to be reused. ! 741: * ! 742: * HWND hwnd - The window whose display context is to be used ! 743: * LPPOINT lppt - The point to be converted. ! 744: * ! 745: * CUSTOMIZATION: None ! 746: * ! 747: */ ! 748: VOID DeviceToHiMetric (HWND hwnd, LPPOINT lppt) ! 749: { ! 750: HDC hdc = GetDC(hwnd); ! 751: ! 752: SetMapMode(hdc, MM_HIMETRIC); ! 753: DPtoLP (hdc, lppt, 1); ! 754: ! 755: lppt->y *= -1; ! 756: ! 757: ReleaseDC(hwnd,hdc); ! 758: ! 759: } ! 760: ! 761: ! 762: /* UpdateFileMenu ! 763: * -------------- ! 764: * ! 765: * Updates the "Update <Client doc>" and "Exit & Return to <Client doc>" ! 766: * with the currently set client document name ! 767: * ! 768: * CUSTOMIZATION: Re-implement ! 769: * ! 770: */ ! 771: VOID UpdateFileMenu (INT iSaveUpdateId) ! 772: { ! 773: CHAR str[cchFilenameMax]; ! 774: HMENU hMenu = GetMenu(hwndMain); ! 775: ! 776: /* Change File menu so it contains "Update" instead of "Save". */ ! 777: ! 778: lstrcpy (str, "&Update "); ! 779: lstrcat (str, szClientDoc); ! 780: ModifyMenu(hMenu, iSaveUpdateId, MF_BYCOMMAND|MF_STRING, IDM_UPDATE, str); ! 781: ! 782: /* Change File menu so it contains "Exit & Return to <client doc>" */ ! 783: /* instead of just "Exit" */ ! 784: ! 785: lstrcpy (str, "E&xit && Return to "); ! 786: lstrcat (str, szClientDoc); ! 787: ModifyMenu(hMenu, IDM_EXIT, MF_BYCOMMAND|MF_STRING, IDM_EXIT, str); ! 788: } ! 789: ! 790: ! 791: ! 792: /* EmbeddingModeOn ! 793: * --------------- ! 794: * ! 795: * Do whatever is necessary for the application to start "embedding mode." ! 796: * ! 797: * CUSTOMIZATION: Re-implement ! 798: * ! 799: */ ! 800: VOID EmbeddingModeOn(VOID) ! 801: { ! 802: HMENU hMenu = GetMenu(hwndMain); ! 803: ! 804: UpdateFileMenu (IDM_SAVE); ! 805: ! 806: /* Change File menu so it contains "Save Copy As..." instead of */ ! 807: /* "Save As..." */ ! 808: ModifyMenu(hMenu, IDM_SAVEAS, MF_BYCOMMAND|MF_STRING, IDM_SAVEAS, ! 809: "Save Copy As.."); ! 810: ! 811: /* In embedded mode, the user can edit only the embedded object, not ! 812: create new ones. */ ! 813: EnableMenuItem(hMenu, menuposObject, MF_BYPOSITION | MF_GRAYED); ! 814: EnableMenuItem(hMenu, IDM_CUT, MF_BYCOMMAND | MF_GRAYED); ! 815: EnableMenuItem(hMenu, IDM_DELETE, MF_BYCOMMAND | MF_GRAYED); ! 816: DrawMenuBar (hwndMain); ! 817: } ! 818: ! 819: ! 820: ! 821: ! 822: /* EmbeddingModeOff ! 823: * ---------------- ! 824: * ! 825: * Do whatever is necessary for the application to end "embedding mode." ! 826: * ! 827: * CUSTOMIZATION: Re-implement ! 828: * ! 829: */ ! 830: VOID EmbeddingModeOff (VOID) ! 831: { ! 832: HMENU hMenu = GetMenu(hwndMain); ! 833: ! 834: /* Change File menu so it contains "Save" instead of "Update". */ ! 835: ModifyMenu(hMenu, IDM_UPDATE, MF_BYCOMMAND | MF_STRING, IDM_SAVE, "&Save"); ! 836: /* Change File menu so it contains "Exit & Return to <client doc>" */ ! 837: /* instead of just "Exit" */ ! 838: ModifyMenu(hMenu, IDM_EXIT, MF_BYCOMMAND | MF_STRING, IDM_EXIT, "E&xit"); ! 839: ! 840: /* Change File menu so it contains "Save As..." instead of */ ! 841: /* "Save Copy As..." */ ! 842: ModifyMenu(hMenu, IDM_SAVEAS, MF_BYCOMMAND|MF_STRING, IDM_SAVEAS, ! 843: "Save As.."); ! 844: ! 845: /* In non-embedded mode, the user can create new objects. */ ! 846: EnableMenuItem(hMenu, menuposObject, MF_BYPOSITION | MF_ENABLED); ! 847: ! 848: lstrcpy (szClientDoc, "Client Document"); ! 849: DrawMenuBar (hwndMain); ! 850: } ! 851: ! 852: ! 853: ! 854: /* ErrorBox ! 855: * -------- ! 856: * ! 857: * char *szMessage - String to display inside message box. ! 858: * ! 859: * CUSTOMIZATION: Server Demo specific ! 860: * ! 861: */ ! 862: VOID ErrorBox (CHAR *szMessage) ! 863: { ! 864: MessageBox (hwndMain, szMessage, szAppName, MB_OK); ! 865: } ! 866: ! 867: ! 868: ! 869: /* GetWord ! 870: * ------- ! 871: * ! 872: * LPSTR *plpszSrc - Pointer to a pointer to a source string ! 873: * LPSTR lpszDst - Pointer to destination buffer ! 874: * ! 875: * Will copy one space-terminated or null-terminated word from the source ! 876: * string to the destination buffer. ! 877: * When done, *plpszSrc will point to the character after the word. ! 878: * ! 879: * CUSTOMIZATION: Server Demo specific ! 880: * ! 881: */ ! 882: static VOID GetWord (LPSTR *plpszSrc, LPSTR lpszDst) ! 883: { ! 884: INT i = 0; ! 885: while (**plpszSrc && **plpszSrc != ' ') ! 886: { ! 887: lpszDst[i++] = *(*plpszSrc)++; ! 888: } ! 889: lpszDst[i] = '\0'; ! 890: } ! 891: ! 892: ! 893: ! 894: /* HiMetricToDevice ! 895: * ---------------- ! 896: * ! 897: * Converts a point from HiMetric units to device units. ! 898: * This function is designed to be generic enough to be reused. ! 899: * ! 900: * HWND hwnd - The window whose display context is to be used ! 901: * LPPOINT lppt - The point to be converted. ! 902: * ! 903: * CUSTOMIZATION: None ! 904: * ! 905: */ ! 906: VOID HiMetricToDevice (HWND hwnd, LPPOINT lppt) ! 907: { ! 908: HDC hdc = GetDC(hwnd); ! 909: ! 910: SetMapMode(hdc, MM_HIMETRIC); ! 911: ! 912: LPtoDP (hdc, lppt, 1); ! 913: ! 914: ReleaseDC(hwnd,hdc); ! 915: } ! 916: ! 917: ! 918: ! 919: /* HwndToLpobj ! 920: * ----------- ! 921: * ! 922: * Given an object's window, return a pointer to the object. ! 923: * The GetWindowLong call extracts an LPOBJ from the extra data stored with ! 924: * the window. ! 925: * ! 926: * HWND hwndObj - Handle to the object's window ! 927: * ! 928: * RETURNS: A pointer to the object ! 929: * ! 930: * CUSTOMIZATION: Server Demo specific ! 931: * ! 932: */ ! 933: LPOBJ HwndToLpobj (HWND hwndObj) ! 934: { ! 935: return (LPOBJ) GetWindowLong (hwndObj, ibLpobj); ! 936: } ! 937: ! 938: ! 939: ! 940: /* CreateUntitledDoc ! 941: * ----------------- ! 942: * ! 943: * Create a fresh document with one object. ! 944: * ! 945: * RETURNS: TRUE if successful ! 946: * FALSE otherwise ! 947: * ! 948: * CUSTOMIZATION: Re-implement ! 949: * ! 950: */ ! 951: static BOOL CreateUntitledDoc (INT nCmdShow) ! 952: { ! 953: if (!CreateNewDoc (NULL, "(Untitled)", doctypeNew)) ! 954: return FALSE; ! 955: CreateNewObj (FALSE); ! 956: ShowWindow(hwndMain, nCmdShow); ! 957: UpdateWindow(hwndMain); ! 958: return TRUE; ! 959: } ! 960: ! 961: ! 962: /* ProcessCmdLine ! 963: * -------------- ! 964: * ! 965: * Parses the Windows command line which was passed to WinMain. ! 966: * ! 967: * Case One: SrvrDemo.exe ! 968: * fEmbedding = FALSE ! 969: * Create an untitled document. ! 970: * ! 971: * Case two: SrvrDemo.exe filename ! 972: * fEmbedding = FALSE ! 973: * Create a new document from the file. ! 974: * ! 975: * Case three: SrvrDemo.exe -Embedding ! 976: * fEmbedding = TRUE ! 977: * Do not create or register a document. ! 978: * Do not show window until client requests it. ! 979: * ! 980: * Case four: SrvrDemo.exe -Embedding filename ! 981: * fEmbedding = TRUE ! 982: * Load file. ! 983: * Call OleRegisterServerDoc. ! 984: * Do not show window until client requests it. ! 985: * ! 986: * ! 987: * LPSTR lpszLine - The Windows command line ! 988: * int nCmdShow - Parameter to WinMain ! 989: * HWND hwndMain - The application's main window ! 990: * ! 991: * RETURNS: TRUE if the command line was processed correctly. ! 992: * FALSE if a filename was specified which did not ! 993: * contain a proper document. ! 994: * ! 995: * CUSTOMIZATION: None. ! 996: * ! 997: */ ! 998: ! 999: static BOOL ProcessCmdLine (LPSTR lpszLine, HWND hwndMain) ! 1000: { ! 1001: CHAR szBuf[cchFilenameMax]; ! 1002: BOOL fEmbedding = FALSE; // Is "-Embedding" on the command line? ! 1003: INT i=0; ! 1004: OFSTRUCT of; ! 1005: ! 1006: if (!*lpszLine) // No filename or options, so start a fresh document. ! 1007: { ! 1008: return CreateUntitledDoc(SW_SHOWNORMAL); ! 1009: } ! 1010: ! 1011: SkipBlanks (&lpszLine); ! 1012: ! 1013: // Check for "-Embedding" or "/Embedding" and set fEmbedding. ! 1014: if(*lpszLine == '-' || *lpszLine == '/') ! 1015: { ! 1016: lpszLine++; ! 1017: GetWord (&lpszLine, szBuf); ! 1018: fEmbedding = !lstrcmp(szBuf, szEmbeddingFlag); ! 1019: } ! 1020: ! 1021: SkipBlanks (&lpszLine); ! 1022: ! 1023: if (*lpszLine) // if there is a filename ! 1024: { ! 1025: // Put filename into szBuf. ! 1026: GetWord (&lpszLine, szBuf); ! 1027: ! 1028: if (-1 == OpenFile(szBuf, &of, OF_READ | OF_EXIST)) ! 1029: { ! 1030: // File not found ! 1031: if (fEmbedding) ! 1032: return FALSE; ! 1033: else ! 1034: { ! 1035: CHAR sz[100]; ! 1036: wsprintf (sz, "File %s not found.", (LPSTR) szBuf); ! 1037: ErrorBox (sz); ! 1038: return CreateUntitledDoc(SW_SHOWNORMAL); ! 1039: } ! 1040: } ! 1041: ! 1042: if (!CreateDocFromFile (szBuf, NULL, doctypeFromFile)) ! 1043: { ! 1044: // File not in proper format. ! 1045: if (fEmbedding) ! 1046: return FALSE; ! 1047: else ! 1048: { ! 1049: CHAR sz[100]; ! 1050: wsprintf (sz, "File %s not in proper format.", (LPSTR) szBuf); ! 1051: ErrorBox (sz); ! 1052: return CreateUntitledDoc(SW_SHOWNORMAL); ! 1053: } ! 1054: } ! 1055: } ! 1056: ! 1057: if (fEmbedding) ! 1058: { ! 1059: /* Do not show window until told to do so by client. */ ! 1060: ShowWindow(hwndMain, SW_HIDE); ! 1061: } ! 1062: else ! 1063: { ! 1064: ShowWindow(hwndMain, SW_SHOWNORMAL); ! 1065: UpdateWindow(hwndMain); ! 1066: } ! 1067: return TRUE; ! 1068: } ! 1069: ! 1070: ! 1071: ! 1072: /* SaveDimensions ! 1073: * -------------- ! 1074: * ! 1075: * Save the dimensions of the main window in a private profile file. ! 1076: * ! 1077: * CUSTOMIZATION: This function may be removed. If you wish to support ! 1078: * intelligent window placement, then the only necessary ! 1079: * change is to change the string "SrvrDemo.Ini" to a filename ! 1080: * appropriate for your application. ! 1081: */ ! 1082: static VOID SaveDimensions (VOID) ! 1083: { ! 1084: if ((dimsCurrent.nX != dimsSaved.nX) || ! 1085: (dimsCurrent.nY != dimsSaved.nY) || ! 1086: (dimsCurrent.nWidth != dimsSaved.nWidth) || ! 1087: (dimsCurrent.nHeight != dimsSaved.nHeight) ) ! 1088: { ! 1089: // Save current window dimensions to private profile. ! 1090: CHAR szBuf[7]; ! 1091: wsprintf (szBuf, "%d", dimsCurrent.nX); ! 1092: WritePrivateProfileString ! 1093: (szAppName, "x", szBuf, "SrvrDemo.Ini"); ! 1094: wsprintf (szBuf, "%d", dimsCurrent.nY); ! 1095: WritePrivateProfileString ! 1096: (szAppName, "y", szBuf, "SrvrDemo.Ini"); ! 1097: wsprintf (szBuf, "%d", dimsCurrent.nWidth); ! 1098: WritePrivateProfileString ! 1099: (szAppName, "w", szBuf, "SrvrDemo.Ini"); ! 1100: wsprintf (szBuf, "%d", dimsCurrent.nHeight); ! 1101: WritePrivateProfileString ! 1102: (szAppName, "h", szBuf, "SrvrDemo.Ini"); ! 1103: } ! 1104: } ! 1105: ! 1106: ! 1107: ! 1108: /* SelectedObject ! 1109: * -------------- ! 1110: * ! 1111: * Return a pointer to the currently selected object. ! 1112: * ! 1113: * CUSTOMIZATION: What a "selected object" is will vary from application ! 1114: * to application. You may find it useful to have a function ! 1115: * like this. In your application it may be necessary to ! 1116: * actually create an OBJ structure based on what data the ! 1117: * user has selected from the document (by highlighting some ! 1118: * text for example). ! 1119: * ! 1120: */ ! 1121: LPOBJ SelectedObject (VOID) ! 1122: { ! 1123: return HwndToLpobj (SelectedObjectWindow()); ! 1124: } ! 1125: ! 1126: ! 1127: ! 1128: ! 1129: /* SelectedObjectWindow ! 1130: * -------------------- ! 1131: * ! 1132: * Return a handle to the window for the currently selected object. ! 1133: * The GetWindow calls returns a handle to the main window's first child, ! 1134: * which is the selected object's window. ! 1135: * ! 1136: * CUSTOMIZATION: Server Demo specific ! 1137: * ! 1138: */ ! 1139: HWND SelectedObjectWindow (VOID) ! 1140: { ! 1141: return GetWindow (hwndMain, GW_CHILD); ! 1142: } ! 1143: ! 1144: ! 1145: ! 1146: /* SetHiMetricFields ! 1147: * ----------------- ! 1148: * ! 1149: * Adjust the nHiMetricWidth and nHiMetricHeight fields of a NATIVE structure ! 1150: * so that they are equivalent to the nWidth and nHeight fields. ! 1151: * The negative sign in the last line is necessary because the positive ! 1152: * y direction is toward the top of the screen in MM_HIMETRIC mode. ! 1153: * ! 1154: * LPOBJ lpobj - Pointer to the object whose native data will be adjusted ! 1155: * ! 1156: * CUSTOMIZATION: Server Demo specific, although you may need a function like ! 1157: * this if you keep track of the size of an object, and an ! 1158: * object handler needs to know the object's size in ! 1159: * HiMetric units. ! 1160: * ! 1161: * ! 1162: */ ! 1163: VOID SetHiMetricFields (LPOBJ lpobj) ! 1164: { ! 1165: POINT pt; ! 1166: ! 1167: pt.x = lpobj->native.nWidth; ! 1168: pt.y = lpobj->native.nHeight; ! 1169: DeviceToHiMetric (hwndMain, &pt); ! 1170: lpobj->native.nHiMetricWidth = pt.x; ! 1171: lpobj->native.nHiMetricHeight = pt.y; ! 1172: } ! 1173: ! 1174: ! 1175: ! 1176: /* SkipBlanks ! 1177: * ---------- ! 1178: * ! 1179: * LPSTR *plpsz - Pointer to a pointer to a character ! 1180: * ! 1181: * Increment *plpsz past any blanks in the character string. ! 1182: * This function is used in ProcessCmdLine. ! 1183: * ! 1184: */ ! 1185: static VOID SkipBlanks (LPSTR *plpsz) ! 1186: { ! 1187: while (**plpsz && **plpsz == ' ') ! 1188: (*plpsz)++; ! 1189: } ! 1190: ! 1191: ! 1192: ! 1193: /* UpdateObjMenus ! 1194: * --------------- ! 1195: * ! 1196: * Grey or Ungrey menu items depending on the existence of at least one ! 1197: * object in the document. ! 1198: * ! 1199: * CUSTOMIZATION: Server Demo specific ! 1200: * ! 1201: */ ! 1202: static VOID UpdateObjMenus (VOID) ! 1203: { ! 1204: static BOOL fObjMenusEnabled = TRUE; ! 1205: BOOL fOneObjExists; // Does at least one object exist? ! 1206: WORD wEnable; ! 1207: HMENU hMenu; ! 1208: ! 1209: fOneObjExists = (SelectedObjectWindow() != NULL); ! 1210: if (fOneObjExists == fObjMenusEnabled) ! 1211: { ! 1212: // Nothing has changed. ! 1213: return; ! 1214: } ! 1215: ! 1216: wEnable = (WORD)(fOneObjExists ? MF_ENABLED : MF_GRAYED); ! 1217: ! 1218: hMenu = GetMenu(hwndMain); ! 1219: EnableMenuItem(hMenu, menuposColor, MF_BYPOSITION | wEnable); ! 1220: ! 1221: hMenu = GetSubMenu(GetMenu(hwndMain), menuposFile); ! 1222: EnableMenuItem(hMenu, IDM_SAVE, MF_BYCOMMAND | wEnable); ! 1223: EnableMenuItem(hMenu, IDM_SAVEAS, MF_BYCOMMAND | wEnable); ! 1224: ! 1225: hMenu = GetSubMenu(GetMenu(hwndMain), menuposEdit); ! 1226: EnableMenuItem(hMenu, IDM_CUT, MF_BYCOMMAND | wEnable); ! 1227: EnableMenuItem(hMenu, IDM_COPY, MF_BYCOMMAND | wEnable); ! 1228: EnableMenuItem(hMenu, IDM_DELETE, MF_BYCOMMAND | wEnable); ! 1229: ! 1230: hMenu = GetSubMenu(GetMenu(hwndMain), menuposObject); ! 1231: EnableMenuItem(hMenu, IDM_NEXTOBJ, MF_BYCOMMAND | wEnable); ! 1232: ! 1233: DrawMenuBar (hwndMain); ! 1234: fObjMenusEnabled = fOneObjExists; ! 1235: } ! 1236: ! 1237: ! 1238: ! 1239: /* Wait ! 1240: * ---- ! 1241: * ! 1242: * Dispatch messages until the given flag is set to FALSE. ! 1243: * One use of this function is to wait until a Release method is called ! 1244: * after a function has returned OLE_WAIT_FOR_RELEASE. ! 1245: * ! 1246: * BOOL *pf - Pointer to the flag being waited on. ! 1247: * ! 1248: * CUSTOMIZATION: The use of OleUnblockServer is for illustration only. ! 1249: * Since Server Demo does not call OleBlockServer, there ! 1250: * will never be any messages in the OLE queue. ! 1251: * ! 1252: */ ! 1253: VOID Wait (BOOL *pf) ! 1254: { ! 1255: MSG msg; ! 1256: BOOL fMoreMsgs = FALSE; ! 1257: ! 1258: *pf = TRUE; ! 1259: while (*pf==TRUE) ! 1260: { ! 1261: OleUnblockServer (srvrMain.lhsrvr, &fMoreMsgs); ! 1262: if (!fMoreMsgs) ! 1263: // if there are no more messages in the OLE queue, go to system queue ! 1264: { ! 1265: if (GetMessage (&msg, NULL, NULL, NULL)) ! 1266: { ! 1267: TranslateMessage (&msg); ! 1268: DispatchMessage (&msg); ! 1269: } ! 1270: } ! 1271: } ! 1272: } ! 1273: ! 1274: static BOOL FailedUpdate(HWND hwnd) ! 1275: { ! 1276: ! 1277: return(DialogBox(hInst, "FailedUpdate", hwnd, (DLGPROC)fnFailedUpdate)); ! 1278: ! 1279: } ! 1280: ! 1281: BOOL APIENTRY fnFailedUpdate (HWND hDlg, UINT message, DWORD wParam, LONG lParam) ! 1282: { ! 1283: ! 1284: switch (message) ! 1285: { ! 1286: case WM_COMMAND: ! 1287: { ! 1288: WORD wID = LOWORD(wParam); ! 1289: ! 1290: switch (wID) ! 1291: { ! 1292: case IDCANCEL: ! 1293: case IDD_CONTINUEEDIT: ! 1294: EndDialog(hDlg, TRUE); ! 1295: break; ! 1296: ! 1297: case IDD_UPDATEEXIT: ! 1298: EndDialog(hDlg, FALSE); ! 1299: break; ! 1300: ! 1301: default: ! 1302: break; ! 1303: } ! 1304: break; ! 1305: } ! 1306: ! 1307: case WM_INITDIALOG: ! 1308: { ! 1309: CHAR szMsg[200]; ! 1310: ! 1311: szMsg[0] = NULL; ! 1312: ! 1313: wsprintf( ! 1314: szMsg, ! 1315: "This %s document can only be updated when you exit %s.", ! 1316: (LPSTR) szClient, ! 1317: (LPSTR) szAppName ! 1318: ); ! 1319: ! 1320: SetDlgItemText(hDlg, IDD_TEXT, szMsg); ! 1321: return TRUE; ! 1322: } ! 1323: ! 1324: default: ! 1325: break; ! 1326: } ! 1327: ! 1328: return FALSE; ! 1329: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.