![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to oledoc.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 oledoc.c CVS log | Up to [WindowsNT SDKs] / mstools / ole20 / samples / outline |
1.1 ! root 1: /************************************************************************* ! 2: ** ! 3: ** OLE 2 Server Sample Code ! 4: ** ! 5: ** oledoc.c ! 6: ** ! 7: ** This file contains general OleDoc methods and related support ! 8: ** functions. OleDoc implementation is used by both the Container ! 9: ** versions and the Server (Object) versions of the Outline Sample. ! 10: ** ! 11: ** This file includes general support for the following: ! 12: ** 1. show/hide doc window ! 13: ** 2. QueryInterface, AddRef, Release ! 14: ** 3. document locking (calls CoLockObjectExternal) ! 15: ** 4. document shutdown (Close, Destroy) ! 16: ** 5. clipboard support ! 17: ** ! 18: ** OleDoc Object ! 19: ** exposed interfaces: ! 20: ** IUnknown ! 21: ** IPersistFile ! 22: ** IOleItemContainer ! 23: ** IDataObject ! 24: ** ! 25: ** (c) Copyright Microsoft Corp. 1992 - 1993 All Rights Reserved ! 26: ** ! 27: *************************************************************************/ ! 28: ! 29: ! 30: #include "outline.h" ! 31: ! 32: OLEDBGDATA ! 33: ! 34: extern LPOUTLINEAPP g_lpApp; ! 35: ! 36: extern IUnknownVtbl g_OleDoc_UnknownVtbl; ! 37: extern IPersistFileVtbl g_OleDoc_PersistFileVtbl; ! 38: extern IOleItemContainerVtbl g_OleDoc_OleItemContainerVtbl; ! 39: extern IDataObjectVtbl g_OleDoc_DataObjectVtbl; ! 40: ! 41: #if defined( USE_DRAGDROP ) ! 42: extern IDropTargetVtbl g_OleDoc_DropTargetVtbl; ! 43: extern IDropSourceVtbl g_OleDoc_DropSourceVtbl; ! 44: #endif // USE_DRAGDROP ! 45: ! 46: #if defined( INPLACE_CNTR ) ! 47: extern BOOL g_fInsideOutContainer; ! 48: #endif ! 49: ! 50: ! 51: /* OleDoc_Init ! 52: * ----------- ! 53: * ! 54: * Initialize the fields of a new OleDoc object. The object is initially ! 55: * not associated with a file or an (Untitled) document. This function sets ! 56: * the docInitType to DOCTYPE_UNKNOWN. After calling this function the ! 57: * caller should call: ! 58: * 1.) Doc_InitNewFile to set the OleDoc to (Untitled) ! 59: * 2.) Doc_LoadFromFile to associate the OleDoc with a file. ! 60: * This function creates a new window for the document. ! 61: * ! 62: * NOTE: the window is initially created with a NIL size. it must be ! 63: * sized and positioned by the caller. also the document is initially ! 64: * created invisible. the caller must call OutlineDoc_ShowWindow ! 65: * after sizing it to make the document window visible. ! 66: */ ! 67: BOOL OleDoc_Init(LPOLEDOC lpOleDoc, BOOL fDataTransferDoc) ! 68: { ! 69: LPOLEAPP lpOleApp = (LPOLEAPP)g_lpApp; ! 70: LPLINELIST lpLL = (LPLINELIST)&((LPOUTLINEDOC)lpOleDoc)->m_LineList; ! 71: ! 72: lpOleDoc->m_cRef = 0; ! 73: lpOleDoc->m_cLock = 0; ! 74: ! 75: lpOleDoc->m_dwRegROT = 0; ! 76: lpOleDoc->m_lpFileMoniker = NULL; ! 77: lpOleDoc->m_fLinkSourceAvail = FALSE; ! 78: lpOleDoc->m_lpSrcDocOfCopy = NULL; ! 79: lpOleDoc->m_fObjIsClosing = FALSE; ! 80: lpOleDoc->m_fObjIsDestroying = FALSE; ! 81: lpOleDoc->m_fUpdateEditMenu = FALSE; ! 82: ! 83: #if defined( USE_DRAGDROP ) ! 84: lpOleDoc->m_dwTimeEnterScrollArea = 0; ! 85: lpOleDoc->m_lastdwScrollDir = SCROLLDIR_NULL; ! 86: lpOleDoc->m_fRegDragDrop = FALSE; ! 87: lpOleDoc->m_fLocalDrag = FALSE; ! 88: lpOleDoc->m_fCanDropCopy = FALSE; ! 89: lpOleDoc->m_fCanDropLink = FALSE; ! 90: lpOleDoc->m_fLocalDrop = FALSE; ! 91: lpOleDoc->m_fDragLeave = FALSE; ! 92: lpOleDoc->m_fPendingDrag = FALSE; ! 93: #endif ! 94: ! 95: INIT_INTERFACEIMPL( ! 96: &lpOleDoc->m_Unknown, ! 97: &g_OleDoc_UnknownVtbl, ! 98: lpOleDoc ! 99: ); ! 100: ! 101: INIT_INTERFACEIMPL( ! 102: &lpOleDoc->m_PersistFile, ! 103: &g_OleDoc_PersistFileVtbl, ! 104: lpOleDoc ! 105: ); ! 106: ! 107: INIT_INTERFACEIMPL( ! 108: &lpOleDoc->m_OleItemContainer, ! 109: &g_OleDoc_OleItemContainerVtbl, ! 110: lpOleDoc ! 111: ); ! 112: ! 113: INIT_INTERFACEIMPL( ! 114: &lpOleDoc->m_DataObject, ! 115: &g_OleDoc_DataObjectVtbl, ! 116: lpOleDoc ! 117: ); ! 118: ! 119: #if defined( USE_DRAGDROP ) ! 120: INIT_INTERFACEIMPL( ! 121: &lpOleDoc->m_DropSource, ! 122: &g_OleDoc_DropSourceVtbl, ! 123: lpOleDoc ! 124: ); ! 125: ! 126: INIT_INTERFACEIMPL( ! 127: &lpOleDoc->m_DropTarget, ! 128: &g_OleDoc_DropTargetVtbl, ! 129: lpOleDoc ! 130: ); ! 131: #endif // USE_DRAGDROP ! 132: ! 133: /* ! 134: ** OLE2NOTE: each user level document addref's the app object in ! 135: ** order to guarentee that the app does not shut down while the ! 136: ** doc is still open. ! 137: */ ! 138: ! 139: // OLE2NOTE: data transfer documents should not hold the app alive ! 140: if (! fDataTransferDoc) ! 141: OleApp_DocLockApp(lpOleApp); ! 142: ! 143: #if defined( OLE_SERVER ) ! 144: ! 145: /* OLE2NOTE: perform initialization specific for an OLE server */ ! 146: if (! ServerDoc_Init((LPSERVERDOC)lpOleDoc, fDataTransferDoc)) ! 147: return FALSE; ! 148: ! 149: #elif defined( OLE_CNTR ) ! 150: ! 151: /* OLE2NOTE: perform initialization specific for an OLE container */ ! 152: if (! ContainerDoc_Init((LPCONTAINERDOC)lpOleDoc, fDataTransferDoc)) ! 153: return FALSE; ! 154: ! 155: #endif ! 156: ! 157: return TRUE; ! 158: } ! 159: ! 160: ! 161: ! 162: /* OleDoc_InitNewFile ! 163: * ------------------ ! 164: * ! 165: * Initialize the document to be a new (Untitled) document. ! 166: * This function sets the docInitType to DOCTYPE_NEW. ! 167: * ! 168: * OLE2NOTE: if this is a visible user document then generate a unique ! 169: * untitled name that we can use to register in the RunningObjectTable. ! 170: * We need a unique name so that clients can link to data in this document ! 171: * even when the document is in the un-saved (untitled) state. it would be ! 172: * ambiguous to register two documents titled "Outline1" in the ROT. we ! 173: * thus generate the lowest numbered document that is not already ! 174: * registered in the ROT. ! 175: */ ! 176: BOOL OleDoc_InitNewFile(LPOLEDOC lpOleDoc) ! 177: { ! 178: LPOUTLINEDOC lpOutlineDoc = (LPOUTLINEDOC)lpOleDoc; ! 179: ! 180: static UINT uUnique = 1; ! 181: ! 182: OleDbgAssert(lpOutlineDoc->m_docInitType == DOCTYPE_UNKNOWN); ! 183: ! 184: #if defined( OLE_CNTR ) ! 185: { ! 186: LPCONTAINERDOC lpContainerDoc = (LPCONTAINERDOC)lpOleDoc; ! 187: ! 188: OleDbgAssertSz(lpContainerDoc->m_lpStg == NULL, ! 189: "Setting to untitled with current file open" ! 190: ); ! 191: ! 192: /* Create a temp, (delete-on-release) file base storage ! 193: ** for the untitled document. ! 194: */ ! 195: lpContainerDoc->m_lpStg = OleStdCreateRootStorage( ! 196: NULL, ! 197: STGM_SHARE_EXCLUSIVE ! 198: ); ! 199: if (! lpContainerDoc->m_lpStg) return FALSE; ! 200: } ! 201: #endif ! 202: ! 203: lpOutlineDoc->m_docInitType = DOCTYPE_NEW; ! 204: ! 205: if (! lpOutlineDoc->m_fDataTransferDoc) { ! 206: /* OLE2NOTE: choose a unique name for a Moniker so that ! 207: ** potential clients can link to our new, untitled document. ! 208: ** if links are established (and currently are connected), ! 209: ** then they will be notified that we have been renamed when ! 210: ** this document is saved to a file. ! 211: */ ! 212: ! 213: lpOleDoc->m_fLinkSourceAvail = TRUE; ! 214: ! 215: // REVIEW: should load UNTITLED string from string resource ! 216: OleStdCreateTempFileMoniker( ! 217: UNTITLED, ! 218: (UINT FAR*)&uUnique, ! 219: lpOutlineDoc->m_szFileName, ! 220: &lpOleDoc->m_lpFileMoniker ! 221: ); ! 222: ! 223: OLEDBG_BEGIN3("OleStdRegisterAsRunning called\r\n") ! 224: OleStdRegisterAsRunning( ! 225: (LPUNKNOWN)&lpOleDoc->m_PersistFile, ! 226: (LPMONIKER)lpOleDoc->m_lpFileMoniker, ! 227: &lpOleDoc->m_dwRegROT ! 228: ); ! 229: OLEDBG_END3 ! 230: ! 231: lpOutlineDoc->m_lpszDocTitle = lpOutlineDoc->m_szFileName; ! 232: OutlineDoc_SetTitle(lpOutlineDoc); ! 233: } else { ! 234: lstrcpy(lpOutlineDoc->m_szFileName, UNTITLED); ! 235: lpOutlineDoc->m_lpszDocTitle = lpOutlineDoc->m_szFileName; ! 236: } ! 237: ! 238: return TRUE; ! 239: } ! 240: ! 241: ! 242: /* OleDoc_ShowWindow ! 243: * ----------------- ! 244: * ! 245: * Show the window of the document to the user. ! 246: * make sure app window is visible and bring the document to the top. ! 247: * if the document is a file-based document or a new untitled ! 248: * document, give the user the control over the life-time of the doc. ! 249: */ ! 250: void OleDoc_ShowWindow(LPOLEDOC lpOleDoc) ! 251: { ! 252: LPOUTLINEAPP lpOutlineApp = (LPOUTLINEAPP)g_lpApp; ! 253: LPOLEAPP lpOleApp = (LPOLEAPP)g_lpApp; ! 254: LPOUTLINEDOC lpOutlineDoc = (LPOUTLINEDOC)lpOleDoc; ! 255: LPLINELIST lpLL = (LPLINELIST)&((LPOUTLINEDOC)lpOleDoc)->m_LineList; ! 256: #if defined( OLE_SERVER ) ! 257: LPSERVERDOC lpServerDoc = (LPSERVERDOC)lpOleDoc; ! 258: #endif // OLE_SERVER ! 259: ! 260: OLEDBG_BEGIN3("OleDoc_ShowWindow\r\n") ! 261: ! 262: /* OLE2NOTE: while the document is visible, we do NOT want it to be ! 263: ** prematurely destroyed when a linking client disconnects. thus ! 264: ** we must inform OLE to hold an external lock on our document. ! 265: ** this arranges that OLE holds at least 1 reference to our ! 266: ** document that will NOT be released until we release this ! 267: ** external lock. later, when the document window is hidden, we ! 268: ** will release this external lock. ! 269: */ ! 270: if (! IsWindowVisible(lpOutlineDoc->m_hWndDoc)) ! 271: OleDoc_Lock(lpOleDoc, TRUE /* fLock */, 0 /* not applicable */); ! 272: ! 273: #if defined( USE_DRAGDROP ) ! 274: /* OLE2NOTE: since our window is now being made visible, we will ! 275: ** register our window as a potential drop target. when the ! 276: ** window is hidden there is no reason to be registered as a ! 277: ** drop target. ! 278: */ ! 279: if (! lpOleDoc->m_fRegDragDrop) { ! 280: OLEDBG_BEGIN2("RegisterDragDrop called\r\n") ! 281: RegisterDragDrop( ! 282: LineList_GetWindow(lpLL), ! 283: (LPDROPTARGET)&lpOleDoc->m_DropTarget ! 284: ); ! 285: OLEDBG_END2 ! 286: lpOleDoc->m_fRegDragDrop = TRUE; ! 287: } ! 288: #endif // USE_DRAGDROP ! 289: ! 290: #if defined( USE_FRAMETOOLS ) ! 291: { ! 292: /* OLE2NOTE: we need to enable our frame level tools ! 293: */ ! 294: FrameTools_Enable(lpOutlineDoc->m_lpFrameTools, TRUE); ! 295: } ! 296: #endif // USE_FRAMETOOLS ! 297: ! 298: #if defined( OLE_SERVER ) ! 299: ! 300: if (lpOutlineDoc->m_docInitType == DOCTYPE_EMBEDDED && ! 301: lpServerDoc->m_lpOleClientSite != NULL) { ! 302: ! 303: /* OLE2NOTE: we must also ask our container to show itself if ! 304: ** it is not already visible and to scroll us into view. we ! 305: ** must make sure to call this BEFORE showing our server's ! 306: ** window and taking focus. we do not want our container's ! 307: ** window to end up on top. ! 308: */ ! 309: OLEDBG_BEGIN2("IOleClientSite::ShowObject called\r\n"); ! 310: lpServerDoc->m_lpOleClientSite->lpVtbl->ShowObject( ! 311: lpServerDoc->m_lpOleClientSite ! 312: ); ! 313: OLEDBG_END2 ! 314: ! 315: /* OLE2NOTE: if we are an embedded object and we are not ! 316: ** in-place active in our containers window, we must inform our ! 317: ** embedding container that our window is opening. ! 318: ** the container must now hatch our object. ! 319: */ ! 320: ! 321: #if defined( INPLACE_SVR ) ! 322: if (! lpServerDoc->m_fInPlaceActive) ! 323: #endif ! 324: { ! 325: OLEDBG_BEGIN2("IOleClientSite::OnShowWindow(TRUE) called\r\n"); ! 326: lpServerDoc->m_lpOleClientSite->lpVtbl->OnShowWindow( ! 327: lpServerDoc->m_lpOleClientSite, ! 328: TRUE ! 329: ); ! 330: OLEDBG_END2 ! 331: } ! 332: ! 333: /* OLE2NOTE: the life-time of our document is controlled by our ! 334: ** client and NOT by the user. we are not an independent ! 335: ** file-level object. we simply want to show our window here. ! 336: ** ! 337: ** if we are not in-place active (ie. we are opening ! 338: ** our own window), we must make sure our main app window is ! 339: ** visible. we do not, however, want to give the user ! 340: ** control of the App window; we do not want OleApp_ShowWindow ! 341: ** to call OleApp_Lock on behalf of the user. ! 342: */ ! 343: if (! IsWindowVisible(lpOutlineApp->m_hWndApp) || ! 344: IsIconic(lpOutlineApp->m_hWndApp)) { ! 345: #if defined( INPLACE_SVR ) ! 346: if (! ((LPSERVERDOC)lpOleDoc)->m_fInPlaceActive) ! 347: #endif ! 348: OleApp_ShowWindow(lpOleApp, FALSE /* fGiveUserCtrl */); ! 349: SetFocus(lpOutlineDoc->m_hWndDoc); ! 350: } ! 351: ! 352: } else ! 353: #endif // OLE_SERVER ! 354: ! 355: { // DOCTYPE_NEW || DOCTYPE_FROMFILE ! 356: ! 357: // we must make sure our app window is visible ! 358: OleApp_ShowWindow(lpOleApp, TRUE /* fGiveUserCtrl */); ! 359: } ! 360: ! 361: // make document window visible and make sure it is not minimized ! 362: ShowWindow(lpOutlineDoc->m_hWndDoc, SW_SHOWNORMAL); ! 363: SetFocus(lpOutlineDoc->m_hWndDoc); ! 364: ! 365: OLEDBG_END3 ! 366: } ! 367: ! 368: ! 369: /* OleDoc_HideWindow ! 370: * ----------------- ! 371: * ! 372: * Hide the window of the document from the user. ! 373: * take away the control of the document by the user. ! 374: */ ! 375: void OleDoc_HideWindow(LPOLEDOC lpOleDoc, BOOL fShutdown) ! 376: { ! 377: LPOLEAPP lpOleApp = (LPOLEAPP)g_lpApp; ! 378: LPOUTLINEDOC lpOutlineDoc = (LPOUTLINEDOC)lpOleDoc; ! 379: LPLINELIST lpLL = (LPLINELIST)&((LPOUTLINEDOC)lpOleDoc)->m_LineList; ! 380: ! 381: if (! IsWindowVisible(lpOutlineDoc->m_hWndDoc)) ! 382: return; // already visible ! 383: ! 384: OLEDBG_BEGIN3("OleDoc_HideWindow\r\n") ! 385: ! 386: #if defined( USE_DRAGDROP ) ! 387: // The document's window is being hidden, revoke it as a DropTarget ! 388: if (lpOleDoc->m_fRegDragDrop) { ! 389: OLEDBG_BEGIN2("RevokeDragDrop called\r\n"); ! 390: RevokeDragDrop(LineList_GetWindow(lpLL)); ! 391: OLEDBG_END2 ! 392: ! 393: lpOleDoc->m_fRegDragDrop = FALSE ; ! 394: } ! 395: #endif // USE_DRAGDROP ! 396: ! 397: /* OLE2NOTE: the document is now being hidden, so we must release ! 398: ** the external lock made when the document was made visible. ! 399: ** if this is a shutdown situation (fShutdown==TRUE), then OLE ! 400: ** is instructed to release our document. if this is that last ! 401: ** external lock on our document, thus enabling our document to ! 402: ** complete its shutdown operation. If This is not a shutdown ! 403: ** situation (eg. in-place server hiding its window when ! 404: ** UIDeactivating or IOleObject::DoVerb(OLEVERB_HIDE) is called), ! 405: ** then OLE is told to NOT immediately release the document. ! 406: ** this leaves the document in an unstable state where the next ! 407: ** Lock/Unlock sequence will shut the document down (eg. a ! 408: ** linking client connecting and disconnecting). ! 409: */ ! 410: if (fShutdown && IsWindowVisible(lpOutlineDoc->m_hWndDoc)) ! 411: OleDoc_Lock(lpOleDoc, FALSE /* fLock */, fShutdown); ! 412: ! 413: ShowWindow(((LPOUTLINEDOC)lpOleDoc)->m_hWndDoc, SW_HIDE); ! 414: ! 415: #if defined( OLE_SERVER ) ! 416: { ! 417: LPSERVERDOC lpServerDoc = (LPSERVERDOC)lpOleDoc; ! 418: ! 419: /* OLE2NOTE: if we are an embedded object and we are not ! 420: ** in-place active, we must inform our ! 421: ** embedding container that our window is hiding (closing ! 422: ** from the user's perspective). the container must now ! 423: ** un-hatch our object. ! 424: */ ! 425: if (lpServerDoc->m_lpOleClientSite != NULL ! 426: #if defined( INPLACE_SVR ) ! 427: && !lpServerDoc->m_fInPlaceVisible ! 428: #endif ! 429: ) { ! 430: OLEDBG_BEGIN2("IOleClientSite::OnShowWindow(FALSE) called\r\n"); ! 431: lpServerDoc->m_lpOleClientSite->lpVtbl->OnShowWindow( ! 432: lpServerDoc->m_lpOleClientSite, ! 433: FALSE ! 434: ); ! 435: OLEDBG_END2 ! 436: } ! 437: } ! 438: #endif ! 439: ! 440: /* OLE2NOTE: if there are no more documents visible to the user. ! 441: ** and the app itself is not under user control, then ! 442: ** it has no reason to stay visible. we thus should hide the ! 443: ** app. we can not directly destroy the app, because it may be ! 444: ** validly being used programatically by another client ! 445: ** application and should remain running. it should simply be ! 446: ** hidded from the user. ! 447: */ ! 448: OleApp_HideIfNoReasonToStayVisible(lpOleApp); ! 449: OLEDBG_END3 ! 450: } ! 451: ! 452: ! 453: /* OleDoc_Lock ! 454: ** ----------- ! 455: ** Lock/Unlock the Doc object. if the last lock is unlocked and ! 456: ** fLastUnlockReleases == TRUE, then the Doc object will shut down ! 457: ** (ie. it will recieve its final release and its refcnt will go to 0). ! 458: */ ! 459: HRESULT OleDoc_Lock(LPOLEDOC lpOleDoc, BOOL fLock, BOOL fLastUnlockReleases) ! 460: { ! 461: HRESULT hrErr; ! 462: ! 463: #if defined( _DEBUG ) ! 464: if (fLock) { ! 465: OLEDBG_BEGIN2("CoLockObjectExternal(lpDoc,TRUE) called\r\n") ! 466: } else { ! 467: if (fLastUnlockReleases) ! 468: OLEDBG_BEGIN2("CoLockObjectExternal(lpDoc,FALSE,TRUE) called\r\n") ! 469: else ! 470: OLEDBG_BEGIN2("CoLockObjectExternal(lpDoc,FALSE,FALSE) called\r\n") ! 471: } ! 472: #endif // _DEBUG ! 473: ! 474: OleDoc_AddRef(lpOleDoc); // artificial AddRef to make object stable ! 475: ! 476: hrErr = CoLockObjectExternal( ! 477: (LPUNKNOWN)&lpOleDoc->m_Unknown, fLock, fLastUnlockReleases); ! 478: ! 479: OleDoc_Release(lpOleDoc); // release artificial AddRef above ! 480: ! 481: OLEDBG_END2 ! 482: return hrErr; ! 483: } ! 484: ! 485: ! 486: /* OleDoc_AddRef ! 487: ** ------------- ! 488: ** ! 489: ** increment the ref count of the document object. ! 490: ** ! 491: ** Returns the new ref count on the object ! 492: */ ! 493: ULONG OleDoc_AddRef(LPOLEDOC lpOleDoc) ! 494: { ! 495: ++lpOleDoc->m_cRef; ! 496: ! 497: OleDbgOutRefCnt4( ! 498: "OleDoc_AddRef: cRef++\r\n", ! 499: lpOleDoc, ! 500: lpOleDoc->m_cRef ! 501: ); ! 502: ! 503: return lpOleDoc->m_cRef; ! 504: } ! 505: ! 506: ! 507: /* OleDoc_Release ! 508: ** -------------- ! 509: ** ! 510: ** decrement the ref count of the document object. ! 511: ** if the ref count goes to 0, then the document is destroyed. ! 512: ** ! 513: ** Returns the remaining ref count on the object ! 514: */ ! 515: ULONG OleDoc_Release (LPOLEDOC lpOleDoc) ! 516: { ! 517: ULONG cRef; ! 518: LPOUTLINEAPP lpOutlineApp = (LPOUTLINEAPP)g_lpApp; ! 519: LPOLEAPP lpOleApp = (LPOLEAPP)g_lpApp; ! 520: ! 521: OleDbgAssertSz (lpOleDoc->m_cRef > 0, "Release called with cRef == 0"); ! 522: ! 523: /********************************************************************* ! 524: ** OLE2NOTE: when the obj refcnt == 0, then destroy the object. ** ! 525: ** otherwise the object is still in use. ** ! 526: *********************************************************************/ ! 527: ! 528: cRef = --lpOleDoc->m_cRef; ! 529: ! 530: OleDbgOutRefCnt4( ! 531: "OleDoc_Release: cRef--\r\n", lpOleDoc, cRef); ! 532: ! 533: if (cRef == 0) ! 534: OutlineDoc_Destroy((LPOUTLINEDOC)lpOleDoc); ! 535: ! 536: return cRef; ! 537: } ! 538: ! 539: ! 540: /* OleDoc_QueryInterface ! 541: ** --------------------- ! 542: ** ! 543: ** Retrieve a pointer to an interface on the document object. ! 544: ** ! 545: ** OLE2NOTE: this function will AddRef the ref cnt of the object. ! 546: ** ! 547: ** Returns S_OK if interface is successfully retrieved. ! 548: ** S_FALSE if the interface is not supported ! 549: */ ! 550: HRESULT OleDoc_QueryInterface( ! 551: LPOLEDOC lpOleDoc, ! 552: REFIID riid, ! 553: LPVOID FAR* lplpvObj ! 554: ) ! 555: { ! 556: LPOUTLINEDOC lpOutlineDoc = (LPOUTLINEDOC)lpOleDoc; ! 557: SCODE sc = E_NOINTERFACE; ! 558: ! 559: /* OLE2NOTE: we must make sure to set all out ptr parameters to NULL. */ ! 560: *lplpvObj = NULL; ! 561: ! 562: if (IsEqualIID(riid, &IID_IUnknown)) { ! 563: OleDbgOut4("OleDoc_QueryInterface: IUnknown* RETURNED\r\n"); ! 564: ! 565: *lplpvObj = (LPVOID) &lpOleDoc->m_Unknown; ! 566: OleDoc_AddRef(lpOleDoc); ! 567: sc = S_OK; ! 568: } ! 569: else if(lpOutlineDoc->m_fDataTransferDoc ! 570: && IsEqualIID(riid, &IID_IDataObject)) { ! 571: OleDbgOut4("OleDoc_QueryInterface: IDataObject* RETURNED\r\n"); ! 572: ! 573: *lplpvObj = (LPVOID) &lpOleDoc->m_DataObject; ! 574: OleDoc_AddRef(lpOleDoc); ! 575: sc = S_OK; ! 576: } ! 577: ! 578: #if defined( USE_DRAGDROP ) ! 579: ! 580: /* DropSource is only needed on a DataTransferDoc */ ! 581: else if(lpOutlineDoc->m_fDataTransferDoc ! 582: && IsEqualIID(riid, &IID_IDropSource)) { ! 583: ! 584: OleDbgOut4("OleDoc_QueryInterface: IDropSource* RETURNED\r\n"); ! 585: ! 586: *lplpvObj = (LPVOID) &lpOleDoc->m_DropSource; ! 587: OleDoc_AddRef(lpOleDoc); ! 588: sc = S_OK; ! 589: } ! 590: #endif ! 591: ! 592: /* OLE2NOTE: if this document is a DataTransferDocument used to ! 593: ** support a clipboard or drag/drop operation, then it should ! 594: ** only expose IUnknown, IDataObject, and IDropSource ! 595: ** interfaces. if the document is a normal user document, then ! 596: ** we will also continue to consider our other interfaces. ! 597: */ ! 598: if (lpOutlineDoc->m_fDataTransferDoc) ! 599: goto done; ! 600: ! 601: if(IsEqualIID(riid, &IID_IPersist) || IsEqualIID(riid, &IID_IPersistFile)) { ! 602: OleDbgOut4("OleDoc_QueryInterface: IPersistFile* RETURNED\r\n"); ! 603: ! 604: *lplpvObj = (LPVOID) &lpOleDoc->m_PersistFile; ! 605: OleDoc_AddRef(lpOleDoc); ! 606: sc = S_OK; ! 607: } ! 608: else if(IsEqualIID(riid, &IID_IOleItemContainer) || ! 609: IsEqualIID(riid, &IID_IOleContainer) || ! 610: IsEqualIID(riid, &IID_IParseDisplayName) ) { ! 611: OleDbgOut4("OleDoc_QueryInterface: IOleItemContainer* RETURNED\r\n"); ! 612: ! 613: *lplpvObj = (LPVOID) &lpOleDoc->m_OleItemContainer; ! 614: OleDoc_AddRef(lpOleDoc); ! 615: sc = S_OK; ! 616: } ! 617: ! 618: #if defined( USE_DRAGDROP ) ! 619: ! 620: else if(IsEqualIID(riid, &IID_IDropTarget)) { ! 621: OleDbgOut4("OleDoc_QueryInterface: IDropTarget* RETURNED\r\n"); ! 622: ! 623: *lplpvObj = (LPVOID) &lpOleDoc->m_DropTarget; ! 624: OleDoc_AddRef(lpOleDoc); ! 625: sc = S_OK; ! 626: } ! 627: #endif ! 628: ! 629: #if defined( OLE_CNTR ) && defined ( IID_IOleUILinkContainer ) ! 630: ! 631: else if (IsEqualIID(riid, &IID_IOleUILinkContainer)) { ! 632: OleDbgOut4("OleDoc_QueryInterface: IOleUILinkContainer* RETURNED\r\n"); ! 633: ! 634: *lplpvObj=(LPVOID)&((LPCONTAINERERDOC)lpOleDoc)->m_OleUILinkContainer; ! 635: OleDoc_AddRef(lpOleDoc); ! 636: sc = S_OK; ! 637: } ! 638: #endif ! 639: ! 640: #if defined( OLE_SERVER ) ! 641: ! 642: /* OLE2NOTE: if OLE server version, than also offer the server ! 643: ** specific interfaces: IOleObject and IPersistStorage. ! 644: */ ! 645: else if (IsEqualIID(riid, &IID_IOleObject)) { ! 646: OleDbgOut4("OleDoc_QueryInterface: IOleObject* RETURNED\r\n"); ! 647: ! 648: *lplpvObj = (LPVOID) &((LPSERVERDOC)lpOleDoc)->m_OleObject; ! 649: OleDoc_AddRef(lpOleDoc); ! 650: sc = S_OK; ! 651: } ! 652: else if(IsEqualIID(riid, &IID_IPersistStorage)) { ! 653: OleDbgOut4("OleDoc_QueryInterface: IPersistStorage* RETURNED\r\n"); ! 654: ! 655: *lplpvObj = (LPVOID) &((LPSERVERDOC)lpOleDoc)->m_PersistStorage; ! 656: OleDoc_AddRef(lpOleDoc); ! 657: sc = S_OK; ! 658: } ! 659: else if(IsEqualIID(riid, &IID_IDataObject)) { ! 660: OleDbgOut4("OleDoc_QueryInterface: IDataObject* RETURNED\r\n"); ! 661: ! 662: *lplpvObj = (LPVOID) &lpOleDoc->m_DataObject; ! 663: OleDoc_AddRef(lpOleDoc); ! 664: sc = S_OK; ! 665: } ! 666: ! 667: #if defined( SVR_TREATAS ) ! 668: else if(IsEqualIID(riid, &IID_IStdMarshalInfo)) { ! 669: OleDbgOut4("OleDoc_QueryInterface: IStdMarshalInfo* RETURNED\r\n"); ! 670: ! 671: *lplpvObj = (LPVOID) &((LPSERVERDOC)lpOleDoc)->m_StdMarshalInfo; ! 672: OleDoc_AddRef(lpOleDoc); ! 673: sc = S_OK; ! 674: } ! 675: #endif // SVR_TREATAS ! 676: ! 677: #if defined( INPLACE_SVR ) ! 678: else if (IsEqualIID(riid, &IID_IOleWindow) || ! 679: IsEqualIID(riid, &IID_IOleInPlaceObject)) { ! 680: OleDbgOut4("OleDoc_QueryInterface: IOleInPlaceObject* RETURNED\r\n"); ! 681: ! 682: *lplpvObj = (LPVOID) &((LPSERVERDOC)lpOleDoc)->m_OleInPlaceObject; ! 683: OleDoc_AddRef(lpOleDoc); ! 684: sc = S_OK; ! 685: } ! 686: #endif // INPLACE_SVR ! 687: #endif // OLE_SERVER ! 688: ! 689: done: ! 690: OleDbgQueryInterfaceMethod(*lplpvObj); ! 691: ! 692: return ResultFromScode(sc); ! 693: } ! 694: ! 695: ! 696: /* OleDoc_Close ! 697: * ------------ ! 698: * ! 699: * Close the document. ! 700: * This functions performs the actions that are in common to all ! 701: * document types which derive from OleDoc (eg. ContainerDoc and ! 702: * ServerDoc) which are required to close a document. ! 703: * ! 704: * Returns: ! 705: * FALSE -- user canceled the closing of the doc. ! 706: * TRUE -- the doc was successfully closed ! 707: */ ! 708: ! 709: BOOL OleDoc_Close(LPOLEDOC lpOleDoc, DWORD dwSaveOption) ! 710: { ! 711: LPOLEAPP lpOleApp = (LPOLEAPP)g_lpApp; ! 712: LPOUTLINEAPP lpOutlineApp = (LPOUTLINEAPP)g_lpApp; ! 713: LPOLEDOC lpClipboardDoc; ! 714: LPLINELIST lpLL = (LPLINELIST)&((LPOUTLINEDOC)lpOleDoc)->m_LineList; ! 715: ! 716: if (! lpOleDoc) ! 717: return TRUE; // active doc's are already destroyed ! 718: ! 719: if (lpOleDoc->m_fObjIsClosing) ! 720: return TRUE; // Closing is already in progress ! 721: ! 722: OLEDBG_BEGIN3("OleDoc_Close\r\n") ! 723: ! 724: if (! OutlineDoc_CheckSaveChanges((LPOUTLINEDOC)lpOleDoc, dwSaveOption)) { ! 725: OLEDBG_END3 ! 726: return FALSE; // cancel closing the doc ! 727: } ! 728: ! 729: lpOleDoc->m_fObjIsClosing = TRUE; // guard against recursive call ! 730: ! 731: /* OLE2NOTE: in order to have a stable app and doc during the ! 732: ** process of closing, we intially AddRef the App and Doc ref ! 733: ** cnts and later Release them. These initial AddRefs are ! 734: ** artificial; they simply guarantee that these objects do not ! 735: ** get destroyed until the end of this routine. ! 736: */ ! 737: OleApp_AddRef(lpOleApp); ! 738: OleDoc_AddRef(lpOleDoc); ! 739: ! 740: #if defined( OLE_CNTR ) ! 741: { ! 742: LPCONTAINERDOC lpContainerDoc = (LPCONTAINERDOC)lpOleDoc; ! 743: ! 744: /* OLE2NOTE: force all OLE objects to close. this forces all ! 745: ** OLE object to transition from running to loaded. we can ! 746: ** NOT exit if any embeddings are still running. ! 747: ** if an object can't be closed then we will abort closing ! 748: ** our document. ! 749: */ ! 750: if (! ContainerDoc_CloseAllOleObjects(lpContainerDoc)) { ! 751: OleDoc_Release(lpOleDoc); // release artificial AddRef above ! 752: OleApp_Release(lpOleApp); // release artificial AddRef above ! 753: lpOleDoc->m_fObjIsClosing = FALSE; // guard against recursive call ! 754: ! 755: OLEDBG_END3 ! 756: return FALSE; ! 757: } ! 758: } ! 759: #endif ! 760: ! 761: #if defined( INPLACE_SVR ) ! 762: /* OLE2NOTE: if the server is currently in-place active we must ! 763: ** deactivate it now before closing ! 764: */ ! 765: ServerDoc_DoInPlaceDeactivate((LPSERVERDOC)lpOleDoc); ! 766: #endif ! 767: ! 768: /* OLE2NOTE: if this document is the source of data for the ! 769: ** clipboard, then flush the clipboard. it is important to flush ! 770: ** the clipboard BEFORE calling sending any notifications to ! 771: ** clients (eg. IOleClientSite::OnShowWindow(FALSE)) which could ! 772: ** give them a chance to run and try to get our clipboard data ! 773: ** object that we want to destroy. (eg. our app tries to ! 774: ** update the paste button of the toolbar when ! 775: ** WM_ACTIVATEAPP is received.) ! 776: */ ! 777: lpClipboardDoc = (LPOLEDOC)lpOutlineApp->m_lpClipboardDoc; ! 778: if (lpClipboardDoc && ! 779: lpClipboardDoc->m_lpSrcDocOfCopy == lpOleDoc) { ! 780: OleApp_FlushClipboard(lpOleApp); ! 781: } ! 782: ! 783: /* OLE2NOTE: Revoke the object from the Running Object Table. it is ! 784: ** best if the object is revoke prior to calling ! 785: ** COLockObjectExternal(FALSE,TRUE) which is called when the ! 786: ** document window is hidden from the user. ! 787: */ ! 788: OLEDBG_BEGIN3("OleStdRevokeAsRunning called\r\n") ! 789: OleStdRevokeAsRunning(&lpOleDoc->m_dwRegROT); ! 790: OLEDBG_END3 ! 791: ! 792: /* OLE2NOTE: if the user is in control of the document, the user ! 793: ** accounts for one refcnt on the document. Closing the ! 794: ** document is achieved by releasing the object on behalf of ! 795: ** the user. if the document is not referenced by any other ! 796: ** clients, then the document will also be destroyed. if it ! 797: ** is referenced by other clients, then it will remain until ! 798: ** they release it. it is important to hide the window and call ! 799: ** IOleClientSite::OnShowWindow(FALSE) BEFORE sending OnClose ! 800: ** notification. ! 801: */ ! 802: OleDoc_HideWindow(lpOleDoc, TRUE); ! 803: ! 804: #if defined( OLE_SERVER ) ! 805: { ! 806: LPSERVERDOC lpServerDoc = (LPSERVERDOC)lpOleDoc; ! 807: LPSERVERNAMETABLE lpServerNameTable = ! 808: (LPSERVERNAMETABLE)((LPOUTLINEDOC)lpOleDoc)->m_lpNameTable; ! 809: ! 810: /* OLE2NOTE: force all pseudo objects to close. this informs all ! 811: ** linking clients of pseudo objects to release their PseudoObj. ! 812: */ ! 813: ServerNameTable_CloseAllPseudoObjs(lpServerNameTable); ! 814: ! 815: /* OLE2NOTE: send last OnDataChange notification to clients ! 816: ** that have registered for data notifications when object ! 817: ** stops running (ADVF_DATAONSTOP), if the data in our ! 818: ** object has ever changed. it is best to only send this ! 819: ** notification if necessary. ! 820: */ ! 821: if (lpServerDoc->m_fSendDataOnStop ! 822: && lpServerDoc->m_lpDataAdviseHldr) { ! 823: ServerDoc_SendAdvise( ! 824: (LPSERVERDOC)lpOleDoc, ! 825: OLE_ONDATACHANGE, ! 826: NULL, /* lpmkDoc -- not relevant here */ ! 827: ADVF_DATAONSTOP ! 828: ); ! 829: ! 830: /* OLE2NOTE: we just sent the last data notification that we ! 831: ** need to send; release our DataAdviseHolder. we SHOULD be ! 832: ** the only one using it. ! 833: */ ! 834: ! 835: OleStdVerifyRelease( ! 836: (LPUNKNOWN)lpServerDoc->m_lpDataAdviseHldr, ! 837: "DataAdviseHldr not released properly" ! 838: ); ! 839: lpServerDoc->m_lpDataAdviseHldr = NULL; ! 840: } ! 841: ! 842: // OLE2NOTE: inform all of our linking clients that we are closing. ! 843: ! 844: ! 845: if (lpServerDoc->m_lpOleAdviseHldr) { ! 846: ServerDoc_SendAdvise( ! 847: (LPSERVERDOC)lpOleDoc, ! 848: OLE_ONCLOSE, ! 849: NULL, /* lpmkDoc -- not relevant here */ ! 850: 0 /* advf -- not relevant here */ ! 851: ); ! 852: ! 853: /* OLE2NOTE: OnClose is the last notification that we need to ! 854: ** send; release our OleAdviseHolder. we SHOULD be the only ! 855: ** one using it. this will make our destructor realize that ! 856: ** OnClose notification has already been sent. ! 857: */ ! 858: OleStdVerifyRelease( ! 859: (LPUNKNOWN)lpServerDoc->m_lpOleAdviseHldr, ! 860: "OleAdviseHldr not released properly" ! 861: ); ! 862: lpServerDoc->m_lpOleAdviseHldr = NULL; ! 863: } ! 864: ! 865: /* release our Container's ClientSite. */ ! 866: if(lpServerDoc->m_lpOleClientSite) { ! 867: OleStdRelease((LPUNKNOWN)lpServerDoc->m_lpOleClientSite); ! 868: lpServerDoc->m_lpOleClientSite = NULL; ! 869: } ! 870: } ! 871: #endif ! 872: ! 873: /* OLE2NOTE: this call forces all external connections to our ! 874: ** object to close down and therefore guarantees that we receive ! 875: ** all releases associated with those external connections. ! 876: */ ! 877: OLEDBG_BEGIN2("CoDisconnectObject(lpDoc) called\r\n") ! 878: CoDisconnectObject((LPUNKNOWN)&lpOleDoc->m_Unknown, 0); ! 879: OLEDBG_END2 ! 880: ! 881: OleDoc_Release(lpOleDoc); // release artificial AddRef above ! 882: OleApp_Release(lpOleApp); // release artificial AddRef above ! 883: ! 884: OLEDBG_END3 ! 885: return TRUE; ! 886: } ! 887: ! 888: ! 889: /* OleDoc_Destroy ! 890: * -------------- ! 891: * ! 892: * Free all OLE related resources that had been allocated for a document. ! 893: */ ! 894: void OleDoc_Destroy(LPOLEDOC lpOleDoc) ! 895: { ! 896: LPOUTLINEAPP lpOutlineApp = (LPOUTLINEAPP)g_lpApp; ! 897: LPOUTLINEDOC lpOutlineDoc = (LPOUTLINEDOC)lpOleDoc; ! 898: ! 899: if (lpOleDoc->m_fObjIsDestroying) ! 900: return; // Doc destruction is already in progress ! 901: ! 902: lpOleDoc->m_fObjIsDestroying = TRUE; // guard against recursive call ! 903: ! 904: /* OLE2NOTE: if the document destructor is called directly because ! 905: ** the object's refcnt went to 0 (ie. without OleDoc_Close first ! 906: ** being called), then we need to make sure that the document is ! 907: ** properly closed before destroying the object. this scenario ! 908: ** could arise during a silent-update of a link. calling ! 909: ** OleDoc_Close here guarantees that the clipboard will be ! 910: ** properly flushed, the doc's moniker will be properly revoked, ! 911: ** the document will be saved if necessary, etc. ! 912: */ ! 913: if (!lpOutlineDoc->m_fDataTransferDoc && !lpOleDoc->m_fObjIsClosing) ! 914: OleDoc_Close(lpOleDoc, OLECLOSE_SAVEIFDIRTY); ! 915: ! 916: #if defined( OLE_SERVER ) ! 917: { ! 918: LPSERVERDOC lpServerDoc = (LPSERVERDOC)lpOleDoc; ! 919: /* OLE2NOTE: perform processing specific for an OLE server */ ! 920: ! 921: #if defined( SVR_TREATAS ) ! 922: if (lpServerDoc->m_lpszTreatAsType) { ! 923: OleStdFreeString(lpServerDoc->m_lpszTreatAsType, NULL); ! 924: lpServerDoc->m_lpszTreatAsType = NULL; ! 925: } ! 926: #endif // SVR_TREATAS ! 927: ! 928: #if defined( INPLACE_SVR ) ! 929: if (IsWindow(lpServerDoc->m_hWndHatch)) ! 930: DestroyWindow(lpServerDoc->m_hWndHatch); ! 931: #endif // INPLACE_SVR ! 932: } ! 933: #endif // OLE_SERVER ! 934: ! 935: ! 936: #if defined( OLE_CNTR ) ! 937: { ! 938: LPCONTAINERDOC lpContainerDoc = (LPCONTAINERDOC)lpOleDoc; ! 939: /* OLE2NOTE: perform processing specific for an OLE container */ ! 940: ! 941: if (lpContainerDoc->m_lpStg) { ! 942: /* release our doc storage. */ ! 943: OleStdRelease((LPUNKNOWN)lpContainerDoc->m_lpStg); ! 944: lpContainerDoc->m_lpStg = NULL; ! 945: } ! 946: } ! 947: #endif // OLE_CNTR ! 948: ! 949: if (lpOleDoc->m_lpFileMoniker) { ! 950: OleStdRelease((LPUNKNOWN)lpOleDoc->m_lpFileMoniker); ! 951: lpOleDoc->m_lpFileMoniker = NULL; ! 952: } ! 953: ! 954: /***************************************************************** ! 955: ** OLE2NOTE: each document addref's the app object in order to ** ! 956: ** guarentee that the app does not shut down while the doc ** ! 957: ** is still open. since this doc is now destroyed, we will ** ! 958: ** release this refcnt now. if there are now more open ** ! 959: ** documents AND the app is not under the control of the ** ! 960: ** user (ie. launched by OLE) then the app will revoke its ** ! 961: ** ClassFactory. if there are no more references to the ** ! 962: ** ClassFactory after it is revoked, then the app will shut ** ! 963: ** down. this whole procedure is triggered by calling ** ! 964: ** OutlineApp_DocUnlockApp. ** ! 965: *****************************************************************/ ! 966: ! 967: OutlineApp_DocUnlockApp(lpOutlineApp, lpOutlineDoc); ! 968: } ! 969: ! 970: ! 971: /* OleDoc_SetUpdateEditMenuFlag ! 972: * ---------------------------- ! 973: * ! 974: * Purpose: ! 975: * Set/clear the UpdateEditMenuFlag in OleDoc. ! 976: * ! 977: * Parameters: ! 978: * fUpdate new value of the flag ! 979: * ! 980: * Returns: ! 981: */ ! 982: void OleDoc_SetUpdateEditMenuFlag(LPOLEDOC lpOleDoc, BOOL fUpdate) ! 983: { ! 984: if (!lpOleDoc) ! 985: return; ! 986: ! 987: lpOleDoc->m_fUpdateEditMenu = fUpdate; ! 988: } ! 989: ! 990: ! 991: /* OleDoc_GetUpdateEditMenuFlag ! 992: * ---------------------------- ! 993: * ! 994: * Purpose: ! 995: * Get the value of the UpdateEditMenuFlag in OleDoc ! 996: * ! 997: * Parameters: ! 998: * ! 999: * Returns: ! 1000: * value of the flag ! 1001: */ ! 1002: BOOL OleDoc_GetUpdateEditMenuFlag(LPOLEDOC lpOleDoc) ! 1003: { ! 1004: if (!lpOleDoc) ! 1005: return FALSE; ! 1006: ! 1007: return lpOleDoc->m_fUpdateEditMenu; ! 1008: } ! 1009: ! 1010: ! 1011: ! 1012: /************************************************************************* ! 1013: ** OleDoc::IUnknown interface implementation ! 1014: *************************************************************************/ ! 1015: ! 1016: STDMETHODIMP OleDoc_Unk_QueryInterface( ! 1017: LPUNKNOWN lpThis, ! 1018: REFIID riid, ! 1019: LPVOID FAR* lplpvObj ! 1020: ) ! 1021: { ! 1022: LPOLEDOC lpOleDoc = ((struct CDocUnknownImpl FAR*)lpThis)->lpOleDoc; ! 1023: ! 1024: return OleDoc_QueryInterface(lpOleDoc, riid, lplpvObj); ! 1025: } ! 1026: ! 1027: ! 1028: STDMETHODIMP_(ULONG) OleDoc_Unk_AddRef(LPUNKNOWN lpThis) ! 1029: { ! 1030: LPOLEDOC lpOleDoc = ((struct CDocUnknownImpl FAR*)lpThis)->lpOleDoc; ! 1031: ! 1032: OleDbgAddRefMethod(lpThis, "IUnknown"); ! 1033: ! 1034: return OleDoc_AddRef(lpOleDoc); ! 1035: } ! 1036: ! 1037: ! 1038: STDMETHODIMP_(ULONG) OleDoc_Unk_Release (LPUNKNOWN lpThis) ! 1039: { ! 1040: LPOLEDOC lpOleDoc = ((struct CDocUnknownImpl FAR*)lpThis)->lpOleDoc; ! 1041: ! 1042: OleDbgReleaseMethod(lpThis, "IUnknown"); ! 1043: ! 1044: return OleDoc_Release(lpOleDoc); ! 1045: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.