![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to svrpsobj.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 svrpsobj.c CVS log | Up to [WindowsNT SDKs] / mstools / ole20 / samples / outline |
1.1 ! root 1: /************************************************************************* ! 2: ** ! 3: ** OLE 2 Server Sample Code ! 4: ** ! 5: ** svrpsobj.c ! 6: ** ! 7: ** This file contains all PseudoObj methods and related support ! 8: ** functions. ! 9: ** ! 10: ** (c) Copyright Microsoft Corp. 1992 - 1993 All Rights Reserved ! 11: ** ! 12: *************************************************************************/ ! 13: ! 14: ! 15: #include "outline.h" ! 16: #include <geticon.h> ! 17: ! 18: OLEDBGDATA ! 19: ! 20: extern LPOUTLINEAPP g_lpApp; ! 21: extern IUnknownVtbl g_PseudoObj_UnknownVtbl; ! 22: extern IOleObjectVtbl g_PseudoObj_OleObjectVtbl; ! 23: extern IDataObjectVtbl g_PseudoObj_DataObjectVtbl; ! 24: ! 25: ! 26: /* PseudoObj_Init ! 27: ** -------------- ! 28: ** Initialize fields in a newly constructed PseudoObj. ! 29: ** NOTE: ref cnt of PseudoObj initialized to 0 ! 30: */ ! 31: void PseudoObj_Init( ! 32: LPPSEUDOOBJ lpPseudoObj, ! 33: LPSERVERNAME lpServerName, ! 34: LPSERVERDOC lpServerDoc ! 35: ) ! 36: { ! 37: OleDbgOut2("++PseudoObj Created\r\n"); ! 38: ! 39: lpPseudoObj->m_cRef = 0; ! 40: lpPseudoObj->m_lpName = lpServerName; ! 41: lpPseudoObj->m_lpDoc = lpServerDoc; ! 42: lpPseudoObj->m_lpOleAdviseHldr = NULL; ! 43: lpPseudoObj->m_lpDataAdviseHldr = NULL; ! 44: lpPseudoObj->m_fObjIsClosing = FALSE; ! 45: ! 46: INIT_INTERFACEIMPL( ! 47: &lpPseudoObj->m_Unknown, ! 48: &g_PseudoObj_UnknownVtbl, ! 49: lpPseudoObj ! 50: ); ! 51: ! 52: INIT_INTERFACEIMPL( ! 53: &lpPseudoObj->m_OleObject, ! 54: &g_PseudoObj_OleObjectVtbl, ! 55: lpPseudoObj ! 56: ); ! 57: ! 58: INIT_INTERFACEIMPL( ! 59: &lpPseudoObj->m_DataObject, ! 60: &g_PseudoObj_DataObjectVtbl, ! 61: lpPseudoObj ! 62: ); ! 63: ! 64: /* OLE2NOTE: Increment the refcnt of the Doc on behalf of the ! 65: ** PseudoObj. the Document should not shut down unless all ! 66: ** pseudo objects are closed. when a pseudo object is destroyed, ! 67: ** it calls ServerDoc_PseudoObjUnlockDoc to release this hold on ! 68: ** the document. ! 69: */ ! 70: ServerDoc_PseudoObjLockDoc(lpServerDoc); ! 71: } ! 72: ! 73: ! 74: ! 75: /* PseudoObj_AddRef ! 76: ** ---------------- ! 77: ** ! 78: ** increment the ref count of the PseudoObj object. ! 79: ** ! 80: ** Returns the new ref count on the object ! 81: */ ! 82: ULONG PseudoObj_AddRef(LPPSEUDOOBJ lpPseudoObj) ! 83: { ! 84: ++lpPseudoObj->m_cRef; ! 85: ! 86: OleDbgOutRefCnt4( ! 87: "PseudoObj_AddRef: cRef++\r\n", ! 88: lpPseudoObj, ! 89: lpPseudoObj->m_cRef ! 90: ); ! 91: return lpPseudoObj->m_cRef; ! 92: } ! 93: ! 94: ! 95: /* PseudoObj_Release ! 96: ** ----------------- ! 97: ** ! 98: ** decrement the ref count of the PseudoObj object. ! 99: ** if the ref count goes to 0, then the PseudoObj is destroyed. ! 100: ** ! 101: ** Returns the remaining ref count on the object ! 102: */ ! 103: ULONG PseudoObj_Release(LPPSEUDOOBJ lpPseudoObj) ! 104: { ! 105: ULONG cRef; ! 106: ! 107: OleDbgAssertSz(lpPseudoObj->m_cRef > 0,"Release called with cRef == 0"); ! 108: ! 109: /********************************************************************* ! 110: ** OLE2NOTE: when the obj refcnt == 0, then destroy the object. ** ! 111: ** otherwise the object is still in use. ** ! 112: *********************************************************************/ ! 113: ! 114: cRef = --lpPseudoObj->m_cRef; ! 115: ! 116: OleDbgOutRefCnt4( ! 117: "PseudoObj_Release: cRef--\r\n", lpPseudoObj,cRef); ! 118: ! 119: if (cRef == 0) ! 120: PseudoObj_Destroy(lpPseudoObj); ! 121: ! 122: return cRef; ! 123: } ! 124: ! 125: ! 126: /* PseudoObj_QueryInterface ! 127: ** ------------------------ ! 128: ** ! 129: ** Retrieve a pointer to an interface on the PseudoObj object. ! 130: ** ! 131: ** Returns S_OK if interface is successfully retrieved. ! 132: ** E_NOINTERFACE if the interface is not supported ! 133: */ ! 134: HRESULT PseudoObj_QueryInterface( ! 135: LPPSEUDOOBJ lpPseudoObj, ! 136: REFIID riid, ! 137: LPVOID FAR* lplpvObj ! 138: ) ! 139: { ! 140: SCODE sc = E_NOINTERFACE; ! 141: ! 142: /* OLE2NOTE: we must make sure to set all out ptr parameters to NULL. */ ! 143: *lplpvObj = NULL; ! 144: ! 145: if (IsEqualIID(riid, &IID_IUnknown)) { ! 146: OleDbgOut4("PseudoObj_QueryInterface: IUnknown* RETURNED\r\n"); ! 147: ! 148: *lplpvObj = (LPVOID) &lpPseudoObj->m_Unknown; ! 149: PseudoObj_AddRef(lpPseudoObj); ! 150: sc = S_OK; ! 151: } ! 152: else if (IsEqualIID(riid, &IID_IOleObject)) { ! 153: OleDbgOut4("PseudoObj_QueryInterface: IOleObject* RETURNED\r\n"); ! 154: ! 155: *lplpvObj = (LPVOID) &lpPseudoObj->m_OleObject; ! 156: PseudoObj_AddRef(lpPseudoObj); ! 157: sc = S_OK; ! 158: } ! 159: else if (IsEqualIID(riid, &IID_IDataObject)) { ! 160: OleDbgOut4("PseudoObj_QueryInterface: IDataObject* RETURNED\r\n"); ! 161: ! 162: *lplpvObj = (LPVOID) &lpPseudoObj->m_DataObject; ! 163: PseudoObj_AddRef(lpPseudoObj); ! 164: sc = S_OK; ! 165: } ! 166: ! 167: OleDbgQueryInterfaceMethod(*lplpvObj); ! 168: ! 169: return ResultFromScode(sc); ! 170: } ! 171: ! 172: ! 173: /* PseudoObj_Close ! 174: * --------------- ! 175: * ! 176: * Close the pseudo object. Force all external connections to close ! 177: * down. This causes link clients to release this PseudoObj. when ! 178: * the refcount actually reaches 0, then the PseudoObj will be ! 179: * destroyed. ! 180: * ! 181: * Returns: ! 182: * FALSE -- user canceled the closing of the doc. ! 183: * TRUE -- the doc was successfully closed ! 184: */ ! 185: ! 186: BOOL PseudoObj_Close(LPPSEUDOOBJ lpPseudoObj) ! 187: { ! 188: LPSERVERDOC lpServerDoc = (LPSERVERDOC)lpPseudoObj->m_lpDoc; ! 189: LPSERVERNAME lpServerName = (LPSERVERNAME)lpPseudoObj->m_lpName; ! 190: LPOLEAPP lpOleApp = (LPOLEAPP)g_lpApp; ! 191: LPOLEDOC lpOleDoc = (LPOLEDOC)lpServerDoc; ! 192: BOOL fStatus; ! 193: ! 194: if (lpPseudoObj->m_fObjIsClosing) ! 195: return TRUE; // Closing is already in progress ! 196: ! 197: lpPseudoObj->m_fObjIsClosing = TRUE; // guard against recursive call ! 198: ! 199: OLEDBG_BEGIN3("PseudoObj_Close\r\n") ! 200: ! 201: /* OLE2NOTE: in order to have a stable App, Doc, AND pseudo object ! 202: ** during the process of closing, we intially AddRef the App, ! 203: ** Doc, and PseudoObj ref counts and later Release them. These ! 204: ** initial AddRefs are artificial; they are simply done to ! 205: ** guarantee that these objects do not get destroyed until the ! 206: ** end of this routine. ! 207: */ ! 208: OleApp_AddRef(lpOleApp); ! 209: OleDoc_AddRef(lpOleDoc); ! 210: PseudoObj_AddRef(lpPseudoObj); ! 211: ! 212: if (lpPseudoObj->m_lpDataAdviseHldr) { ! 213: /* OLE2NOTE: send last OnDataChange notification to clients ! 214: ** that have registered for data notifications when object ! 215: ** stops running (ADVF_DATAONSTOP) ! 216: */ ! 217: PseudoObj_SendAdvise( ! 218: lpPseudoObj, ! 219: OLE_ONDATACHANGE, ! 220: NULL, /* lpmkObj -- not relevant here */ ! 221: ADVF_DATAONSTOP ! 222: ); ! 223: ! 224: /* OLE2NOTE: we just sent the last data notification that we ! 225: ** need to send; release our DataAdviseHolder. we SHOULD be ! 226: ** the only one using it. ! 227: */ ! 228: OleStdVerifyRelease( ! 229: (LPUNKNOWN)lpPseudoObj->m_lpDataAdviseHldr, ! 230: "DataAdviseHldr not released properly" ! 231: ); ! 232: lpPseudoObj->m_lpDataAdviseHldr = NULL; ! 233: } ! 234: ! 235: if (lpPseudoObj->m_lpOleAdviseHldr) { ! 236: // OLE2NOTE: inform all of our linking clients that we are closing. ! 237: PseudoObj_SendAdvise( ! 238: lpPseudoObj, ! 239: OLE_ONCLOSE, ! 240: NULL, /* lpmkObj -- not relevant here */ ! 241: 0 /* advf -- not relevant here */ ! 242: ); ! 243: ! 244: /* OLE2NOTE: OnClose is the last notification that we need to ! 245: ** send; release our OleAdviseHolder. we SHOULD be the only ! 246: ** one using it. this will make our destructor realize that ! 247: ** OnClose notification has already been sent. ! 248: */ ! 249: OleStdVerifyRelease( ! 250: (LPUNKNOWN)lpPseudoObj->m_lpOleAdviseHldr, ! 251: "OleAdviseHldr not released properly" ! 252: ); ! 253: lpPseudoObj->m_lpOleAdviseHldr = NULL; ! 254: } ! 255: ! 256: /* OLE2NOTE: this call forces all external connections to our ! 257: ** object to close down and therefore guarantees that we receive ! 258: ** all releases associated with those external connections. ! 259: */ ! 260: OLEDBG_BEGIN2("CoDisconnectObject called\r\n") ! 261: CoDisconnectObject((LPUNKNOWN)&lpPseudoObj->m_Unknown, 0); ! 262: OLEDBG_END2 ! 263: ! 264: PseudoObj_Release(lpPseudoObj); // release artificial AddRef above ! 265: OleDoc_Release(lpOleDoc); // release artificial AddRef above ! 266: OleApp_Release(lpOleApp); // release artificial AddRef above ! 267: ! 268: OLEDBG_END3 ! 269: return fStatus; ! 270: } ! 271: ! 272: ! 273: /* PseudoObj_Destroy ! 274: ** ----------------- ! 275: ** Destroy (Free) the memory used by a PseudoObj structure. ! 276: ** This function is called when the ref count of the PseudoObj goes ! 277: ** to zero. the ref cnt goes to zero after PseudoObj_Delete forces ! 278: ** the OleObject to unload and release its pointers to the ! 279: ** PseudoObj IOleClientSite and IAdviseSink interfaces. ! 280: */ ! 281: ! 282: void PseudoObj_Destroy(LPPSEUDOOBJ lpPseudoObj) ! 283: { ! 284: LPSERVERDOC lpServerDoc = lpPseudoObj->m_lpDoc; ! 285: LPOLEAPP lpOleApp = (LPOLEAPP)g_lpApp; ! 286: LPOLEDOC lpOleDoc = (LPOLEDOC)lpServerDoc; ! 287: ! 288: OLEDBG_BEGIN3("PseudoObj_Destroy\r\n") ! 289: ! 290: /* OLE2NOTE: in order to have a stable App, Doc, AND pseudo object ! 291: ** during the process of closing, we intially AddRef the App, ! 292: ** Doc ref counts and later Release them. These ! 293: ** initial AddRefs are artificial; they are simply done to ! 294: ** guarantee that these objects do not get destroyed until the ! 295: ** end of this routine. ! 296: */ ! 297: OleApp_AddRef(lpOleApp); ! 298: OleDoc_AddRef(lpOleDoc); ! 299: ! 300: /****************************************************************** ! 301: ** OLE2NOTE: we no longer need the advise and enum holder objects, ! 302: ** so release them. ! 303: ******************************************************************/ ! 304: ! 305: if (lpPseudoObj->m_lpDataAdviseHldr) { ! 306: /* release DataAdviseHldr; we SHOULD be the only one using it. */ ! 307: OleStdVerifyRelease( ! 308: (LPUNKNOWN)lpPseudoObj->m_lpDataAdviseHldr, ! 309: "DataAdviseHldr not released properly" ! 310: ); ! 311: lpPseudoObj->m_lpDataAdviseHldr = NULL; ! 312: } ! 313: ! 314: if (lpPseudoObj->m_lpOleAdviseHldr) { ! 315: /* release OleAdviseHldr; we SHOULD be the only one using it. */ ! 316: OleStdVerifyRelease( ! 317: (LPUNKNOWN)lpPseudoObj->m_lpOleAdviseHldr, ! 318: "OleAdviseHldr not released properly" ! 319: ); ! 320: lpPseudoObj->m_lpOleAdviseHldr = NULL; ! 321: } ! 322: ! 323: /* forget the pointer to destroyed PseudoObj in NameTable */ ! 324: if (lpPseudoObj->m_lpName) ! 325: lpPseudoObj->m_lpName->m_lpPseudoObj = NULL; ! 326: ! 327: /* OLE2NOTE: release the lock on the Doc held on behalf of the ! 328: ** PseudoObj. the Document should not shut down unless all ! 329: ** pseudo objects are closed. when a pseudo object is first ! 330: ** created, it calls ServerDoc_PseudoObjLockDoc to guarantee ! 331: ** that the document stays alive (called from PseudoObj_Init). ! 332: */ ! 333: ServerDoc_PseudoObjUnlockDoc(lpServerDoc, lpPseudoObj); ! 334: ! 335: Delete(lpPseudoObj); // Free the memory for the structure itself ! 336: ! 337: OleDoc_Release(lpOleDoc); // release artificial AddRef above ! 338: OleApp_Release(lpOleApp); // release artificial AddRef above ! 339: ! 340: OLEDBG_END3 ! 341: } ! 342: ! 343: ! 344: /* PseudoObj_GetSel ! 345: ** ---------------- ! 346: ** Return the line range for the pseudo object ! 347: */ ! 348: void PseudoObj_GetSel(LPPSEUDOOBJ lpPseudoObj, LPLINERANGE lplrSel) ! 349: { ! 350: LPOUTLINENAME lpOutlineName = (LPOUTLINENAME)lpPseudoObj->m_lpName; ! 351: lplrSel->m_nStartLine = lpOutlineName->m_nStartLine; ! 352: lplrSel->m_nEndLine = lpOutlineName->m_nEndLine; ! 353: } ! 354: ! 355: ! 356: /* PseudoObj_GetExtent ! 357: * ------------------- ! 358: * ! 359: * Get the extent (width, height) of the entire document. ! 360: */ ! 361: void PseudoObj_GetExtent(LPPSEUDOOBJ lpPseudoObj, LPSIZEL lpsizel) ! 362: { ! 363: LPOLEDOC lpOleDoc = (LPOLEDOC)lpPseudoObj->m_lpDoc; ! 364: LPLINELIST lpLL = (LPLINELIST)&((LPOUTLINEDOC)lpOleDoc)->m_LineList; ! 365: LINERANGE lrSel; ! 366: ! 367: PseudoObj_GetSel(lpPseudoObj, (LPLINERANGE)&lrSel); ! 368: ! 369: LineList_CalcSelExtentInHimetric(lpLL, (LPLINERANGE)&lrSel, lpsizel); ! 370: } ! 371: ! 372: ! 373: /* PseudoObj_SendAdvise ! 374: * -------------------- ! 375: * ! 376: * This function sends an advise notification on behalf of a specific ! 377: * doc object to all its clients. ! 378: */ ! 379: void PseudoObj_SendAdvise( ! 380: LPPSEUDOOBJ lpPseudoObj, ! 381: WORD wAdvise, ! 382: LPMONIKER lpmkObj, ! 383: DWORD dwAdvf ! 384: ) ! 385: { ! 386: LPOUTLINEDOC lpOutlineDoc = (LPOUTLINEDOC)lpPseudoObj->m_lpDoc; ! 387: ! 388: switch (wAdvise) { ! 389: ! 390: case OLE_ONDATACHANGE: ! 391: ! 392: // inform clients that the data of the object has changed ! 393: ! 394: if (lpOutlineDoc->m_nDisableDraw == 0) { ! 395: /* drawing is currently enabled. inform clients that ! 396: ** the data of the object has changed ! 397: */ ! 398: ! 399: lpPseudoObj->m_fDataChanged = FALSE; ! 400: if (lpPseudoObj->m_lpDataAdviseHldr) { ! 401: ! 402: OLEDBG_BEGIN2( ! 403: "IDataAdviseHolder::SendOnDataChange called\r\n" ! 404: ); ! 405: lpPseudoObj->m_lpDataAdviseHldr->lpVtbl->SendOnDataChange( ! 406: lpPseudoObj->m_lpDataAdviseHldr, ! 407: (LPDATAOBJECT)&lpPseudoObj->m_DataObject, ! 408: 0, ! 409: dwAdvf ! 410: ); ! 411: OLEDBG_END2 ! 412: } ! 413: ! 414: } else { ! 415: /* drawing is currently disabled. do not send ! 416: ** notifications until drawing is re-enabled. ! 417: */ ! 418: lpPseudoObj->m_fDataChanged = TRUE; ! 419: } ! 420: break; ! 421: ! 422: case OLE_ONCLOSE: ! 423: ! 424: // inform clients that the object is shutting down ! 425: ! 426: if (lpPseudoObj->m_lpOleAdviseHldr) { ! 427: ! 428: OLEDBG_BEGIN2("IOleAdviseHolder::SendOnClose called\r\n"); ! 429: lpPseudoObj->m_lpOleAdviseHldr->lpVtbl->SendOnClose( ! 430: lpPseudoObj->m_lpOleAdviseHldr ! 431: ); ! 432: OLEDBG_END2 ! 433: } ! 434: break; ! 435: ! 436: case OLE_ONSAVE: ! 437: ! 438: // inform clients that the object has been saved ! 439: ! 440: if (lpPseudoObj->m_lpOleAdviseHldr) { ! 441: ! 442: OLEDBG_BEGIN2("IOleAdviseHolder::SendOnClose called\r\n"); ! 443: lpPseudoObj->m_lpOleAdviseHldr->lpVtbl->SendOnSave( ! 444: lpPseudoObj->m_lpOleAdviseHldr ! 445: ); ! 446: OLEDBG_END2 ! 447: } ! 448: break; ! 449: ! 450: case OLE_ONRENAME: ! 451: ! 452: // inform clients that the object's name has changed ! 453: if (lpmkObj && lpPseudoObj->m_lpOleAdviseHldr) { ! 454: ! 455: OLEDBG_BEGIN2("IOleAdviseHolder::SendOnRename called\r\n"); ! 456: if (lpPseudoObj->m_lpOleAdviseHldr) ! 457: lpPseudoObj->m_lpOleAdviseHldr->lpVtbl->SendOnRename( ! 458: lpPseudoObj->m_lpOleAdviseHldr, ! 459: lpmkObj ! 460: ); ! 461: OLEDBG_END2 ! 462: } ! 463: break; ! 464: } ! 465: } ! 466: ! 467: ! 468: /* PseudoObj_GetFullMoniker ! 469: * ------------------------ ! 470: * ! 471: * Returns the Full, absolute Moniker which identifies this pseudo object. ! 472: */ ! 473: LPMONIKER PseudoObj_GetFullMoniker(LPPSEUDOOBJ lpPseudoObj, LPMONIKER lpmkDoc) ! 474: { ! 475: LPOUTLINENAME lpOutlineName = (LPOUTLINENAME)lpPseudoObj->m_lpName; ! 476: LPMONIKER lpmkItem = NULL; ! 477: LPMONIKER lpmkPseudoObj = NULL; ! 478: ! 479: if (lpmkDoc != NULL) { ! 480: CreateItemMoniker(OLESTDDELIM,lpOutlineName->m_szName,&lpmkItem); ! 481: ! 482: /* OLE2NOTE: create an absolute moniker which identifies the ! 483: ** pseudo object. this moniker is created as a composite of ! 484: ** the absolute moniker for the entire document appended ! 485: ** with an item moniker which identifies the selection of ! 486: ** the pseudo object relative to the document. ! 487: */ ! 488: CreateGenericComposite(lpmkDoc, lpmkItem, &lpmkPseudoObj); ! 489: ! 490: if (lpmkItem) ! 491: OleStdRelease((LPUNKNOWN)lpmkItem); ! 492: ! 493: return lpmkPseudoObj; ! 494: } else { ! 495: return NULL; ! 496: } ! 497: } ! 498: ! 499: ! 500: /************************************************************************* ! 501: ** PseudoObj::IUnknown interface implementation ! 502: *************************************************************************/ ! 503: ! 504: STDMETHODIMP PseudoObj_Unk_QueryInterface( ! 505: LPUNKNOWN lpThis, ! 506: REFIID riid, ! 507: LPVOID FAR* lplpvObj ! 508: ) ! 509: { ! 510: LPPSEUDOOBJ lpPseudoObj = ! 511: ((struct CPseudoObjUnknownImpl FAR*)lpThis)->lpPseudoObj; ! 512: ! 513: return PseudoObj_QueryInterface(lpPseudoObj, riid, lplpvObj); ! 514: } ! 515: ! 516: ! 517: STDMETHODIMP_(ULONG) PseudoObj_Unk_AddRef(LPUNKNOWN lpThis) ! 518: { ! 519: LPPSEUDOOBJ lpPseudoObj = ! 520: ((struct CPseudoObjUnknownImpl FAR*)lpThis)->lpPseudoObj; ! 521: ! 522: OleDbgAddRefMethod(lpThis, "IUnknown"); ! 523: ! 524: return PseudoObj_AddRef(lpPseudoObj); ! 525: } ! 526: ! 527: ! 528: STDMETHODIMP_(ULONG) PseudoObj_Unk_Release (LPUNKNOWN lpThis) ! 529: { ! 530: LPPSEUDOOBJ lpPseudoObj = ! 531: ((struct CPseudoObjUnknownImpl FAR*)lpThis)->lpPseudoObj; ! 532: ! 533: OleDbgReleaseMethod(lpThis, "IUnknown"); ! 534: ! 535: return PseudoObj_Release(lpPseudoObj); ! 536: } ! 537: ! 538: ! 539: /************************************************************************* ! 540: ** PseudoObj::IOleObject interface implementation ! 541: *************************************************************************/ ! 542: ! 543: STDMETHODIMP PseudoObj_OleObj_QueryInterface( ! 544: LPOLEOBJECT lpThis, ! 545: REFIID riid, ! 546: LPVOID FAR* lplpvObj ! 547: ) ! 548: { ! 549: LPPSEUDOOBJ lpPseudoObj = ! 550: ((struct CPseudoObjOleObjectImpl FAR*)lpThis)->lpPseudoObj; ! 551: ! 552: return PseudoObj_QueryInterface(lpPseudoObj, riid, lplpvObj); ! 553: } ! 554: ! 555: ! 556: STDMETHODIMP_(ULONG) PseudoObj_OleObj_AddRef(LPOLEOBJECT lpThis) ! 557: { ! 558: LPPSEUDOOBJ lpPseudoObj = ! 559: ((struct CPseudoObjOleObjectImpl FAR*)lpThis)->lpPseudoObj; ! 560: ! 561: OleDbgAddRefMethod(lpThis, "IOleObject"); ! 562: ! 563: return PseudoObj_AddRef((LPPSEUDOOBJ)lpPseudoObj); ! 564: } ! 565: ! 566: ! 567: STDMETHODIMP_(ULONG) PseudoObj_OleObj_Release(LPOLEOBJECT lpThis) ! 568: { ! 569: LPPSEUDOOBJ lpPseudoObj = ! 570: ((struct CPseudoObjOleObjectImpl FAR*)lpThis)->lpPseudoObj; ! 571: ! 572: OleDbgReleaseMethod(lpThis, "IOleObject"); ! 573: ! 574: return PseudoObj_Release((LPPSEUDOOBJ)lpPseudoObj); ! 575: } ! 576: ! 577: ! 578: STDMETHODIMP PseudoObj_OleObj_SetClientSite( ! 579: LPOLEOBJECT lpThis, ! 580: LPOLECLIENTSITE lpClientSite ! 581: ) ! 582: { ! 583: OleDbgOut2("PseudoObj_OleObj_SetClientSite\r\n"); ! 584: ! 585: // OLE2NOTE: a pseudo object does NOT support SetExtent ! 586: ! 587: return ResultFromScode(E_FAIL); ! 588: } ! 589: ! 590: ! 591: STDMETHODIMP PseudoObj_OleObj_GetClientSite( ! 592: LPOLEOBJECT lpThis, ! 593: LPOLECLIENTSITE FAR* lplpClientSite ! 594: ) ! 595: { ! 596: OleDbgOut2("PseudoObj_OleObj_GetClientSite\r\n"); ! 597: ! 598: *lplpClientSite = NULL; ! 599: ! 600: // OLE2NOTE: a pseudo object does NOT support SetExtent ! 601: ! 602: return ResultFromScode(E_FAIL); ! 603: } ! 604: ! 605: ! 606: ! 607: STDMETHODIMP PseudoObj_OleObj_SetHostNames( ! 608: LPOLEOBJECT lpThis, ! 609: LPCSTR szContainerApp, ! 610: LPCSTR szContainerObj ! 611: ) ! 612: { ! 613: OleDbgOut2("PseudoObj_OleObj_SetHostNames\r\n"); ! 614: ! 615: // OLE2NOTE: a pseudo object does NOT support SetExtent ! 616: ! 617: return ResultFromScode(E_FAIL); ! 618: } ! 619: ! 620: ! 621: STDMETHODIMP PseudoObj_OleObj_Close( ! 622: LPOLEOBJECT lpThis, ! 623: DWORD dwSaveOption ! 624: ) ! 625: { ! 626: LPPSEUDOOBJ lpPseudoObj = ! 627: ((struct CPseudoObjOleObjectImpl FAR*)lpThis)->lpPseudoObj; ! 628: BOOL fStatus; ! 629: ! 630: OLEDBG_BEGIN2("PseudoObj_OleObj_Close\r\n") ! 631: ! 632: /* OLE2NOTE: a pseudo object's implementation of IOleObject::Close ! 633: ** should ignore the dwSaveOption parameter. it is NOT ! 634: ** applicable to pseudo objects. ! 635: */ ! 636: ! 637: fStatus = PseudoObj_Close(lpPseudoObj); ! 638: OleDbgAssertSz(fStatus == TRUE, "PseudoObj_OleObj_Close failed\r\n"); ! 639: ! 640: OLEDBG_END2 ! 641: return NOERROR; ! 642: } ! 643: ! 644: ! 645: STDMETHODIMP PseudoObj_OleObj_SetMoniker( ! 646: LPOLEOBJECT lpThis, ! 647: DWORD dwWhichMoniker, ! 648: LPMONIKER lpmk ! 649: ) ! 650: { ! 651: OleDbgOut2("PseudoObj_OleObj_SetMoniker\r\n"); ! 652: ! 653: // OLE2NOTE: a pseudo object does NOT support SetMoniker ! 654: ! 655: return ResultFromScode(E_FAIL); ! 656: } ! 657: ! 658: ! 659: STDMETHODIMP PseudoObj_OleObj_GetMoniker( ! 660: LPOLEOBJECT lpThis, ! 661: DWORD dwAssign, ! 662: DWORD dwWhichMoniker, ! 663: LPMONIKER FAR* lplpmk ! 664: ) ! 665: { ! 666: LPPSEUDOOBJ lpPseudoObj = ! 667: ((struct CPseudoObjOleObjectImpl FAR*)lpThis)->lpPseudoObj; ! 668: LPOLEDOC lpOleDoc = (LPOLEDOC)lpPseudoObj->m_lpDoc; ! 669: LPMONIKER lpmkDoc; ! 670: ! 671: OLEDBG_BEGIN2("PseudoObj_OleObj_GetMoniker\r\n") ! 672: ! 673: lpmkDoc = OleDoc_GetFullMoniker(lpOleDoc, GETMONIKER_ONLYIFTHERE); ! 674: *lplpmk = PseudoObj_GetFullMoniker(lpPseudoObj, lpmkDoc); ! 675: ! 676: OLEDBG_END2 ! 677: ! 678: if (*lplpmk != NULL) ! 679: return NOERROR; ! 680: else ! 681: return ResultFromScode(E_FAIL); ! 682: } ! 683: ! 684: ! 685: STDMETHODIMP PseudoObj_OleObj_InitFromData( ! 686: LPOLEOBJECT lpThis, ! 687: LPDATAOBJECT lpDataObject, ! 688: BOOL fCreation, ! 689: DWORD reserved ! 690: ) ! 691: { ! 692: LPPSEUDOOBJ lpPseudoObj = ! 693: ((struct CPseudoObjOleObjectImpl FAR*)lpThis)->lpPseudoObj; ! 694: ! 695: OleDbgOut2("PseudoObj_OleObj_InitFromData\r\n"); ! 696: ! 697: // REVIEW: NOT YET IMPLEMENTED ! 698: ! 699: return ResultFromScode(E_NOTIMPL); ! 700: } ! 701: ! 702: ! 703: STDMETHODIMP PseudoObj_OleObj_GetClipboardData( ! 704: LPOLEOBJECT lpThis, ! 705: DWORD reserved, ! 706: LPDATAOBJECT FAR* lplpDataObject ! 707: ) ! 708: { ! 709: LPPSEUDOOBJ lpPseudoObj = ! 710: ((struct CPseudoObjOleObjectImpl FAR*)lpThis)->lpPseudoObj; ! 711: ! 712: OleDbgOut2("PseudoObj_OleObj_GetClipboardData\r\n"); ! 713: ! 714: // REVIEW: NOT YET IMPLEMENTED ! 715: ! 716: return ResultFromScode(E_NOTIMPL); ! 717: } ! 718: ! 719: ! 720: STDMETHODIMP PseudoObj_OleObj_DoVerb( ! 721: LPOLEOBJECT lpThis, ! 722: LONG lVerb, ! 723: LPMSG lpmsg, ! 724: LPOLECLIENTSITE lpActiveSite, ! 725: LONG lindex, ! 726: HWND hwndParent, ! 727: LPCRECT lprcPosRect ! 728: ) ! 729: { ! 730: LPPSEUDOOBJ lpPseudoObj = ! 731: ((struct CPseudoObjOleObjectImpl FAR*)lpThis)->lpPseudoObj; ! 732: LPOUTLINEDOC lpOutlineDoc = (LPOUTLINEDOC)lpPseudoObj->m_lpDoc; ! 733: LPSERVERDOC lpServerDoc = lpPseudoObj->m_lpDoc; ! 734: LINERANGE lrSel; ! 735: HRESULT hrErr; ! 736: ! 737: OLEDBG_BEGIN2("PseudoObj_OleObj_DoVerb\r\n"); ! 738: ! 739: /* OLE2NOTE: we must first ask our Document to perform the same ! 740: ** verb. then if the verb is NOT OLEIVERB_HIDE we should also ! 741: ** select the range of our pseudo object. ! 742: ** however, we must give our document its own embedding site as ! 743: ** its active site. ! 744: */ ! 745: hrErr = SvrDoc_OleObj_DoVerb( ! 746: (LPOLEOBJECT)&lpServerDoc->m_OleObject, ! 747: lVerb, ! 748: lpmsg, ! 749: lpServerDoc->m_lpOleClientSite, ! 750: lindex, ! 751: NULL, /* we have no hwndParent to give */ ! 752: NULL /* we have no lprcPosRect to give */ ! 753: ); ! 754: if (hrErr != NOERROR ) { ! 755: OLEDBG_END2 ! 756: return hrErr; ! 757: } ! 758: ! 759: if (lVerb != OLEIVERB_HIDE) { ! 760: PseudoObj_GetSel(lpPseudoObj, &lrSel); ! 761: OutlineDoc_SetSel(lpOutlineDoc, &lrSel); ! 762: } ! 763: ! 764: OLEDBG_END2 ! 765: return NOERROR; ! 766: } ! 767: ! 768: ! 769: ! 770: STDMETHODIMP PseudoObj_OleObj_EnumVerbs( ! 771: LPOLEOBJECT lpThis, ! 772: LPENUMOLEVERB FAR* lplpenumOleVerb ! 773: ) ! 774: { ! 775: OleDbgOut2("PseudoObj_OleObj_EnumVerbs\r\n"); ! 776: ! 777: /* OLE2NOTE: we must make sure to set all out parameters to NULL. */ ! 778: *lplpenumOleVerb = NULL; ! 779: ! 780: // Tell OLE to enumerate our verbs using the REGDB ! 781: return ResultFromScode(OLE_S_USEREG); ! 782: } ! 783: ! 784: ! 785: STDMETHODIMP PseudoObj_OleObj_Update(LPOLEOBJECT lpThis) ! 786: { ! 787: OleDbgOut2("PseudoObj_OleObj_Update\r\n"); ! 788: ! 789: /* OLE2NOTE: a server-only app is always "up-to-date". ! 790: ** a container-app which contains links where the link source ! 791: ** has changed since the last update of the link would be ! 792: ** considered "out-of-date". the "Update" method instructs the ! 793: ** object to get an update from any out-of-date links. ! 794: */ ! 795: ! 796: return NOERROR; ! 797: } ! 798: ! 799: ! 800: STDMETHODIMP PseudoObj_OleObj_IsUpToDate(LPOLEOBJECT lpThis) ! 801: { ! 802: LPPSEUDOOBJ lpPseudoObj = ! 803: ((struct CPseudoObjOleObjectImpl FAR*)lpThis)->lpPseudoObj; ! 804: ! 805: OleDbgOut2("PseudoObj_OleObj_IsUpToDate\r\n"); ! 806: ! 807: /* OLE2NOTE: a server-only app is always "up-to-date". ! 808: ** a container-app which contains links where the link source ! 809: ** has changed since the last update of the link would be ! 810: ** considered "out-of-date". ! 811: */ ! 812: return NOERROR; ! 813: } ! 814: ! 815: ! 816: STDMETHODIMP PseudoObj_OleObj_GetUserClassID( ! 817: LPOLEOBJECT lpThis, ! 818: LPCLSID lpclsid ! 819: ) ! 820: { ! 821: LPPSEUDOOBJ lpPseudoObj = ! 822: ((struct CPseudoObjOleObjectImpl FAR*)lpThis)->lpPseudoObj; ! 823: LPSERVERDOC lpServerDoc = (LPSERVERDOC)lpPseudoObj->m_lpDoc; ! 824: ! 825: OleDbgOut2("PseudoObj_OleObj_GetUserClassID\r\n"); ! 826: ! 827: /* OLE2NOTE: we must be carefull to return the correct CLSID here. ! 828: ** if we are currently preforming a "TreatAs (aka. ActivateAs)" ! 829: ** operation then we need to return the class of the object ! 830: ** written in the storage of the object. otherwise we would ! 831: ** return our own class id. ! 832: */ ! 833: return ServerDoc_GetClassID(lpServerDoc, lpclsid); ! 834: } ! 835: ! 836: ! 837: STDMETHODIMP PseudoObj_OleObj_GetUserType( ! 838: LPOLEOBJECT lpThis, ! 839: DWORD dwFormOfType, ! 840: LPSTR FAR* lpszUserType ! 841: ) ! 842: { ! 843: OleDbgOut2("PseudoObj_OleObj_GetUserType\r\n"); ! 844: ! 845: /* OLE2NOTE: we must make sure to set all out parameters to NULL. */ ! 846: *lpszUserType = NULL; ! 847: ! 848: // Tell OLE to enumerate our verbs using the REGDB ! 849: return ResultFromScode(OLE_S_USEREG); ! 850: ! 851: #if defined( LATER ) ! 852: LPPSEUDOOBJ lpPseudoObj = ! 853: ((struct CPseudoObjOleObjectImpl FAR*)lpThis)->lpPseudoObj; ! 854: LPSERVERDOC lpServerDoc = (LPSERVERDOC)lpPseudoObj->m_lpDoc; ! 855: ! 856: /* OLE2NOTE: we must be carefull to return the correct UserType here. ! 857: ** if we are currently preforming a "TreatAs (aka. ActivateAs)" ! 858: ** operation then we need to return the UserType of the object ! 859: ** written in the storage of the object. otherwise we would ! 860: ** return our own UserType. ! 861: */ ! 862: return ServerDoc_GetUserType(lpServerDoc, dwFormOfType, lpszUserType); ! 863: #endif ! 864: } ! 865: ! 866: ! 867: STDMETHODIMP PseudoObj_OleObj_SetExtent( ! 868: LPOLEOBJECT lpThis, ! 869: DWORD dwDrawAspect, ! 870: LPSIZEL lplgrc ! 871: ) ! 872: { ! 873: OleDbgOut2("PseudoObj_OleObj_SetExtent\r\n"); ! 874: ! 875: // OLE2NOTE: a pseudo object does NOT support SetExtent ! 876: ! 877: return ResultFromScode(E_FAIL); ! 878: } ! 879: ! 880: ! 881: STDMETHODIMP PseudoObj_OleObj_GetExtent( ! 882: LPOLEOBJECT lpThis, ! 883: DWORD dwDrawAspect, ! 884: LPSIZEL lplgrc ! 885: ) ! 886: { ! 887: OleDbgOut2("PseudoObj_OleObj_GetExtent\r\n"); ! 888: ! 889: return ResultFromScode(E_NOTIMPL); ! 890: } ! 891: ! 892: ! 893: STDMETHODIMP PseudoObj_OleObj_Advise( ! 894: LPOLEOBJECT lpThis, ! 895: LPADVISESINK lpAdvSink, ! 896: LPDWORD lpdwConnection ! 897: ) ! 898: { ! 899: LPPSEUDOOBJ lpPseudoObj = ! 900: ((struct CPseudoObjOleObjectImpl FAR*)lpThis)->lpPseudoObj; ! 901: HRESULT hrErr; ! 902: SCODE sc; ! 903: ! 904: OLEDBG_BEGIN2("PseudoObj_OleObj_Advise\r\n"); ! 905: ! 906: if (lpPseudoObj->m_lpOleAdviseHldr == NULL && ! 907: CreateOleAdviseHolder(&lpPseudoObj->m_lpOleAdviseHldr) != NOERROR) { ! 908: sc = E_OUTOFMEMORY; ! 909: goto error; ! 910: } ! 911: ! 912: OLEDBG_BEGIN2("IOleAdviseHolder::Advise called\r\n") ! 913: hrErr = lpPseudoObj->m_lpOleAdviseHldr->lpVtbl->Advise( ! 914: lpPseudoObj->m_lpOleAdviseHldr, ! 915: lpAdvSink, ! 916: lpdwConnection ! 917: ); ! 918: OLEDBG_END2 ! 919: ! 920: OLEDBG_END2 ! 921: return hrErr; ! 922: ! 923: error: ! 924: OLEDBG_END2 ! 925: return ResultFromScode(sc); ! 926: } ! 927: ! 928: ! 929: STDMETHODIMP PseudoObj_OleObj_Unadvise(LPOLEOBJECT lpThis, DWORD dwConnection) ! 930: { ! 931: LPPSEUDOOBJ lpPseudoObj = ! 932: ((struct CPseudoObjOleObjectImpl FAR*)lpThis)->lpPseudoObj; ! 933: HRESULT hrErr; ! 934: SCODE sc; ! 935: ! 936: OLEDBG_BEGIN2("PseudoObj_OleObj_Unadvise\r\n"); ! 937: ! 938: if (lpPseudoObj->m_lpOleAdviseHldr == NULL) { ! 939: sc = E_FAIL; ! 940: goto error; ! 941: } ! 942: ! 943: OLEDBG_BEGIN2("IOleAdviseHolder::Unadvise called\r\n") ! 944: hrErr = lpPseudoObj->m_lpOleAdviseHldr->lpVtbl->Unadvise( ! 945: lpPseudoObj->m_lpOleAdviseHldr, ! 946: dwConnection ! 947: ); ! 948: OLEDBG_END2 ! 949: ! 950: OLEDBG_END2 ! 951: return hrErr; ! 952: ! 953: error: ! 954: OLEDBG_END2 ! 955: return ResultFromScode(sc); ! 956: } ! 957: ! 958: ! 959: STDMETHODIMP PseudoObj_OleObj_EnumAdvise( ! 960: LPOLEOBJECT lpThis, ! 961: LPENUMSTATDATA FAR* lplpenumAdvise ! 962: ) ! 963: { ! 964: LPPSEUDOOBJ lpPseudoObj = ! 965: ((struct CPseudoObjOleObjectImpl FAR*)lpThis)->lpPseudoObj; ! 966: HRESULT hrErr; ! 967: SCODE sc; ! 968: ! 969: OLEDBG_BEGIN2("PseudoObj_OleObj_EnumAdvise\r\n"); ! 970: ! 971: /* OLE2NOTE: we must make sure to set all out parameters to NULL. */ ! 972: *lplpenumAdvise = NULL; ! 973: ! 974: if (lpPseudoObj->m_lpOleAdviseHldr == NULL) { ! 975: sc = E_FAIL; ! 976: goto error; ! 977: } ! 978: ! 979: OLEDBG_BEGIN2("IOleAdviseHolder::EnumAdvise called\r\n") ! 980: hrErr = lpPseudoObj->m_lpOleAdviseHldr->lpVtbl->EnumAdvise( ! 981: lpPseudoObj->m_lpOleAdviseHldr, ! 982: lplpenumAdvise ! 983: ); ! 984: OLEDBG_END2 ! 985: ! 986: OLEDBG_END2 ! 987: return hrErr; ! 988: ! 989: error: ! 990: OLEDBG_END2 ! 991: return ResultFromScode(sc); ! 992: } ! 993: ! 994: ! 995: STDMETHODIMP PseudoObj_OleObj_GetMiscStatus( ! 996: LPOLEOBJECT lpThis, ! 997: DWORD dwAspect, ! 998: DWORD FAR* lpdwStatus ! 999: ) ! 1000: { ! 1001: LPPSEUDOOBJ lpPseudoObj = ! 1002: ((struct CPseudoObjOleObjectImpl FAR*)lpThis)->lpPseudoObj; ! 1003: ! 1004: OleDbgOut2("PseudoObj_OleObj_GetMiscStatus\r\n"); ! 1005: ! 1006: // Tell OLE to get our user type name from the REGDB ! 1007: return ResultFromScode(OLE_S_USEREG); ! 1008: } ! 1009: ! 1010: ! 1011: STDMETHODIMP PseudoObj_OleObj_SetColorScheme( ! 1012: LPOLEOBJECT lpThis, ! 1013: LPLOGPALETTE lpLogpal ! 1014: ) ! 1015: { ! 1016: OleDbgOut2("PseudoObj_OleObj_SetColorScheme\r\n"); ! 1017: ! 1018: // REVIEW: NOT YET IMPLEMENTED ! 1019: ! 1020: return ResultFromScode(E_NOTIMPL); ! 1021: } ! 1022: ! 1023: ! 1024: /************************************************************************* ! 1025: ** PseudoObj::IDataObject interface implementation ! 1026: *************************************************************************/ ! 1027: ! 1028: STDMETHODIMP PseudoObj_DataObj_QueryInterface ( ! 1029: LPDATAOBJECT lpThis, ! 1030: REFIID riid, ! 1031: LPVOID FAR* lplpvObj ! 1032: ) ! 1033: { ! 1034: LPPSEUDOOBJ lpPseudoObj = ! 1035: ((struct CPseudoObjDataObjectImpl FAR*)lpThis)->lpPseudoObj; ! 1036: ! 1037: return PseudoObj_QueryInterface(lpPseudoObj, riid, lplpvObj); ! 1038: } ! 1039: ! 1040: ! 1041: STDMETHODIMP_(ULONG) PseudoObj_DataObj_AddRef(LPDATAOBJECT lpThis) ! 1042: { ! 1043: LPPSEUDOOBJ lpPseudoObj = ! 1044: ((struct CPseudoObjDataObjectImpl FAR*)lpThis)->lpPseudoObj; ! 1045: ! 1046: OleDbgAddRefMethod(lpThis, "IDataObject"); ! 1047: ! 1048: return PseudoObj_AddRef((LPPSEUDOOBJ)lpPseudoObj); ! 1049: } ! 1050: ! 1051: ! 1052: STDMETHODIMP_(ULONG) PseudoObj_DataObj_Release (LPDATAOBJECT lpThis) ! 1053: { ! 1054: LPPSEUDOOBJ lpPseudoObj = ! 1055: ((struct CPseudoObjDataObjectImpl FAR*)lpThis)->lpPseudoObj; ! 1056: ! 1057: OleDbgReleaseMethod(lpThis, "IDataObject"); ! 1058: ! 1059: return PseudoObj_Release((LPPSEUDOOBJ)lpPseudoObj); ! 1060: } ! 1061: ! 1062: ! 1063: STDMETHODIMP PseudoObj_DataObj_GetData ( ! 1064: LPDATAOBJECT lpThis, ! 1065: LPFORMATETC lpformatetc, ! 1066: LPSTGMEDIUM lpMedium ! 1067: ) ! 1068: { ! 1069: LPPSEUDOOBJ lpPseudoObj = ! 1070: ((struct CPseudoObjDataObjectImpl FAR*)lpThis)->lpPseudoObj; ! 1071: LPSERVERDOC lpServerDoc = lpPseudoObj->m_lpDoc; ! 1072: LPOUTLINEDOC lpOutlineDoc = (LPOUTLINEDOC)lpServerDoc; ! 1073: LPSERVERAPP lpServerApp = (LPSERVERAPP)g_lpApp; ! 1074: LPOLEAPP lpOleApp = (LPOLEAPP)lpServerApp; ! 1075: LPOUTLINEAPP lpOutlineApp = (LPOUTLINEAPP)lpServerApp; ! 1076: LINERANGE lrSel; ! 1077: SCODE sc = S_OK; ! 1078: ! 1079: OLEDBG_BEGIN2("PseudoObj_DataObj_GetData\r\n") ! 1080: ! 1081: PseudoObj_GetSel(lpPseudoObj, &lrSel); ! 1082: ! 1083: /* OLE2NOTE: we must make sure to set all out parameters to NULL. */ ! 1084: lpMedium->tymed = TYMED_NULL; ! 1085: lpMedium->pUnkForRelease = NULL; // we transfer ownership to caller ! 1086: lpMedium->u.hGlobal = NULL; ! 1087: ! 1088: if (lpformatetc->cfFormat == lpOutlineApp->m_cfOutline) { ! 1089: // Verify caller asked for correct medium ! 1090: if (!(lpformatetc->tymed & TYMED_HGLOBAL)) { ! 1091: sc = DATA_E_FORMATETC; ! 1092: goto error; ! 1093: } ! 1094: ! 1095: lpMedium->u.hGlobal = OutlineDoc_GetOutlineData (lpOutlineDoc,&lrSel); ! 1096: if (! lpMedium->u.hGlobal) return ResultFromScode(E_OUTOFMEMORY); ! 1097: lpMedium->tymed = TYMED_HGLOBAL; ! 1098: OleDbgOut3("PseudoObj_DataObj_GetData: rendered CF_OUTLINE\r\n"); ! 1099: ! 1100: } else if(lpformatetc->cfFormat == CF_METAFILEPICT && ! 1101: (lpformatetc->dwAspect & (DVASPECT_CONTENT | DVASPECT_DOCPRINT)) ) { ! 1102: // Verify caller asked for correct medium ! 1103: if (!(lpformatetc->tymed & TYMED_MFPICT)) { ! 1104: sc = DATA_E_FORMATETC; ! 1105: goto error; ! 1106: } ! 1107: ! 1108: lpMedium->u.hGlobal=ServerDoc_GetMetafilePictData(lpServerDoc,&lrSel); ! 1109: if (! lpMedium->u.hGlobal) { ! 1110: sc = E_OUTOFMEMORY; ! 1111: goto error; ! 1112: } ! 1113: lpMedium->tymed = TYMED_MFPICT; ! 1114: OleDbgOut3("PseudoObj_DataObj_GetData: rendered CF_METAFILEPICT\r\n"); ! 1115: ! 1116: } else if (lpformatetc->cfFormat == CF_METAFILEPICT && ! 1117: (lpformatetc->dwAspect & DVASPECT_ICON | DVASPECT_DOCPRINT) ) { ! 1118: CLSID clsid; ! 1119: // Verify caller asked for correct medium ! 1120: if (!(lpformatetc->tymed & TYMED_MFPICT)) { ! 1121: sc = DATA_E_FORMATETC; ! 1122: goto error; ! 1123: } ! 1124: ! 1125: /* OLE2NOTE: we should return the default icon for our class. ! 1126: ** we must be carefull to use the correct CLSID here. ! 1127: ** if we are currently preforming a "TreatAs (aka. ActivateAs)" ! 1128: ** operation then we need to use the class of the object ! 1129: ** written in the storage of the object. otherwise we would ! 1130: ** use our own class id. ! 1131: */ ! 1132: if (ServerDoc_GetClassID(lpServerDoc, (LPCLSID)&clsid) != NOERROR) { ! 1133: sc = DATA_E_FORMATETC; ! 1134: goto error; ! 1135: } ! 1136: ! 1137: lpMedium->u.hGlobal=GetIconOfClass( ! 1138: g_lpApp->m_hInst,(REFCLSID)&clsid, NULL, FALSE); ! 1139: if (! lpMedium->u.hGlobal) { ! 1140: sc = E_OUTOFMEMORY; ! 1141: goto error; ! 1142: } ! 1143: ! 1144: lpMedium->tymed = TYMED_MFPICT; ! 1145: OleDbgOut3( ! 1146: "PseudoObj_DataObj_GetData: rendered CF_METAFILEPICT (icon)\r\n"); ! 1147: return NOERROR; ! 1148: ! 1149: } else if (lpformatetc->cfFormat == CF_TEXT) { ! 1150: // Verify caller asked for correct medium ! 1151: if (!(lpformatetc->tymed & TYMED_HGLOBAL)) { ! 1152: sc = DATA_E_FORMATETC; ! 1153: goto error; ! 1154: } ! 1155: ! 1156: lpMedium->u.hGlobal = OutlineDoc_GetTextData (lpOutlineDoc, &lrSel); ! 1157: if (! lpMedium->u.hGlobal) { ! 1158: sc = E_OUTOFMEMORY; ! 1159: goto error; ! 1160: } ! 1161: lpMedium->tymed = TYMED_HGLOBAL; ! 1162: OleDbgOut3("PseudoObj_DataObj_GetData: rendered CF_TEXT\r\n"); ! 1163: ! 1164: } else { ! 1165: sc = DATA_E_FORMATETC; ! 1166: goto error; ! 1167: } ! 1168: ! 1169: OLEDBG_END2 ! 1170: return NOERROR; ! 1171: ! 1172: error: ! 1173: OLEDBG_END2 ! 1174: return ResultFromScode(sc); ! 1175: } ! 1176: ! 1177: ! 1178: STDMETHODIMP PseudoObj_DataObj_GetDataHere ( ! 1179: LPDATAOBJECT lpThis, ! 1180: LPFORMATETC lpformatetc, ! 1181: LPSTGMEDIUM lpMedium ! 1182: ) ! 1183: { ! 1184: LPPSEUDOOBJ lpPseudoObj = ! 1185: ((struct CPseudoObjDataObjectImpl FAR*)lpThis)->lpPseudoObj; ! 1186: LPSERVERDOC lpServerDoc = lpPseudoObj->m_lpDoc; ! 1187: LPOUTLINEDOC lpOutlineDoc = (LPOUTLINEDOC)lpServerDoc; ! 1188: LPSERVERAPP lpServerApp = (LPSERVERAPP)g_lpApp; ! 1189: LPOLEAPP lpOleApp = (LPOLEAPP)lpServerApp; ! 1190: LPOUTLINEAPP lpOutlineApp = (LPOUTLINEAPP)lpServerApp; ! 1191: ! 1192: OleDbgOut("PseudoObj_DataObj_GetDataHere\r\n"); ! 1193: ! 1194: /* Caller is requesting data to be returned in Caller allocated ! 1195: ** medium, but we do NOT support this. we only support ! 1196: ** global memory blocks that WE allocate for the caller. ! 1197: */ ! 1198: return ResultFromScode(DATA_E_FORMATETC); ! 1199: } ! 1200: ! 1201: ! 1202: STDMETHODIMP PseudoObj_DataObj_QueryGetData ( ! 1203: LPDATAOBJECT lpThis, ! 1204: LPFORMATETC lpformatetc ! 1205: ) ! 1206: { ! 1207: LPPSEUDOOBJ lpPseudoObj = ! 1208: ((struct CPseudoObjDataObjectImpl FAR*)lpThis)->lpPseudoObj; ! 1209: LPSERVERDOC lpServerDoc = lpPseudoObj->m_lpDoc; ! 1210: LPOUTLINEDOC lpOutlineDoc = (LPOUTLINEDOC)lpServerDoc; ! 1211: LPSERVERAPP lpServerApp = (LPSERVERAPP)g_lpApp; ! 1212: LPOLEAPP lpOleApp = (LPOLEAPP)lpServerApp; ! 1213: LPOUTLINEAPP lpOutlineApp = (LPOUTLINEAPP)lpServerApp; ! 1214: ! 1215: OleDbgOut2("PseudoObj_DataObj_QueryGetData\r\n"); ! 1216: ! 1217: /* Caller is querying if we support certain format but does not ! 1218: ** want any data actually returned. ! 1219: */ ! 1220: if (lpformatetc->cfFormat == CF_METAFILEPICT && ! 1221: (lpformatetc->dwAspect & ! 1222: (DVASPECT_CONTENT | DVASPECT_CONTENT | DVASPECT_DOCPRINT)) ) { ! 1223: return OleStdQueryFormatMedium(lpformatetc, TYMED_HGLOBAL); ! 1224: ! 1225: } else if (lpformatetc->cfFormat == (lpOutlineApp)->m_cfOutline || ! 1226: lpformatetc->cfFormat == CF_TEXT) { ! 1227: return OleStdQueryFormatMedium(lpformatetc, TYMED_HGLOBAL); ! 1228: } ! 1229: ! 1230: return ResultFromScode(DATA_E_FORMATETC); ! 1231: } ! 1232: ! 1233: ! 1234: STDMETHODIMP PseudoObj_DataObj_GetCanonicalFormatEtc( ! 1235: LPDATAOBJECT lpThis, ! 1236: LPFORMATETC lpformatetc, ! 1237: LPFORMATETC lpformatetcOut ! 1238: ) ! 1239: { ! 1240: OleDbgOut2("PseudoObj_DataObj_GetCanonicalFormatEtc\r\n"); ! 1241: ! 1242: OleDbgAssertSz(0, "NOT_YET_IMPLEMENTED\r\n"); ! 1243: return ResultFromScode(E_NOTIMPL); ! 1244: } ! 1245: ! 1246: ! 1247: STDMETHODIMP PseudoObj_DataObj_SetData ( ! 1248: LPDATAOBJECT lpThis, ! 1249: LPFORMATETC lpformatetc, ! 1250: LPSTGMEDIUM lpmedium, ! 1251: BOOL fRelease ! 1252: ) ! 1253: { ! 1254: LPPSEUDOOBJ lpPseudoObj = ! 1255: ((struct CPseudoObjDataObjectImpl FAR*)lpThis)->lpPseudoObj; ! 1256: LPSERVERDOC lpServerDoc = lpPseudoObj->m_lpDoc; ! 1257: LPOUTLINEDOC lpOutlineDoc = (LPOUTLINEDOC)lpServerDoc; ! 1258: LPSERVERAPP lpServerApp = (LPSERVERAPP)g_lpApp; ! 1259: ! 1260: OleDbgOut2("PseudoObj_DataObj_SetData\r\n"); ! 1261: ! 1262: // REVIEW: NOT-YET-IMPLEMENTED ! 1263: return ResultFromScode(E_NOTIMPL); ! 1264: } ! 1265: ! 1266: ! 1267: STDMETHODIMP PseudoObj_DataObj_EnumFormatEtc( ! 1268: LPDATAOBJECT lpThis, ! 1269: DWORD dwDirection, ! 1270: LPENUMFORMATETC FAR* lplpenumFormatEtc ! 1271: ) ! 1272: { ! 1273: SCODE sc; ! 1274: ! 1275: OleDbgOut2("PseudoObj_DataObj_EnumFormatEtc\r\n"); ! 1276: ! 1277: /* OLE2NOTE: a pseudo object only needs to enumerate the static list ! 1278: ** of formats that are registered for our app in the ! 1279: ** registration database. OLE provides a default enumerator ! 1280: ** which enumerates from the registration database. this default ! 1281: ** enumerator is requested by returning OLE_S_USEREG. it is NOT ! 1282: ** required that a pseudo object (ie. non-DataTransferDoc) ! 1283: ** enumerate the OLE formats: CF_LINKSOURCE, CF_EMBEDSOURCE, or ! 1284: ** CF_EMBEDDEDOBJECT. we do NOT use pseudo objects for data ! 1285: ** transfers. ! 1286: */ ! 1287: if (dwDirection == DATADIR_GET) ! 1288: sc = OLE_S_USEREG; ! 1289: else if (dwDirection == DATADIR_SET) ! 1290: sc = E_NOTIMPL; ! 1291: else ! 1292: sc = E_INVALIDARG; ! 1293: ! 1294: return ResultFromScode(sc); ! 1295: } ! 1296: ! 1297: ! 1298: STDMETHODIMP PseudoObj_DataObj_Advise( ! 1299: LPDATAOBJECT lpThis, ! 1300: FORMATETC FAR* lpFormatetc, ! 1301: DWORD advf, ! 1302: LPADVISESINK lpAdvSink, ! 1303: DWORD FAR* lpdwConnection ! 1304: ) ! 1305: { ! 1306: LPPSEUDOOBJ lpPseudoObj = ! 1307: ((struct CPseudoObjDataObjectImpl FAR*)lpThis)->lpPseudoObj; ! 1308: HRESULT hrErr; ! 1309: SCODE sc; ! 1310: ! 1311: OLEDBG_BEGIN2("PseudoObj_DataObj_Advise\r\n") ! 1312: ! 1313: /* OLE2NOTE: we must make sure to set all out parameters to NULL. */ ! 1314: *lpdwConnection = 0; ! 1315: ! 1316: if (lpPseudoObj->m_lpDataAdviseHldr == NULL && ! 1317: CreateDataAdviseHolder(&lpPseudoObj->m_lpDataAdviseHldr) != NOERROR) { ! 1318: sc = E_OUTOFMEMORY; ! 1319: goto error; ! 1320: } ! 1321: ! 1322: OLEDBG_BEGIN2("IOleAdviseHolder::Advise called\r\n") ! 1323: hrErr = lpPseudoObj->m_lpDataAdviseHldr->lpVtbl->Advise( ! 1324: lpPseudoObj->m_lpDataAdviseHldr, ! 1325: (LPDATAOBJECT)&lpPseudoObj->m_DataObject, ! 1326: lpFormatetc, ! 1327: advf, ! 1328: lpAdvSink, ! 1329: lpdwConnection ! 1330: ); ! 1331: OLEDBG_END2 ! 1332: ! 1333: OLEDBG_END2 ! 1334: return hrErr; ! 1335: ! 1336: error: ! 1337: OLEDBG_END2 ! 1338: return ResultFromScode(sc); ! 1339: } ! 1340: ! 1341: ! 1342: STDMETHODIMP PseudoObj_DataObj_Unadvise(LPDATAOBJECT lpThis, DWORD dwConnection) ! 1343: { ! 1344: LPPSEUDOOBJ lpPseudoObj = ! 1345: ((struct CPseudoObjDataObjectImpl FAR*)lpThis)->lpPseudoObj; ! 1346: HRESULT hrErr; ! 1347: SCODE sc; ! 1348: ! 1349: OLEDBG_BEGIN2("PseudoObj_DataObj_Unadvise\r\n"); ! 1350: ! 1351: // no one registered ! 1352: if (lpPseudoObj->m_lpDataAdviseHldr == NULL) { ! 1353: sc = E_FAIL; ! 1354: goto error; ! 1355: } ! 1356: ! 1357: OLEDBG_BEGIN2("IOleAdviseHolder::Unadvise called\r\n") ! 1358: hrErr = lpPseudoObj->m_lpDataAdviseHldr->lpVtbl->Unadvise( ! 1359: lpPseudoObj->m_lpDataAdviseHldr, ! 1360: dwConnection ! 1361: ); ! 1362: OLEDBG_END2 ! 1363: ! 1364: OLEDBG_END2 ! 1365: return hrErr; ! 1366: ! 1367: error: ! 1368: OLEDBG_END2 ! 1369: return ResultFromScode(sc); ! 1370: } ! 1371: ! 1372: ! 1373: STDMETHODIMP PseudoObj_DataObj_EnumAdvise( ! 1374: LPDATAOBJECT lpThis, ! 1375: LPENUMSTATDATA FAR* lplpenumAdvise ! 1376: ) ! 1377: { ! 1378: LPPSEUDOOBJ lpPseudoObj = ! 1379: ((struct CPseudoObjDataObjectImpl FAR*)lpThis)->lpPseudoObj; ! 1380: HRESULT hrErr; ! 1381: SCODE sc; ! 1382: ! 1383: OLEDBG_BEGIN2("PseudoObj_DataObj_EnumAdvise\r\n"); ! 1384: ! 1385: /* OLE2NOTE: we must make sure to set all out parameters to NULL. */ ! 1386: *lplpenumAdvise = NULL; ! 1387: ! 1388: if (lpPseudoObj->m_lpDataAdviseHldr == NULL) { ! 1389: sc = E_FAIL; ! 1390: goto error; ! 1391: } ! 1392: ! 1393: OLEDBG_BEGIN2("IOleAdviseHolder::EnumAdvise called\r\n") ! 1394: hrErr = lpPseudoObj->m_lpDataAdviseHldr->lpVtbl->EnumAdvise( ! 1395: lpPseudoObj->m_lpDataAdviseHldr, ! 1396: lplpenumAdvise ! 1397: ); ! 1398: OLEDBG_END2 ! 1399: ! 1400: OLEDBG_END2 ! 1401: return hrErr; ! 1402: ! 1403: error: ! 1404: OLEDBG_END2 ! 1405: return ResultFromScode(sc); ! 1406: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.