![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to outlapp.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / ole20 / samples / outline|
Return to outlapp.c CVS log | Up to [WindowsNT SDKs] / mstools / ole20 / samples / outline |
1.1 ! root 1: /************************************************************************* ! 2: ** ! 3: ** OLE 2 Sample Code ! 4: ** ! 5: ** outlapp.c ! 6: ** ! 7: ** This file contains OutlineApp functions. ! 8: ** ! 9: ** (c) Copyright Microsoft Corp. 1992 - 1993 All Rights Reserved ! 10: ** ! 11: *************************************************************************/ ! 12: ! 13: #include "outline.h" ! 14: ! 15: #if defined( USE_STATUSBAR ) ! 16: #include "status.h" ! 17: #endif ! 18: ! 19: #if !defined( WIN32 ) ! 20: #include <print.h> ! 21: #endif ! 22: ! 23: OLEDBGDATA ! 24: ! 25: extern LPOUTLINEAPP g_lpApp; ! 26: extern RECT g_rectNull; ! 27: ! 28: // REVIEW: should use string resource for messages ! 29: char ErrMsgClass[] = "Can't register window classes!"; ! 30: char ErrMsgFrame[] = "Can't create Frame Window!"; ! 31: char ErrMsgPrinting[] = "Can't access printer!"; ! 32: ! 33: ! 34: /* OutlineApp_InitApplication ! 35: ** -------------------------- ! 36: ** Sets up the class data structures and does a one-time ! 37: ** initialization of the app by registering the window classes. ! 38: ** Returns TRUE if initialization is successful ! 39: ** FALSE otherwise ! 40: */ ! 41: ! 42: BOOL OutlineApp_InitApplication(LPOUTLINEAPP lpOutlineApp, HINSTANCE hInst) ! 43: { ! 44: WNDCLASS wndclass; ! 45: ! 46: // REVIEW: should load msg strings from string resource ! 47: ! 48: /* Register the app frame class */ ! 49: wndclass.style = CS_HREDRAW | CS_VREDRAW | CS_BYTEALIGNWINDOW; ! 50: wndclass.lpfnWndProc = AppWndProc; ! 51: /* Extra storage for Class and Window objects */ ! 52: wndclass.cbClsExtra = 0; ! 53: wndclass.cbWndExtra = sizeof(LPOUTLINEAPP); /* to store lpApp */ ! 54: wndclass.hInstance = hInst; ! 55: wndclass.hIcon = LoadIcon(hInst, APPICON); ! 56: wndclass.hCursor = LoadCursor(NULL, IDC_ARROW); ! 57: /* Create brush for erasing background */ ! 58: wndclass.hbrBackground = (HBRUSH)(COLOR_WINDOW+1); ! 59: wndclass.lpszMenuName = APPMENU; /* Menu Name is App Name */ ! 60: wndclass.lpszClassName = APPWNDCLASS; /* Class Name is App Name */ ! 61: ! 62: if(! RegisterClass(&wndclass)) { ! 63: OutlineApp_ErrorMessage(lpOutlineApp, ErrMsgFrame); ! 64: return FALSE; ! 65: } ! 66: ! 67: /* Register the document window class */ ! 68: wndclass.style = CS_BYTEALIGNWINDOW; ! 69: wndclass.lpfnWndProc = DocWndProc; ! 70: wndclass.hIcon = NULL; ! 71: wndclass.hbrBackground = (HBRUSH)(COLOR_WINDOW+1); ! 72: wndclass.lpszMenuName = NULL; ! 73: wndclass.lpszClassName = DOCWNDCLASS; ! 74: wndclass.cbWndExtra = sizeof(LPOUTLINEDOC); /* to store lpDoc */ ! 75: if(! RegisterClass(&wndclass)) { ! 76: OutlineApp_ErrorMessage(lpOutlineApp, ErrMsgClass); ! 77: return FALSE; ! 78: } ! 79: ! 80: #if defined( USE_STATUSBAR ) ! 81: if (! RegisterStatusClass(hInst)) ! 82: return FALSE; ! 83: #endif ! 84: ! 85: #if defined( USE_FRAMETOOLS ) ! 86: if (! FrameToolsRegisterClass(hInst)) { ! 87: return FALSE; ! 88: } ! 89: #endif ! 90: ! 91: #if defined( INPLACE_SVR ) ! 92: // We should only register the hatch window class ! 93: // in the UI Library once per application. ! 94: RegisterHatchWindowClass(hInst); ! 95: ! 96: #endif ! 97: ! 98: return TRUE; ! 99: } ! 100: ! 101: ! 102: /* OutlineApp_InitInstance ! 103: * ----------------------- ! 104: * ! 105: * Performs a per-instance initialization of app. ! 106: * This method creates the frame window. ! 107: * ! 108: * RETURNS : TRUE - If initialization was successful. ! 109: * FALSE - otherwise. ! 110: */ ! 111: ! 112: BOOL OutlineApp_InitInstance(LPOUTLINEAPP lpOutlineApp, HINSTANCE hInst, int nCmdShow) ! 113: { ! 114: lpOutlineApp->m_hInst = hInst; ! 115: ! 116: /* create application's Frame window */ ! 117: lpOutlineApp->m_hWndApp = CreateWindow( ! 118: APPWNDCLASS, /* Window class name */ ! 119: APPNAME, /* initial Window title */ ! 120: WS_OVERLAPPEDWINDOW| ! 121: WS_CLIPCHILDREN, ! 122: CW_USEDEFAULT, 0, /* Use default X, Y */ ! 123: CW_USEDEFAULT, 0, /* Use default X, Y */ ! 124: HWND_DESKTOP, /* Parent window's handle */ ! 125: NULL, /* Default to Class Menu */ ! 126: hInst, /* Instance of window */ ! 127: NULL /* Create struct for WM_CREATE */ ! 128: ); ! 129: ! 130: if(! lpOutlineApp->m_hWndApp) { ! 131: // REVIEW: should load string from string resource ! 132: OutlineApp_ErrorMessage(lpOutlineApp, ErrMsgFrame); ! 133: return FALSE; ! 134: } ! 135: ! 136: SetWindowLong(lpOutlineApp->m_hWndApp, 0, (LONG) lpOutlineApp); ! 137: ! 138: /* defer creating the user's SDI document until we parse the cmd line. */ ! 139: lpOutlineApp->m_lpDoc = NULL; ! 140: ! 141: /* Initialize clipboard. ! 142: */ ! 143: lpOutlineApp->m_lpClipboardDoc = NULL; ! 144: if(!(lpOutlineApp->m_cfOutline = RegisterClipboardFormat(OUTLINEDOCFORMAT))) { ! 145: // REVIEW: should load string from string resource ! 146: OutlineApp_ErrorMessage(lpOutlineApp, "Can't register clipboard format!"); ! 147: return FALSE; ! 148: } ! 149: ! 150: /* init the standard font to be used for drawing/printing text ! 151: * request a Roman style True Type font of the desired size ! 152: */ ! 153: lpOutlineApp->m_hStdFont = CreateFont( ! 154: -DEFFONTSIZE, ! 155: 0,0,0,0,0,0,0,0, ! 156: OUT_TT_PRECIS, // use TrueType ! 157: CLIP_DEFAULT_PRECIS, ! 158: DEFAULT_QUALITY, ! 159: VARIABLE_PITCH | FF_ROMAN, ! 160: DEFFONTFACE ! 161: ); ! 162: ! 163: // Load special cursor for selection of Lines in ListBox. ! 164: lpOutlineApp->m_hcursorSelCur = LoadCursor ( hInst, "SelCur" ); ! 165: ! 166: /* init the Print Dialog structure */ ! 167: _fmemset((LPVOID)&lpOutlineApp->m_PrintDlg,0,sizeof(PRINTDLG)); ! 168: lpOutlineApp->m_PrintDlg.lStructSize = sizeof(PRINTDLG); ! 169: lpOutlineApp->m_PrintDlg.hDevMode = NULL; ! 170: lpOutlineApp->m_PrintDlg.hDevNames = NULL; ! 171: lpOutlineApp->m_PrintDlg.Flags = PD_RETURNDC | PD_NOSELECTION | PD_NOPAGENUMS | ! 172: PD_HIDEPRINTTOFILE; ! 173: lpOutlineApp->m_PrintDlg.nCopies = 1; ! 174: lpOutlineApp->m_PrintDlg.hwndOwner = lpOutlineApp->m_hWndApp; ! 175: ! 176: #if defined( USE_STATUSBAR ) ! 177: lpOutlineApp->m_hWndStatusBar = CreateStatusWindow(lpOutlineApp->m_hWndApp, hInst); ! 178: if (! lpOutlineApp->m_hWndStatusBar) ! 179: return FALSE; ! 180: ! 181: lpOutlineApp->m_hMenuApp = GetMenu(lpOutlineApp->m_hWndApp); ! 182: ! 183: /* setup status messages for the application menus */ ! 184: { ! 185: HMENU hMenuFile = GetSubMenu(lpOutlineApp->m_hMenuApp, 0); ! 186: HMENU hMenuEdit = GetSubMenu(lpOutlineApp->m_hMenuApp, 1); ! 187: HMENU hMenuLine = GetSubMenu(lpOutlineApp->m_hMenuApp, 2); ! 188: HMENU hMenuName = GetSubMenu(lpOutlineApp->m_hMenuApp, 3); ! 189: HMENU hMenuHelp = GetSubMenu(lpOutlineApp->m_hMenuApp, 4); ! 190: HMENU hMenuSys = GetSystemMenu(lpOutlineApp->m_hWndApp, FALSE); ! 191: ! 192: AssignPopupMessage(hMenuFile, "Create, open, save, print outlines or quit application"); ! 193: AssignPopupMessage(hMenuEdit, "Cut, copy, paste or clear selection"); ! 194: AssignPopupMessage(hMenuLine, "Create, edit, and indent lines"); ! 195: AssignPopupMessage(hMenuName, "Create, edit, delete and goto names"); ! 196: AssignPopupMessage(hMenuHelp, "Get help on using the application"); ! 197: AssignPopupMessage(hMenuSys,"Move, size or close application window"); ! 198: } ! 199: #endif ! 200: ! 201: #if defined ( USE_FRAMETOOLS ) || defined ( INPLACE_CNTR ) ! 202: lpOutlineApp->m_FrameToolWidths = g_rectNull; ! 203: #endif // USE_FRAMETOOLS || INPLACE_CNTR ! 204: ! 205: #if defined( USE_FRAMETOOLS ) ! 206: if (! FrameTools_Init(&lpOutlineApp->m_frametools, ! 207: lpOutlineApp->m_hWndApp, lpOutlineApp->m_hInst)) ! 208: return FALSE; ! 209: #endif ! 210: ! 211: #if defined( OLE_VERSION ) ! 212: ! 213: /* OLE2NOTE: perform initialization required for OLE */ ! 214: if (! OleApp_InitInstance((LPOLEAPP)lpOutlineApp, hInst, nCmdShow)) ! 215: return FALSE; ! 216: #else ! 217: /* OLE2NOTE: Although no OLE call is made in the base outline, ! 218: ** OLE memory allocator is used and thus CoInitialize() neeed to ! 219: ** be called ! 220: */ ! 221: { ! 222: HRESULT hrErr; ! 223: ! 224: hrErr = CoInitialize(NULL); ! 225: if (hrErr != NOERROR) { ! 226: OutlineApp_ErrorMessage(lpOutlineApp, ! 227: "CoInitialize initialization failed!"); ! 228: return FALSE; ! 229: } ! 230: } ! 231: #endif ! 232: ! 233: return TRUE; ! 234: } ! 235: ! 236: ! 237: /* OutlineApp_ParseCmdLine ! 238: * ----------------------- ! 239: * ! 240: * Parse the command line for any execution flags/arguments. ! 241: */ ! 242: BOOL OutlineApp_ParseCmdLine(LPOUTLINEAPP lpOutlineApp, LPSTR lpszCmdLine, int nCmdShow) ! 243: { ! 244: ! 245: #if defined( OLE_VERSION ) ! 246: // Call OLE version of this function instead ! 247: return OleApp_ParseCmdLine((LPOLEAPP)lpOutlineApp,lpszCmdLine,nCmdShow); ! 248: ! 249: #else ! 250: ! 251: BOOL fStatus = TRUE; ! 252: char szFileName[256]; /* buffer for filename in command line */ ! 253: ! 254: szFileName[0] = '\0'; ! 255: ParseCmdLine(lpszCmdLine, NULL, (LPSTR)szFileName); ! 256: ! 257: if(*szFileName) { ! 258: // allocate a new document ! 259: lpOutlineApp->m_lpDoc = OutlineApp_CreateDoc(lpOutlineApp, FALSE); ! 260: if (! lpOutlineApp->m_lpDoc) goto error; ! 261: ! 262: // open the specified file ! 263: if (! OutlineDoc_LoadFromFile(lpOutlineApp->m_lpDoc, szFileName)) ! 264: goto error; ! 265: } else { ! 266: // create a new document ! 267: lpOutlineApp->m_lpDoc = OutlineApp_CreateDoc(lpOutlineApp, FALSE); ! 268: if (! lpOutlineApp->m_lpDoc) goto error; ! 269: ! 270: // set the doc to an (Untitled) doc. ! 271: if (! OutlineDoc_InitNewFile(lpOutlineApp->m_lpDoc)) ! 272: goto error; ! 273: } ! 274: ! 275: // position and size the new doc window ! 276: OutlineApp_ResizeWindows(lpOutlineApp); ! 277: OutlineDoc_ShowWindow(lpOutlineApp->m_lpDoc); ! 278: ! 279: // show main app window ! 280: ShowWindow(lpOutlineApp->m_hWndApp, nCmdShow); ! 281: UpdateWindow(lpOutlineApp->m_hWndApp); ! 282: ! 283: return TRUE; ! 284: ! 285: error: ! 286: // REVIEW: should load string from string resource ! 287: OutlineApp_ErrorMessage(lpOutlineApp, "Could not create new document"); ! 288: ! 289: if (lpOutlineApp->m_lpDoc) { ! 290: OutlineDoc_Destroy(lpOutlineApp->m_lpDoc); ! 291: lpOutlineApp->m_lpDoc = NULL; ! 292: } ! 293: ! 294: return FALSE; ! 295: ! 296: #endif ! 297: } ! 298: ! 299: ! 300: /* OutlineApp_InitMenu ! 301: * ------------------- ! 302: * ! 303: * Enable or Disable menu items depending on the state of ! 304: * the appliation ! 305: */ ! 306: void OutlineApp_InitMenu(LPOUTLINEAPP lpOutlineApp, LPOUTLINEDOC lpOutlineDoc, HMENU hMenu) ! 307: { ! 308: WORD status; ! 309: static UINT uCurrentZoom = (UINT)-1; ! 310: static UINT uCurrentMargin = (UINT)-1; ! 311: static UINT uBBState = (UINT)-1; ! 312: static UINT uFBState = (UINT)-1; ! 313: ! 314: if (!lpOutlineApp || !lpOutlineDoc || !hMenu) ! 315: return; ! 316: ! 317: EnableMenuItem(lpOutlineApp->m_hMenuApp, IDM_E_UNDO, MF_GRAYED); ! 318: ! 319: status = (WORD)(OutlineDoc_GetLineCount(lpOutlineDoc) ? MF_ENABLED : MF_GRAYED); ! 320: ! 321: EnableMenuItem(lpOutlineApp->m_hMenuApp, IDM_E_CUT ,status); ! 322: EnableMenuItem(lpOutlineApp->m_hMenuApp, IDM_E_COPY ,status); ! 323: EnableMenuItem(lpOutlineApp->m_hMenuApp, IDM_E_CLEAR ,status); ! 324: EnableMenuItem(lpOutlineApp->m_hMenuApp, IDM_E_SELECTALL ,status); ! 325: ! 326: EnableMenuItem(lpOutlineApp->m_hMenuApp, IDM_L_EDITLINE ,status); ! 327: EnableMenuItem(lpOutlineApp->m_hMenuApp, IDM_L_INDENTLINE ,status); ! 328: EnableMenuItem(lpOutlineApp->m_hMenuApp, IDM_L_UNINDENTLINE ,status); ! 329: EnableMenuItem(lpOutlineApp->m_hMenuApp, IDM_L_SETLINEHEIGHT ,status); ! 330: ! 331: EnableMenuItem(lpOutlineApp->m_hMenuApp, IDM_N_DEFINENAME ,status); ! 332: ! 333: status = (WORD)(OutlineDoc_GetNameCount(lpOutlineDoc) ? MF_ENABLED : MF_GRAYED); ! 334: ! 335: EnableMenuItem(lpOutlineApp->m_hMenuApp, IDM_N_GOTONAME, status); ! 336: ! 337: if (uCurrentZoom != (UINT)-1) ! 338: CheckMenuItem(lpOutlineApp->m_hMenuApp, uCurrentZoom, MF_UNCHECKED); ! 339: uCurrentZoom = OutlineDoc_GetCurrentZoomMenuCheck(lpOutlineDoc); ! 340: CheckMenuItem(lpOutlineApp->m_hMenuApp, uCurrentZoom, MF_CHECKED); ! 341: ! 342: if (uCurrentMargin != (UINT)-1) ! 343: CheckMenuItem(lpOutlineApp->m_hMenuApp, uCurrentMargin, MF_UNCHECKED); ! 344: uCurrentMargin = OutlineDoc_GetCurrentMarginMenuCheck(lpOutlineDoc); ! 345: CheckMenuItem(lpOutlineApp->m_hMenuApp, uCurrentMargin, MF_CHECKED); ! 346: ! 347: #if defined( USE_FRAMETOOLS ) ! 348: if (uBBState != (UINT)-1) ! 349: CheckMenuItem(lpOutlineApp->m_hMenuApp, uBBState, MF_UNCHECKED); ! 350: if (lpOutlineDoc->m_lpFrameTools) { ! 351: switch (FrameTools_BB_GetState(lpOutlineDoc->m_lpFrameTools)) { ! 352: case BARSTATE_TOP: ! 353: uBBState = IDM_O_BB_TOP; ! 354: break; ! 355: case BARSTATE_BOTTOM: ! 356: uBBState = IDM_O_BB_BOTTOM; ! 357: break; ! 358: case BARSTATE_POPUP: ! 359: uBBState = IDM_O_BB_POPUP; ! 360: break; ! 361: case BARSTATE_HIDE: ! 362: uBBState = IDM_O_BB_HIDE; ! 363: break; ! 364: } ! 365: CheckMenuItem(lpOutlineApp->m_hMenuApp, uBBState, MF_CHECKED); ! 366: } ! 367: ! 368: if (uFBState != (UINT)-1) ! 369: CheckMenuItem(lpOutlineApp->m_hMenuApp, uFBState, MF_UNCHECKED); ! 370: if (lpOutlineDoc->m_lpFrameTools) { ! 371: switch (FrameTools_FB_GetState(lpOutlineDoc->m_lpFrameTools)) { ! 372: case BARSTATE_TOP: ! 373: uFBState = IDM_O_FB_TOP; ! 374: break; ! 375: case BARSTATE_BOTTOM: ! 376: uFBState = IDM_O_FB_BOTTOM; ! 377: break; ! 378: case BARSTATE_POPUP: ! 379: uFBState = IDM_O_FB_POPUP; ! 380: break; ! 381: } ! 382: CheckMenuItem(lpOutlineApp->m_hMenuApp, uFBState, MF_CHECKED); ! 383: } ! 384: #endif // USE_FRAMETOOLS ! 385: ! 386: #if defined( OLE_VERSION ) ! 387: /* OLE2NOTE: perform OLE specific menu initialization. ! 388: ** the OLE versions use the OleGetClipboard mechanism for ! 389: ** clipboard handling. thus, they determine if the Paste and ! 390: ** PasteSpecial commands should be enabled in an OLE specific ! 391: ** manner. ! 392: ** (Container only) build the OLE object verb menu if necessary. ! 393: */ ! 394: OleApp_InitMenu( ! 395: (LPOLEAPP)lpOutlineApp, ! 396: (LPOLEDOC)lpOutlineDoc, ! 397: lpOutlineApp->m_hMenuApp ! 398: ); ! 399: ! 400: /* OLE2NOTE: To avoid the overhead of initializing the Edit menu, ! 401: ** we do it only when it is popped up. Thus we just set a flag ! 402: ** in the OleDoc saying that the Edit menu needs to be updated ! 403: ** but we don't do it immediately ! 404: */ ! 405: OleDoc_SetUpdateEditMenuFlag((LPOLEDOC)lpOutlineDoc, TRUE); ! 406: ! 407: #else ! 408: // Base Outline version uses standard Windows clipboard handling ! 409: if(IsClipboardFormatAvailable(lpOutlineApp->m_cfOutline) || ! 410: IsClipboardFormatAvailable(CF_TEXT)) ! 411: status = MF_ENABLED; ! 412: else ! 413: status = MF_GRAYED; ! 414: EnableMenuItem(lpOutlineApp->m_hMenuApp, IDM_E_PASTE, status); ! 415: ! 416: #endif ! 417: ! 418: #if defined( USE_FRAMETOOLS ) ! 419: if (! OutlineDoc_IsEditFocusInFormulaBar(lpOutlineDoc)) { ! 420: EnableMenuItem(lpOutlineApp->m_hMenuApp, IDM_L_ADDLINE, MF_GRAYED); ! 421: EnableMenuItem(lpOutlineApp->m_hMenuApp, IDM_L_EDITLINE, MF_GRAYED); ! 422: } ! 423: else ! 424: EnableMenuItem(lpOutlineApp->m_hMenuApp, IDM_L_ADDLINE, MF_ENABLED); ! 425: ! 426: #endif // USE_FRAMETOOLS ! 427: ! 428: } ! 429: ! 430: ! 431: /* OutlineApp_GetWindow ! 432: * -------------------- ! 433: * ! 434: * Get the window handle of the application frame. ! 435: */ ! 436: HWND OutlineApp_GetWindow(LPOUTLINEAPP lpOutlineApp) ! 437: { ! 438: if (!lpOutlineApp) ! 439: return NULL; ! 440: ! 441: return lpOutlineApp->m_hWndApp; ! 442: } ! 443: ! 444: ! 445: /* OutlineApp_GetFrameWindow ! 446: ** ------------------------- ! 447: ** Gets the current frame window to use as a parent to any dialogs ! 448: ** this app uses. ! 449: ** ! 450: ** OLE2NOTE: normally this is simply the main hWnd of the app. but, ! 451: ** if the app is currently supporting an in-place server document, ! 452: ** then the frame window of the top in-place container must be used. ! 453: */ ! 454: HWND OutlineApp_GetFrameWindow(LPOUTLINEAPP lpOutlineApp) ! 455: { ! 456: HWND hWndApp = OutlineApp_GetWindow(lpOutlineApp); ! 457: ! 458: #if defined( INPLACE_SVR ) ! 459: LPSERVERDOC lpServerDoc = ! 460: (LPSERVERDOC)OutlineApp_GetActiveDoc(lpOutlineApp); ! 461: if (lpServerDoc && lpServerDoc->m_fUIActive) ! 462: return lpServerDoc->m_lpIPData->frameInfo.hwndFrame; ! 463: #endif ! 464: ! 465: return hWndApp; ! 466: } ! 467: ! 468: ! 469: /* OutlineApp_GetInstance ! 470: * ---------------------- ! 471: * ! 472: * Get the process instance of the application. ! 473: */ ! 474: HINSTANCE OutlineApp_GetInstance(LPOUTLINEAPP lpOutlineApp) ! 475: { ! 476: if (!lpOutlineApp) ! 477: return NULL; ! 478: ! 479: return lpOutlineApp->m_hInst; ! 480: } ! 481: ! 482: ! 483: /* OutlineApp_CreateDoc ! 484: * -------------------- ! 485: * ! 486: * Allocate a new document of the appropriate type. ! 487: * OutlineApp --> creates OutlineDoc type documents ! 488: * ! 489: * Returns lpOutlineDoc for successful, NULL if error. ! 490: */ ! 491: LPOUTLINEDOC OutlineApp_CreateDoc( ! 492: LPOUTLINEAPP lpOutlineApp, ! 493: BOOL fDataTransferDoc ! 494: ) ! 495: { ! 496: LPOUTLINEDOC lpOutlineDoc; ! 497: ! 498: OLEDBG_BEGIN3("OutlineApp_CreateDoc\r\n") ! 499: ! 500: #if defined( OLE_SERVER ) ! 501: lpOutlineDoc = (LPOUTLINEDOC)New((DWORD)sizeof(SERVERDOC)); ! 502: #elif defined( OLE_CNTR ) ! 503: lpOutlineDoc = (LPOUTLINEDOC)New((DWORD)sizeof(CONTAINERDOC)); ! 504: #else ! 505: lpOutlineDoc = (LPOUTLINEDOC)New((DWORD)sizeof(OUTLINEDOC)); ! 506: #endif ! 507: ! 508: if (! OleDbgVerifySz(lpOutlineDoc != NULL, "Error allocating OutlineDoc")) ! 509: return NULL; ! 510: ! 511: // initialize new document ! 512: if (! OutlineDoc_Init(lpOutlineDoc, fDataTransferDoc)) ! 513: goto error; ! 514: ! 515: OLEDBG_END3 ! 516: return lpOutlineDoc; ! 517: ! 518: error: ! 519: if (lpOutlineDoc) ! 520: Delete(lpOutlineDoc); ! 521: ! 522: OLEDBG_END3 ! 523: return NULL; ! 524: } ! 525: ! 526: ! 527: /* OutlineApp_CreateName ! 528: * --------------------- ! 529: * ! 530: * Allocate a new Name of the appropriate type. ! 531: * OutlineApp --> creates standard OutlineName type names. ! 532: * ServerApp --> creates enhanced SeverName type names. ! 533: * ! 534: * Returns lpOutlineName for successful, NULL if error. ! 535: */ ! 536: LPOUTLINENAME OutlineApp_CreateName(LPOUTLINEAPP lpOutlineApp) ! 537: { ! 538: LPOUTLINENAME lpOutlineName; ! 539: ! 540: #if defined( OLE_SERVER ) ! 541: lpOutlineName = (LPOUTLINENAME)New((DWORD)sizeof(SERVERNAME)); ! 542: #else ! 543: lpOutlineName = (LPOUTLINENAME)New((DWORD)sizeof(OUTLINENAME)); ! 544: #endif ! 545: ! 546: if (! OleDbgVerifySz(lpOutlineName != NULL, "Error allocating Name")) ! 547: return NULL; ! 548: ! 549: #if defined( OLE_SERVER ) ! 550: _fmemset((LPVOID)lpOutlineName,0,sizeof(SERVERNAME)); ! 551: #else ! 552: _fmemset((LPVOID)lpOutlineName,0,sizeof(OUTLINENAME)); ! 553: #endif ! 554: ! 555: return lpOutlineName; ! 556: } ! 557: ! 558: ! 559: /* OutlineApp_DocUnlockApp ! 560: ** ----------------------- ! 561: ** Forget all references to a closed document. ! 562: */ ! 563: void OutlineApp_DocUnlockApp(LPOUTLINEAPP lpOutlineApp, LPOUTLINEDOC lpOutlineDoc) ! 564: { ! 565: /* forget pointers to destroyed document */ ! 566: if (lpOutlineApp->m_lpDoc == lpOutlineDoc) ! 567: lpOutlineApp->m_lpDoc = NULL; ! 568: else if (lpOutlineApp->m_lpClipboardDoc == lpOutlineDoc) ! 569: lpOutlineApp->m_lpClipboardDoc = NULL; ! 570: ! 571: #if defined( OLE_VERSION ) ! 572: /* OLE2NOTE: when there are no open documents and the app is not ! 573: ** under the control of the user then revoke our ClassFactory to ! 574: ** enable the app to shut down. ! 575: ** ! 576: ** NOTE: data transfer documents (non-user documents) do NOT ! 577: ** hold the app alive. therefore they do not Lock the app. ! 578: */ ! 579: if (! lpOutlineDoc->m_fDataTransferDoc) ! 580: OleApp_DocUnlockApp((LPOLEAPP)lpOutlineApp, lpOutlineDoc); ! 581: #endif ! 582: } ! 583: ! 584: ! 585: /* OutlineApp_NewCommand ! 586: * --------------------- ! 587: * ! 588: * Start a new untitled document (File.New command). ! 589: */ ! 590: void OutlineApp_NewCommand(LPOUTLINEAPP lpOutlineApp) ! 591: { ! 592: #if defined( OLE_VERSION ) ! 593: // Call OLE version of this function instead ! 594: OleApp_NewCommand((LPOLEAPP)lpOutlineApp); ! 595: ! 596: #else ! 597: ! 598: LPOUTLINEDOC lpOutlineDoc = lpOutlineApp->m_lpDoc; ! 599: ! 600: if (! OutlineDoc_Close(lpOutlineDoc, OLECLOSE_PROMPTSAVE)) ! 601: return; ! 602: ! 603: OleDbgAssertSz(lpOutlineApp->m_lpDoc==NULL,"Closed doc NOT properly destroyed"); ! 604: ! 605: lpOutlineApp->m_lpDoc = OutlineApp_CreateDoc(lpOutlineApp, FALSE); ! 606: if (! lpOutlineApp->m_lpDoc) goto error; ! 607: ! 608: // set the doc to an (Untitled) doc. ! 609: if (! OutlineDoc_InitNewFile(lpOutlineApp->m_lpDoc)) ! 610: goto error; ! 611: ! 612: // position and size the new doc window ! 613: OutlineApp_ResizeWindows(lpOutlineApp); ! 614: OutlineDoc_ShowWindow(lpOutlineApp->m_lpDoc); // calls OleDoc_Lock ! 615: ! 616: return; ! 617: ! 618: error: ! 619: // REVIEW: should load string from string resource ! 620: OutlineApp_ErrorMessage(lpOutlineApp, "Could not create new document"); ! 621: ! 622: if (lpOutlineApp->m_lpDoc) { ! 623: OutlineDoc_Destroy(lpOutlineApp->m_lpDoc); ! 624: lpOutlineApp->m_lpDoc = NULL; ! 625: } ! 626: ! 627: return; ! 628: ! 629: #endif ! 630: } ! 631: ! 632: ! 633: /* OutlineApp_OpenCommand ! 634: * ---------------------- ! 635: * ! 636: * Load a document from file (File.Open command). ! 637: */ ! 638: void OutlineApp_OpenCommand(LPOUTLINEAPP lpOutlineApp) ! 639: { ! 640: #if defined( OLE_VERSION ) ! 641: // Call OLE version of this function instead ! 642: OleApp_OpenCommand((LPOLEAPP)lpOutlineApp); ! 643: ! 644: #else ! 645: ! 646: OPENFILENAME ofn; ! 647: char szFilter[]=APPFILENAMEFILTER; ! 648: char szFileName[256]; ! 649: UINT i; ! 650: BOOL fStatus = TRUE; ! 651: ! 652: if (! OutlineDoc_CheckSaveChanges(lpOutlineApp->m_lpDoc, OLECLOSE_PROMPTSAVE)) ! 653: return; // abort opening new doc ! 654: ! 655: for(i=0; szFilter[i]; i++) ! 656: if(szFilter[i]=='|') szFilter[i]='\0'; ! 657: ! 658: _fmemset((LPOPENFILENAME)&ofn,0,sizeof(OPENFILENAME)); ! 659: ! 660: szFileName[0]='\0'; ! 661: ! 662: ofn.lStructSize=sizeof(OPENFILENAME); ! 663: ofn.hwndOwner=lpOutlineApp->m_hWndApp; ! 664: ofn.lpstrFilter=(LPSTR)szFilter; ! 665: ofn.lpstrFile=(LPSTR)szFileName; ! 666: ofn.nMaxFile=sizeof(szFileName); ! 667: ofn.Flags=OFN_FILEMUSTEXIST | OFN_HIDEREADONLY; ! 668: ofn.lpstrDefExt=DEFEXTENSION; ! 669: ! 670: if(! GetOpenFileName((LPOPENFILENAME)&ofn)) ! 671: return; // user canceled file open dialog ! 672: ! 673: OutlineDoc_Close(lpOutlineApp->m_lpDoc, OLECLOSE_NOSAVE); ! 674: OleDbgAssertSz( ! 675: lpOutlineApp->m_lpDoc==NULL,"Closed doc NOT properly destroyed"); ! 676: ! 677: lpOutlineApp->m_lpDoc = OutlineApp_CreateDoc(lpOutlineApp, FALSE); ! 678: if (! lpOutlineApp->m_lpDoc) goto error; ! 679: ! 680: fStatus=OutlineDoc_LoadFromFile(lpOutlineApp->m_lpDoc, (LPSTR)szFileName); ! 681: ! 682: if (! fStatus) { ! 683: // loading the doc failed; create an untitled instead ! 684: OutlineDoc_Destroy(lpOutlineApp->m_lpDoc); // destroy unused doc ! 685: lpOutlineApp->m_lpDoc = OutlineApp_CreateDoc(lpOutlineApp, FALSE); ! 686: if (! lpOutlineApp->m_lpDoc) goto error; ! 687: if (! OutlineDoc_InitNewFile(lpOutlineApp->m_lpDoc)) ! 688: goto error; ! 689: } ! 690: ! 691: // position and size the new doc window ! 692: OutlineApp_ResizeWindows(lpOutlineApp); ! 693: OutlineDoc_ShowWindow(lpOutlineApp->m_lpDoc); ! 694: ! 695: return; ! 696: ! 697: error: ! 698: // REVIEW: should load string from string resource ! 699: OutlineApp_ErrorMessage(lpOutlineApp, "Could not create new document"); ! 700: ! 701: if (lpOutlineApp->m_lpDoc) { ! 702: OutlineDoc_Destroy(lpOutlineApp->m_lpDoc); ! 703: lpOutlineApp->m_lpDoc = NULL; ! 704: } ! 705: ! 706: return; ! 707: ! 708: #endif ! 709: } ! 710: ! 711: ! 712: /* OutlineApp_PrintCommand ! 713: * ----------------------- ! 714: * ! 715: * Print the document ! 716: */ ! 717: void OutlineApp_PrintCommand(LPOUTLINEAPP lpOutlineApp) ! 718: { ! 719: LPOUTLINEDOC lpOutlineDoc = lpOutlineApp->m_lpDoc; ! 720: HDC hDC=NULL; ! 721: BOOL fMustDeleteDC = FALSE; ! 722: ! 723: if (!PrintDlg((LPPRINTDLG)&lpOutlineApp->m_PrintDlg)) { ! 724: if (!CommDlgExtendedError()) { // Cancel button pressed ! 725: return; ! 726: } ! 727: } ! 728: else { ! 729: hDC = OutlineApp_GetPrinterDC(lpOutlineApp); ! 730: if (hDC) { ! 731: ! 732: #if defined( OLE_VERSION ) ! 733: /* OLE2NOTE: while we are printing we do NOT want to ! 734: ** receive any OnDataChange notifications or other OLE ! 735: ** interface calls which could disturb the printing of ! 736: ** the document. we will temporarily reply ! 737: ** SERVERCALL_RETRYLATER ! 738: */ ! 739: OleApp_RejectInComingCalls((LPOLEAPP)lpOutlineApp, TRUE); ! 740: #endif ! 741: ! 742: OutlineDoc_Print(lpOutlineDoc, hDC); ! 743: DeleteDC(hDC); ! 744: ! 745: #if defined( OLE_VERSION ) ! 746: // re-enable LRPC calls ! 747: OleApp_RejectInComingCalls((LPOLEAPP)lpOutlineApp, FALSE); ! 748: #endif ! 749: ! 750: return; // Printing completed ! 751: } ! 752: } ! 753: ! 754: // REVIEW: should load string from string resource ! 755: OutlineApp_ErrorMessage(lpOutlineApp, ErrMsgPrinting); ! 756: } ! 757: ! 758: ! 759: /* OutlineApp_PrinterSetupCommand ! 760: * ------------------------------ ! 761: * ! 762: * Setup a different printer for printing ! 763: */ ! 764: void OutlineApp_PrinterSetupCommand(LPOUTLINEAPP lpOutlineApp) ! 765: { ! 766: DWORD FlagSave; ! 767: ! 768: FlagSave = lpOutlineApp->m_PrintDlg.Flags; ! 769: lpOutlineApp->m_PrintDlg.Flags |= PD_PRINTSETUP; ! 770: PrintDlg((LPPRINTDLG)&lpOutlineApp->m_PrintDlg); ! 771: lpOutlineApp->m_PrintDlg.Flags = FlagSave; ! 772: } ! 773: ! 774: /* ! 775: * FUNCTION : OutlineApp_GetPrinterDC () ! 776: * ! 777: * PURPOSE : Creates a printer display context for the printer ! 778: * ! 779: * RETURNS : HDC - A handle to printer DC. ! 780: */ ! 781: HDC OutlineApp_GetPrinterDC(LPOUTLINEAPP lpApp) ! 782: { ! 783: ! 784: HDC hDC; ! 785: LPDEVMODE lpDevMode = NULL; ! 786: LPDEVNAMES lpDevNames; ! 787: LPSTR lpszDriverName; ! 788: LPSTR lpszDeviceName; ! 789: LPSTR lpszPortName; ! 790: ! 791: if(lpApp->m_PrintDlg.hDC) { ! 792: hDC = lpApp->m_PrintDlg.hDC; ! 793: } else { ! 794: if(! lpApp->m_PrintDlg.hDevNames) ! 795: return(NULL); ! 796: lpDevNames = (LPDEVNAMES)GlobalLock(lpApp->m_PrintDlg.hDevNames); ! 797: lpszDriverName = (LPSTR)lpDevNames + lpDevNames->wDriverOffset; ! 798: lpszDeviceName = (LPSTR)lpDevNames + lpDevNames->wDeviceOffset; ! 799: lpszPortName = (LPSTR)lpDevNames + lpDevNames->wOutputOffset; ! 800: GlobalUnlock(lpApp->m_PrintDlg.hDevNames); ! 801: ! 802: if(lpApp->m_PrintDlg.hDevMode) ! 803: lpDevMode = (LPDEVMODE)GlobalLock(lpApp->m_PrintDlg.hDevMode); ! 804: #if defined( WIN32 ) ! 805: hDC = CreateDC( ! 806: lpszDriverName, ! 807: lpszDeviceName, ! 808: lpszPortName, ! 809: (CONST DEVMODE FAR*)lpDevMode); ! 810: #else ! 811: hDC = CreateDC( ! 812: lpszDriverName, ! 813: lpszDeviceName, ! 814: lpszPortName, ! 815: (LPSTR)lpDevMode); ! 816: #endif ! 817: ! 818: if(lpApp->m_PrintDlg.hDevMode && lpDevMode) ! 819: GlobalUnlock(lpApp->m_PrintDlg.hDevMode); ! 820: } ! 821: ! 822: return(hDC); ! 823: } ! 824: ! 825: ! 826: /* OutlineApp_SaveCommand ! 827: * ---------------------- ! 828: * ! 829: * Save the document with same name. If no name exists, prompt the user ! 830: * for a name (via SaveAsCommand) ! 831: * ! 832: * Parameters: ! 833: * ! 834: * Returns: ! 835: * TRUE if succesfully ! 836: * FALSE if failed or aborted ! 837: */ ! 838: BOOL OutlineApp_SaveCommand(LPOUTLINEAPP lpOutlineApp) ! 839: { ! 840: LPOUTLINEDOC lpOutlineDoc = OutlineApp_GetActiveDoc(lpOutlineApp); ! 841: ! 842: if(lpOutlineDoc->m_docInitType == DOCTYPE_NEW) /* file with no name */ ! 843: return OutlineApp_SaveAsCommand(lpOutlineApp); ! 844: ! 845: ! 846: if(OutlineDoc_IsModified(lpOutlineDoc)) { ! 847: ! 848: #if defined( OLE_SERVER ) ! 849: ! 850: if (lpOutlineDoc->m_docInitType == DOCTYPE_EMBEDDED) { ! 851: LPSERVERDOC lpServerDoc = (LPSERVERDOC)lpOutlineDoc; ! 852: HRESULT hrErr; ! 853: ! 854: /* OLE2NOTE: if the document is an embedded object, then ! 855: ** the "File.Save" command is changed to "File.Update". ! 856: ** in order to update our container, we must ask our ! 857: ** container to save us. ! 858: */ ! 859: OleDbgAssert(lpServerDoc->m_lpOleClientSite != NULL); ! 860: OLEDBG_BEGIN2("IOleClientSite::SaveObject called\r\n") ! 861: hrErr = lpServerDoc->m_lpOleClientSite->lpVtbl->SaveObject( ! 862: lpServerDoc->m_lpOleClientSite ! 863: ); ! 864: OLEDBG_END2 ! 865: ! 866: if (hrErr != NOERROR) { ! 867: OleDbgOutHResult("IOleClientSite::SaveObject returned",hrErr); ! 868: return FALSE; ! 869: } ! 870: } else ! 871: // document is file-base user document, save it to its file. ! 872: ! 873: #endif // OLE_SERVER ! 874: ! 875: (void)OutlineDoc_SaveToFile( ! 876: lpOutlineDoc, ! 877: NULL, ! 878: lpOutlineDoc->m_cfSaveFormat, ! 879: TRUE ! 880: ); ! 881: } ! 882: ! 883: return TRUE; ! 884: } ! 885: ! 886: ! 887: /* OutlineApp_SaveAsCommand ! 888: * ------------------------ ! 889: * ! 890: * Save the document as another name ! 891: * ! 892: * Parameters: ! 893: * ! 894: * Returns: ! 895: * TRUE if saved successful ! 896: * FALSE if failed or aborted ! 897: */ ! 898: BOOL OutlineApp_SaveAsCommand(LPOUTLINEAPP lpOutlineApp) ! 899: { ! 900: LPOUTLINEDOC lpOutlineDoc = lpOutlineApp->m_lpDoc; ! 901: OPENFILENAME ofn; ! 902: char szFilter[]=APPFILENAMEFILTER; ! 903: char szFileName[256]=""; ! 904: int i; ! 905: UINT uFormat; ! 906: BOOL fNoError = TRUE; ! 907: BOOL fRemember = TRUE; ! 908: ! 909: for(i=0; szFilter[i]; i++) ! 910: if(szFilter[i]=='|') szFilter[i]='\0'; ! 911: ! 912: _fmemset((LPOPENFILENAME)&ofn,0,sizeof(OPENFILENAME)); ! 913: ! 914: ofn.lStructSize=sizeof(OPENFILENAME); ! 915: ofn.hwndOwner=lpOutlineDoc->m_hWndDoc; ! 916: ofn.lpstrFilter=(LPSTR)szFilter; ! 917: ofn.lpstrFile=(LPSTR)szFileName; ! 918: ofn.nMaxFile=sizeof(szFileName); ! 919: ! 920: ofn.Flags=OFN_PATHMUSTEXIST | OFN_OVERWRITEPROMPT | OFN_HIDEREADONLY; ! 921: ofn.lpstrDefExt=DEFEXTENSION; ! 922: ! 923: if (GetSaveFileName((LPOPENFILENAME)&ofn)) { ! 924: ! 925: #if defined( OLE_CNTR ) ! 926: // determine which file type the user selected. ! 927: switch (ofn.nFilterIndex) { ! 928: case 1: ! 929: uFormat = ((LPCONTAINERAPP)lpOutlineApp)->m_cfCntrOutl; ! 930: break; ! 931: case 2: ! 932: uFormat = lpOutlineApp->m_cfOutline; ! 933: break; ! 934: default: ! 935: uFormat = ((LPCONTAINERAPP)lpOutlineApp)->m_cfCntrOutl; ! 936: break; ! 937: } ! 938: #else ! 939: uFormat = lpOutlineApp->m_cfOutline; ! 940: #endif ! 941: ! 942: #if defined( OLE_SERVER ) ! 943: /* OLE2NOTE: if the document is an embedded object, then the ! 944: ** File.SaveAs command is changed to File.SaveCopyAs. with the ! 945: ** Save Copy As operation, the document does NOT remember the ! 946: ** saved file as the associated file for the document. ! 947: */ ! 948: if (lpOutlineDoc->m_docInitType == DOCTYPE_EMBEDDED) ! 949: fRemember = FALSE; ! 950: #endif ! 951: ! 952: (void)OutlineDoc_SaveToFile( ! 953: lpOutlineDoc, ! 954: szFileName, ! 955: uFormat, ! 956: fRemember ! 957: ); ! 958: ! 959: } ! 960: else ! 961: fNoError = FALSE; ! 962: ! 963: return fNoError; ! 964: ! 965: } ! 966: ! 967: ! 968: /* OutlineApp_AboutCommand ! 969: * ----------------------- ! 970: * ! 971: * Show the About dialog box ! 972: */ ! 973: void OutlineApp_AboutCommand(LPOUTLINEAPP lpOutlineApp) ! 974: { ! 975: DialogBox( ! 976: lpOutlineApp->m_hInst, ! 977: (LPSTR)"About", ! 978: OutlineApp_GetFrameWindow(lpOutlineApp), ! 979: (DLGPROC)AboutDlgProc ! 980: ); ! 981: } ! 982: ! 983: ! 984: /* OutlineApp_CloseAllDocsAndExitCommand ! 985: * ------------------------------------- ! 986: * ! 987: * Close all active documents and exit the app. ! 988: * Because this is an SDI, there is only one document ! 989: * If the doc was modified, prompt the user if he wants to save it. ! 990: * ! 991: * Returns: ! 992: * TRUE if the app is successfully closed ! 993: * FALSE if failed or aborted ! 994: */ ! 995: BOOL OutlineApp_CloseAllDocsAndExitCommand(LPOUTLINEAPP lpOutlineApp) ! 996: { ! 997: BOOL fResult; ! 998: ! 999: OLEDBG_BEGIN2("OutlineApp_CloseAllDocsAndExitCommand\r\n") ! 1000: ! 1001: #if defined( OLE_VERSION ) ! 1002: // Call OLE specific version of this function ! 1003: fResult = OleApp_CloseAllDocsAndExitCommand((LPOLEAPP)lpOutlineApp); ! 1004: ! 1005: #else ! 1006: ! 1007: /* Because this is an SDI app, there is only one document. ! 1008: ** Close the doc. if it is successfully closed and the app will ! 1009: ** not automatically exit, then also exit the app. ! 1010: ** if this were an MDI app, we would loop through and close all ! 1011: ** open MDI child documents. ! 1012: */ ! 1013: if (OutlineDoc_Close(lpOutlineApp->m_lpDoc, OLECLOSE_PROMPTSAVE)) { ! 1014: ! 1015: OleDbgAssertSz( ! 1016: lpOutlineApp->m_lpDoc==NULL, ! 1017: "Closed doc NOT properly destroyed" ! 1018: ); ! 1019: ! 1020: OutlineApp_Destroy(lpOutlineApp); ! 1021: fResult = TRUE; ! 1022: ! 1023: } // else User Canceled shutdown ! 1024: else ! 1025: fResult = FALSE; ! 1026: ! 1027: #endif ! 1028: ! 1029: OLEDBG_END2 ! 1030: ! 1031: return fResult; ! 1032: } ! 1033: ! 1034: ! 1035: /* OutlineApp_Destroy ! 1036: * ------------------ ! 1037: * ! 1038: * Destroy all data structures used by the app and force the ! 1039: * app to shut down. This should be called after all documents have ! 1040: * been closed. ! 1041: */ ! 1042: void OutlineApp_Destroy(LPOUTLINEAPP lpOutlineApp) ! 1043: { ! 1044: OLEDBG_BEGIN3("OutlineApp_Destroy\r\n"); ! 1045: ! 1046: #if defined( OLE_VERSION ) ! 1047: /* OLE2NOTE: perform processing required for OLE */ ! 1048: OleApp_Destroy((LPOLEAPP)lpOutlineApp); ! 1049: #endif ! 1050: ! 1051: SetCursor(LoadCursor(NULL, MAKEINTRESOURCE(IDC_ARROW))); ! 1052: DestroyCursor(lpOutlineApp->m_hcursorSelCur); ! 1053: ! 1054: #if defined( USE_FRAMETOOLS ) ! 1055: FrameTools_Destroy(&lpOutlineApp->m_frametools); ! 1056: #endif ! 1057: ! 1058: DeleteObject(lpOutlineApp->m_hStdFont); ! 1059: if(lpOutlineApp->m_PrintDlg.hDevMode) ! 1060: GlobalFree(lpOutlineApp->m_PrintDlg.hDevMode); ! 1061: if(lpOutlineApp->m_PrintDlg.hDevNames) ! 1062: GlobalFree(lpOutlineApp->m_PrintDlg.hDevNames); ! 1063: ! 1064: #if defined( USE_STATUSBAR ) ! 1065: if(lpOutlineApp->m_hWndStatusBar) { ! 1066: DestroyStatusWindow(lpOutlineApp->m_hWndStatusBar); ! 1067: lpOutlineApp->m_hWndStatusBar = NULL; ! 1068: } ! 1069: #endif ! 1070: ! 1071: OutlineApp_DestroyWindow(lpOutlineApp); ! 1072: ! 1073: OleDbgOut1("@@@@ APP DESTROYED\r\n"); ! 1074: ! 1075: OLEDBG_END3 ! 1076: } ! 1077: ! 1078: ! 1079: /* OutlineApp_DestroyWindow ! 1080: * ------------------------ ! 1081: * ! 1082: * Destroy all windows created by the App. ! 1083: */ ! 1084: void OutlineApp_DestroyWindow(LPOUTLINEAPP lpOutlineApp) ! 1085: { ! 1086: HWND hWndApp = lpOutlineApp->m_hWndApp; ! 1087: ! 1088: if(hWndApp) { ! 1089: lpOutlineApp->m_hWndApp = NULL; ! 1090: lpOutlineApp->m_hWndAccelTarget = NULL; ! 1091: DestroyWindow(hWndApp); /* Quit the app */ ! 1092: } ! 1093: } ! 1094: ! 1095: ! 1096: /* OutlineApp_GetFrameRect ! 1097: ** ----------------------- ! 1098: ** Get the rectangle of the app frame window EXCLUDING space for the ! 1099: ** status line. ! 1100: ** ! 1101: ** OLE2NOTE: this is the rectangle that an in-place container can ! 1102: ** offer to an in-place active object from which to get frame tool ! 1103: ** space. ! 1104: */ ! 1105: void OutlineApp_GetFrameRect(LPOUTLINEAPP lpOutlineApp, LPRECT lprcFrameRect) ! 1106: { ! 1107: GetClientRect(lpOutlineApp->m_hWndApp, lprcFrameRect); ! 1108: ! 1109: #if defined( USE_STATUSBAR ) ! 1110: lprcFrameRect->bottom -= STATUS_HEIGHT; ! 1111: #endif ! 1112: ! 1113: } ! 1114: ! 1115: ! 1116: /* OutlineApp_GetClientAreaRect ! 1117: ** ---------------------------- ! 1118: ** Get the rectangle of the app frame window EXCLUDING space for the ! 1119: ** status line AND EXCLUDING space for any frame-level tools. ! 1120: ** ! 1121: ** OLE2NOTE: this is the rectangle that an in-place container gives ! 1122: ** to its in-place active object as the lpClipRect in ! 1123: ** IOleInPlaceSite::GetWindowContext. ! 1124: */ ! 1125: void OutlineApp_GetClientAreaRect( ! 1126: LPOUTLINEAPP lpOutlineApp, ! 1127: LPRECT lprcClientAreaRect ! 1128: ) ! 1129: { ! 1130: OutlineApp_GetFrameRect(lpOutlineApp, lprcClientAreaRect); ! 1131: ! 1132: /* if the app either uses frame-level tools itself or, as in-place ! 1133: ** container, is prepared to allow an in-place active object to ! 1134: ** have space for tools, then it must subtract away the space ! 1135: ** required for the tools. ! 1136: */ ! 1137: #if defined ( USE_FRAMETOOLS ) || defined ( INPLACE_CNTR ) ! 1138: ! 1139: lprcClientAreaRect->top += lpOutlineApp->m_FrameToolWidths.top; ! 1140: lprcClientAreaRect->left += lpOutlineApp->m_FrameToolWidths.left; ! 1141: lprcClientAreaRect->right -= lpOutlineApp->m_FrameToolWidths.right; ! 1142: lprcClientAreaRect->bottom -= lpOutlineApp->m_FrameToolWidths.bottom; ! 1143: #endif // USE_FRAMETOOLS || INPLACE_CNTR ! 1144: ! 1145: } ! 1146: ! 1147: ! 1148: /* OutlineApp_GetStatusLineRect ! 1149: ** ---------------------------- ! 1150: ** Get the rectangle required for the status line. ! 1151: ** ! 1152: ** OLE2NOTE: the top frame-level in-place container displays its ! 1153: ** status line even when an object is active in-place. ! 1154: */ ! 1155: void OutlineApp_GetStatusLineRect( ! 1156: LPOUTLINEAPP lpOutlineApp, ! 1157: LPRECT lprcStatusLineRect ! 1158: ) ! 1159: { ! 1160: RECT rcFrameRect; ! 1161: GetClientRect(lpOutlineApp->m_hWndApp, (LPRECT)&rcFrameRect); ! 1162: lprcStatusLineRect->left = rcFrameRect.left; ! 1163: lprcStatusLineRect->top = rcFrameRect.bottom - STATUS_HEIGHT; ! 1164: lprcStatusLineRect->right = rcFrameRect.right; ! 1165: lprcStatusLineRect->bottom = rcFrameRect.bottom; ! 1166: } ! 1167: ! 1168: ! 1169: /* OutlineApp_ResizeWindows ! 1170: * ------------------------ ! 1171: * ! 1172: * Changes the size and position of the SDI document and tool windows. ! 1173: * Normally called on a WM_SIZE message. ! 1174: * ! 1175: * Currently the app supports a status bar and a single SDI document window. ! 1176: * In the future it will have a formula bar and possibly multiple MDI ! 1177: * document windows. ! 1178: * ! 1179: * CUSTOMIZATION: Change positions of windows. ! 1180: */ ! 1181: void OutlineApp_ResizeWindows(LPOUTLINEAPP lpOutlineApp) ! 1182: { ! 1183: LPOUTLINEDOC lpOutlineDoc = OutlineApp_GetActiveDoc(lpOutlineApp); ! 1184: RECT rcStatusLineRect; ! 1185: ! 1186: if (! lpOutlineApp) ! 1187: return; ! 1188: ! 1189: #if defined( INPLACE_CNTR ) ! 1190: if (lpOutlineDoc) ! 1191: ContainerDoc_FrameWindowResized((LPCONTAINERDOC)lpOutlineDoc); ! 1192: #elif defined( USE_FRAMETOOLS ) ! 1193: if (lpOutlineDoc) ! 1194: OutlineDoc_AddFrameLevelTools(lpOutlineDoc); ! 1195: #else ! 1196: OutlineApp_ResizeClientArea(lpOutlineApp); ! 1197: #endif ! 1198: ! 1199: #if defined( USE_STATUSBAR ) ! 1200: if (lpOutlineApp->m_hWndStatusBar) { ! 1201: OutlineApp_GetStatusLineRect(lpOutlineApp, (LPRECT)&rcStatusLineRect); ! 1202: MoveWindow( ! 1203: lpOutlineApp->m_hWndStatusBar, ! 1204: rcStatusLineRect.left, ! 1205: rcStatusLineRect.top, ! 1206: rcStatusLineRect.right - rcStatusLineRect.left, ! 1207: rcStatusLineRect.bottom - rcStatusLineRect.top, ! 1208: TRUE /* fRepaint */ ! 1209: ); ! 1210: } ! 1211: #endif // USE_STATUSBAR ! 1212: } ! 1213: ! 1214: ! 1215: #if defined( USE_FRAMETOOLS ) || defined( INPLACE_CNTR ) ! 1216: ! 1217: void OutlineApp_SetBorderSpace( ! 1218: LPOUTLINEAPP lpOutlineApp, ! 1219: LPBORDERWIDTHS lpBorderWidths ! 1220: ) ! 1221: { ! 1222: lpOutlineApp->m_FrameToolWidths = *lpBorderWidths; ! 1223: OutlineApp_ResizeClientArea(lpOutlineApp); ! 1224: } ! 1225: #endif // USE_FRAMETOOLS || INPLACE_CNTR ! 1226: ! 1227: ! 1228: void OutlineApp_ResizeClientArea(LPOUTLINEAPP lpOutlineApp) ! 1229: { ! 1230: RECT rcClientAreaRect; ! 1231: ! 1232: #if defined( MDI_VERSION ) ! 1233: ! 1234: // Resize MDI Client Area Window here ! 1235: ! 1236: #else ! 1237: ! 1238: if (lpOutlineApp->m_lpDoc) { ! 1239: OutlineApp_GetClientAreaRect( ! 1240: lpOutlineApp, (LPRECT)&rcClientAreaRect); ! 1241: OutlineDoc_Resize(lpOutlineApp->m_lpDoc, ! 1242: (LPRECT)&rcClientAreaRect); ! 1243: } ! 1244: ! 1245: #endif ! 1246: ! 1247: } ! 1248: ! 1249: ! 1250: /* OutlineApp_GetActiveDoc ! 1251: * ----------------------- ! 1252: * ! 1253: * Return the document in focus. For SDI, the same (only one) document is ! 1254: * always returned. ! 1255: */ ! 1256: LPOUTLINEDOC OutlineApp_GetActiveDoc(LPOUTLINEAPP lpOutlineApp) ! 1257: { ! 1258: return lpOutlineApp->m_lpDoc; ! 1259: } ! 1260: ! 1261: /* OutlineApp_GetMenu ! 1262: * ------------------ ! 1263: * ! 1264: * Return the menu handle of the app ! 1265: */ ! 1266: HMENU OutlineApp_GetMenu(LPOUTLINEAPP lpOutlineApp) ! 1267: { ! 1268: if (!lpOutlineApp) { ! 1269: return NULL; ! 1270: } ! 1271: ! 1272: return lpOutlineApp->m_hMenuApp; ! 1273: } ! 1274: ! 1275: ! 1276: #if defined( USE_FRAMETOOLS ) ! 1277: ! 1278: /* OutlineApp_GetFrameTools ! 1279: * --------------------- ! 1280: * ! 1281: * Return the pointer to the toolbar object ! 1282: */ ! 1283: LPFRAMETOOLS OutlineApp_GetFrameTools(LPOUTLINEAPP lpOutlineApp) ! 1284: { ! 1285: return (LPFRAMETOOLS)&lpOutlineApp->m_frametools; ! 1286: } ! 1287: #endif ! 1288: ! 1289: ! 1290: /* OutlineApp_GetStatusWindow ! 1291: * -------------------------- ! 1292: * ! 1293: * Return the status bar window handle. ! 1294: */ ! 1295: HWND OutlineApp_GetStatusWindow(LPOUTLINEAPP lpOutlineApp) ! 1296: { ! 1297: return lpOutlineApp->m_hWndStatusBar; ! 1298: } ! 1299: ! 1300: ! 1301: /* OutlineApp_GetActiveFont ! 1302: * ------------------------ ! 1303: * ! 1304: * Return the font used by the application ! 1305: */ ! 1306: HFONT OutlineApp_GetActiveFont(LPOUTLINEAPP lpOutlineApp) ! 1307: { ! 1308: return lpOutlineApp->m_hStdFont; ! 1309: } ! 1310: ! 1311: ! 1312: /* OutlineApp_GetAppName ! 1313: * --------------------- ! 1314: * ! 1315: * Retrieve the application name ! 1316: */ ! 1317: void OutlineApp_GetAppName(LPOUTLINEAPP lpOutlineApp, LPSTR lpszAppName) ! 1318: { ! 1319: lstrcpy(lpszAppName, APPNAME); ! 1320: } ! 1321: ! 1322: ! 1323: /* OutlineApp_GetAppVersionNo ! 1324: * -------------------------- ! 1325: * ! 1326: * Get the version number (major and minor) of the application ! 1327: */ ! 1328: void OutlineApp_GetAppVersionNo(LPOUTLINEAPP lpOutlineApp, int narrAppVersionNo[]) ! 1329: { ! 1330: narrAppVersionNo[0] = APPMAJORVERSIONNO; ! 1331: narrAppVersionNo[1] = APPMINORVERSIONNO; ! 1332: } ! 1333: ! 1334: ! 1335: /* OutlineApp_VersionNoCheck ! 1336: * ------------------------- ! 1337: * ! 1338: * Check if the version stamp read from a file is compatible ! 1339: * with the current instance of the application. ! 1340: * returns TRUE if the file can be read, else FALSE. ! 1341: */ ! 1342: BOOL OutlineApp_VersionNoCheck(LPOUTLINEAPP lpOutlineApp, LPSTR lpszFormatName, int narrAppVersionNo[]) ! 1343: { ! 1344: #if defined( OLE_CNTR ) ! 1345: ! 1346: /* ContainerApp accepts both CF_OUTLINE and CF_CONTAINEROUTLINE formats */ ! 1347: if (lstrcmp(lpszFormatName, CONTAINERDOCFORMAT) != 0 && ! 1348: lstrcmp(lpszFormatName, OUTLINEDOCFORMAT) != 0) { ! 1349: // REVIEW: should load string from string resource ! 1350: OutlineApp_ErrorMessage( ! 1351: lpOutlineApp, ! 1352: "File is either corrupted or not of proper type." ! 1353: ); ! 1354: return FALSE; ! 1355: } ! 1356: ! 1357: #else ! 1358: ! 1359: /* OutlineApp accepts CF_OUTLINE format only */ ! 1360: if (lstrcmp(lpszFormatName, OUTLINEDOCFORMAT) != 0) { ! 1361: // REVIEW: should load string from string resource ! 1362: OutlineApp_ErrorMessage( ! 1363: lpOutlineApp, ! 1364: "File is either corrupted or not of proper type." ! 1365: ); ! 1366: return FALSE; ! 1367: } ! 1368: #endif ! 1369: ! 1370: if (narrAppVersionNo[0] < APPMAJORVERSIONNO) { ! 1371: // REVIEW: should load string from string resource ! 1372: OutlineApp_ErrorMessage( ! 1373: lpOutlineApp, ! 1374: "File was created by an older version; it can not be read." ! 1375: ); ! 1376: return FALSE; ! 1377: } ! 1378: ! 1379: return TRUE; ! 1380: } ! 1381: ! 1382: ! 1383: /* OutlineApp_ErrorMessage ! 1384: * ----------------------- ! 1385: * ! 1386: * Display an error message box ! 1387: */ ! 1388: void OutlineApp_ErrorMessage(LPOUTLINEAPP lpOutlineApp, LPSTR lpszErrMsg) ! 1389: { ! 1390: HWND hWndFrame = OutlineApp_GetFrameWindow(lpOutlineApp); ! 1391: ! 1392: // OLE2NOTE: only put up user message boxes if app is visible ! 1393: if (IsWindowVisible(hWndFrame)) ! 1394: MessageBox(hWndFrame, lpszErrMsg, NULL, MB_ICONEXCLAMATION | MB_OK); ! 1395: } ! 1396: ! 1397: ! 1398: #if defined( USE_FRAMETOOLS ) ! 1399: ! 1400: /* OutlineApp_SetFormulaBarAccel ! 1401: * ----------------------------- ! 1402: * ! 1403: * Set accelerator table based on state of formula bar. ! 1404: */ ! 1405: void OutlineApp_SetFormulaBarAccel( ! 1406: LPOUTLINEAPP lpOutlineApp, ! 1407: BOOL fEditFocus ! 1408: ) ! 1409: { ! 1410: if (fEditFocus) ! 1411: lpOutlineApp->m_hAccel = lpOutlineApp->m_hAccelFocusEdit; ! 1412: else ! 1413: lpOutlineApp->m_hAccel = lpOutlineApp->m_hAccelApp; ! 1414: } ! 1415: ! 1416: #endif // USE_FRAMETOOLS
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.