![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to clipbrd.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 clipbrd.c CVS log | Up to [WindowsNT SDKs] / mstools / ole20 / samples / outline |
1.1 root 1: /*************************************************************************
2: **
3: ** OLE 2 Sample Code
4: **
5: ** clipbrd.c
6: **
7: ** This file contains the major interfaces, methods and related support
8: ** functions for implementing clipboard data transfer. The code
9: ** contained in this file is used by BOTH the Container and Server
10: ** (Object) versions of the Outline sample code.
11: ** (see file dragdrop.c for Drag/Drop support implementation)
12: **
13: ** OleDoc Object
14: ** exposed interfaces:
15: ** IDataObject
16: **
17: ** (c) Copyright Microsoft Corp. 1992 - 1993 All Rights Reserved
18: **
19: *************************************************************************/
20:
21: #include "outline.h"
22: #include <enumfetc.h>
23: #include <geticon.h>
24:
25: OLEDBGDATA
26:
27: extern LPOUTLINEAPP g_lpApp;
28:
29: // REVIEW: should use string resource for messages
30: char ErrMsgPasting[] = "Could not paste data from clipboard!";
31: char ErrMsgBadFmt[] = "Invalid format selected!";
32: char ErrMsgPasteFailed[] = "Could not paste data from clipboard!";
33:
34:
35:
36: /*************************************************************************
37: ** OleDoc::IDataObject interface implementation
38: *************************************************************************/
39:
40: STDMETHODIMP OleDoc_DataObj_QueryInterface (
41: LPDATAOBJECT lpThis,
42: REFIID riid,
43: LPVOID FAR* lplpvObj
44: )
45: {
46: LPOLEDOC lpOleDoc = ((struct CDocDataObjectImpl FAR*)lpThis)->lpOleDoc;
47:
48: return OleDoc_QueryInterface((LPOLEDOC)lpOleDoc, riid, lplpvObj);
49: }
50:
51:
52: STDMETHODIMP_(ULONG) OleDoc_DataObj_AddRef(LPDATAOBJECT lpThis)
53: {
54: LPOLEDOC lpOleDoc = ((struct CDocDataObjectImpl FAR*)lpThis)->lpOleDoc;
55:
56: OleDbgAddRefMethod(lpThis, "IDataObject");
57:
58: return OleDoc_AddRef((LPOLEDOC)lpOleDoc);
59: }
60:
61:
62: STDMETHODIMP_(ULONG) OleDoc_DataObj_Release (LPDATAOBJECT lpThis)
63: {
64: LPOLEDOC lpOleDoc = ((struct CDocDataObjectImpl FAR*)lpThis)->lpOleDoc;
65:
66: OleDbgReleaseMethod(lpThis, "IDataObject");
67:
68: return OleDoc_Release((LPOLEDOC)lpOleDoc);
69: }
70:
71:
72: STDMETHODIMP OleDoc_DataObj_GetData (
73: LPDATAOBJECT lpThis,
74: LPFORMATETC lpFormatetc,
75: LPSTGMEDIUM lpMedium
76: )
77: {
78: LPOLEDOC lpOleDoc = ((struct CDocDataObjectImpl FAR*)lpThis)->lpOleDoc;
79: HRESULT hrErr;
80:
81: OLEDBG_BEGIN2("OleDoc_DataObj_GetData\r\n")
82:
83: #if defined( OLE_SERVER )
84: // Call OLE Server specific version of this function
85: hrErr = ServerDoc_GetData((LPSERVERDOC)lpOleDoc, lpFormatetc, lpMedium);
86:
87: #elif defined( OLE_CNTR )
88: // Call OLE Container specific version of this function
89: hrErr = ContainerDoc_GetData(
90: (LPCONTAINERDOC)lpOleDoc,
91: lpFormatetc,
92: lpMedium
93: );
94: #endif
95:
96: OLEDBG_END2
97: return hrErr;
98: }
99:
100:
101: STDMETHODIMP OleDoc_DataObj_GetDataHere (
102: LPDATAOBJECT lpThis,
103: LPFORMATETC lpFormatetc,
104: LPSTGMEDIUM lpMedium
105: )
106: {
107: LPOLEDOC lpOleDoc = ((struct CDocDataObjectImpl FAR*)lpThis)->lpOleDoc;
108: HRESULT hrErr;
109:
110: OLEDBG_BEGIN2("OleDoc_DataObj_GetDataHere\r\n")
111:
112: #if defined( OLE_SERVER )
113: // Call OLE Server specific version of this function
114: hrErr = ServerDoc_GetDataHere(
115: (LPSERVERDOC)lpOleDoc,
116: lpFormatetc,
117: lpMedium
118: );
119:
120: #elif defined( OLE_CNTR )
121: // Call OLE Container specific version of this function
122: hrErr = ContainerDoc_GetDataHere(
123: (LPCONTAINERDOC)lpOleDoc,
124: lpFormatetc,
125: lpMedium
126: );
127: #endif
128:
129: OLEDBG_END2
130: return hrErr;
131: }
132:
133:
134: STDMETHODIMP OleDoc_DataObj_QueryGetData (
135: LPDATAOBJECT lpThis,
136: LPFORMATETC lpFormatetc
137: )
138: {
139: LPOLEDOC lpOleDoc = ((struct CDocDataObjectImpl FAR*)lpThis)->lpOleDoc;
140: HRESULT hrErr;
141:
142: OLEDBG_BEGIN2("OleDoc_DataObj_QueryGetData\r\n");
143:
144: #if defined( OLE_SERVER )
145: // Call OLE Server specific version of this function
146: hrErr = ServerDoc_QueryGetData((LPSERVERDOC)lpOleDoc, lpFormatetc);
147:
148: #elif defined( OLE_CNTR )
149: // Call OLE Container specific version of this function
150: hrErr = ContainerDoc_QueryGetData((LPCONTAINERDOC)lpOleDoc, lpFormatetc);
151: #endif
152:
153: OLEDBG_END2
154: return hrErr;
155: }
156:
157:
158: STDMETHODIMP OleDoc_DataObj_GetCanonicalFormatEtc(
159: LPDATAOBJECT lpThis,
160: LPFORMATETC lpformatetc,
161: LPFORMATETC lpformatetcOut
162: )
163: {
164: OleDbgOut2("OleDoc_DataObj_GetCanonicalFormatEtc\r\n");
165:
166: return ResultFromScode(E_NOTIMPL);
167: }
168:
169:
170: STDMETHODIMP OleDoc_DataObj_SetData (
171: LPDATAOBJECT lpThis,
172: LPFORMATETC lpFormatetc,
173: LPSTGMEDIUM lpMedium,
174: BOOL fRelease
175: )
176: {
177: LPOLEDOC lpOleDoc = ((struct CDocDataObjectImpl FAR*)lpThis)->lpOleDoc;
178: LPOUTLINEDOC lpOutlineDoc = (LPOUTLINEDOC)lpOleDoc;
179: LPOUTLINEAPP lpOutlineApp = (LPOUTLINEAPP)g_lpApp;
180: SCODE sc;
181:
182: OLEDBG_BEGIN2("OleDoc_DataObj_SetData\r\n")
183:
184: /* OLE2NOTE: a document that is used to transfer data (either via
185: ** the clipboard or drag/drop) does NOT accept SetData on ANY
186: ** format!
187: */
188: if (lpOutlineDoc->m_fDataTransferDoc) {
189: sc = E_FAIL;
190: goto error;
191: }
192:
193: #if defined( OLE_SERVER )
194: {
195: HRESULT hrErr;
196:
197: if (lpFormatetc->cfFormat == lpOutlineApp->m_cfOutline) {
198:
199: OLEDBG_BEGIN2("ServerDoc_SetData: CF_OUTLINE\r\n");
200:
201: OutlineDoc_SetRedraw ( lpOutlineDoc, FALSE );
202: OutlineDoc_ClearAllLines(lpOutlineDoc);
203: OutlineDoc_PasteOutlineData(lpOutlineDoc,lpMedium->u.hGlobal,-1);
204: OutlineDoc_SetRedraw ( lpOutlineDoc, TRUE );
205:
206: OLEDBG_END3
207:
208: } else if (lpFormatetc->cfFormat == CF_TEXT) {
209:
210: OLEDBG_BEGIN2("ServerDoc_SetData: CF_TEXT\r\n");
211:
212: OutlineDoc_SetRedraw ( lpOutlineDoc, FALSE );
213: OutlineDoc_ClearAllLines(lpOutlineDoc);
214: OutlineDoc_PasteTextData(lpOutlineDoc,lpMedium->u.hGlobal,-1);
215: OutlineDoc_SetRedraw ( lpOutlineDoc, TRUE );
216:
217: OLEDBG_END3
218:
219: } else {
220: sc = DATA_E_FORMATETC;
221: goto error;
222: }
223:
224: OLEDBG_END2
225: return hrErr;
226: }
227:
228: #elif defined( OLE_CNTR )
229: {
230: /* the Container-Only version of Outline does NOT offer
231: ** IDataObject interface from its User documents. this is
232: ** required by objects which can be embedded or linked. the
233: ** Container-only app only allows linking to its contained
234: ** objects, NOT the data of the container itself.
235: */
236: OleDbgAssertSz(0, "User documents do NOT support IDataObject\r\n");
237: sc = E_NOTIMPL;
238: goto error;
239: }
240: #endif
241:
242: error:
243: OLEDBG_END2
244: return ResultFromScode(sc);
245:
246: }
247:
248:
249: STDMETHODIMP OleDoc_DataObj_EnumFormatEtc(
250: LPDATAOBJECT lpThis,
251: DWORD dwDirection,
252: LPENUMFORMATETC FAR* lplpenumFormatEtc
253: )
254: {
255: LPOLEDOC lpOleDoc=((struct CDocDataObjectImpl FAR*)lpThis)->lpOleDoc;
256: HRESULT hrErr;
257:
258: OLEDBG_BEGIN2("OleDoc_DataObj_EnumFormatEtc\r\n")
259:
260: /* OLE2NOTE: we must make sure to set all out parameters to NULL. */
261: *lplpenumFormatEtc = NULL;
262:
263: #if defined( OLE_SERVER )
264: /* OLE2NOTE: a user document only needs to enumerate the static list
265: ** of formats that are registered for our app in the
266: ** registration database. OLE provides a default enumerator
267: ** which enumerates from the registration database. this default
268: ** enumerator is requested by returning OLE_S_USEREG. it is NOT
269: ** required that a user document (ie. non-DataTransferDoc)
270: ** enumerate the OLE formats: CF_LINKSOURCE, CF_EMBEDSOURCE, or
271: ** CF_EMBEDDEDOBJECT.
272: */
273: if (! ((LPOUTLINEDOC)lpOleDoc)->m_fDataTransferDoc)
274: return ResultFromScode(OLE_S_USEREG);
275:
276: // Call OLE Server specific version of this function
277: hrErr = ServerDoc_EnumFormatEtc(
278: (LPSERVERDOC)lpOleDoc,
279: dwDirection,
280: lplpenumFormatEtc
281: );
282: #elif defined( OLE_CNTR )
283: // Call OLE Container specific version of this function
284: hrErr = ContainerDoc_EnumFormatEtc(
285: (LPCONTAINERDOC)lpOleDoc,
286: dwDirection,
287: lplpenumFormatEtc
288: );
289: #endif
290:
291: OLEDBG_END2
292: return hrErr;
293: }
294:
295:
296: STDMETHODIMP OleDoc_DataObj_DAdvise(
297: LPDATAOBJECT lpThis,
298: FORMATETC FAR* lpFormatetc,
299: DWORD advf,
300: LPADVISESINK lpAdvSink,
301: DWORD FAR* lpdwConnection
302: )
303: {
304: LPOLEDOC lpOleDoc=((struct CDocDataObjectImpl FAR*)lpThis)->lpOleDoc;
305: LPOUTLINEDOC lpOutlineDoc = (LPOUTLINEDOC)lpOleDoc;
306: SCODE sc;
307:
308: OLEDBG_BEGIN2("OleDoc_DataObj_DAdvise\r\n")
309:
310: /* OLE2NOTE: we must make sure to set all out parameters to NULL. */
311: *lpdwConnection = 0;
312:
313: /* OLE2NOTE: a document that is used to transfer data (either via
314: ** the clipboard or drag/drop) does NOT support Advise notifications.
315: */
316: if (lpOutlineDoc->m_fDataTransferDoc) {
317: sc = OLE_E_ADVISENOTSUPPORTED;
318: goto error;
319: }
320:
321: #if defined( OLE_SERVER )
322: {
323: HRESULT hrErr;
324: LPSERVERDOC lpServerDoc = (LPSERVERDOC)lpOleDoc;
325:
326: if (lpServerDoc->m_lpDataAdviseHldr == NULL &&
327: CreateDataAdviseHolder(&lpServerDoc->m_lpDataAdviseHldr)
328: != NOERROR) {
329: sc = E_OUTOFMEMORY;
330: goto error;
331: }
332:
333: OLEDBG_BEGIN2("IDataAdviseHolder::Advise called\r\n");
334: hrErr = lpServerDoc->m_lpDataAdviseHldr->lpVtbl->Advise(
335: lpServerDoc->m_lpDataAdviseHldr,
336: (LPDATAOBJECT)&lpOleDoc->m_DataObject,
337: lpFormatetc,
338: advf,
339: lpAdvSink,
340: lpdwConnection
341: );
342: OLEDBG_END2
343:
344: OLEDBG_END2
345: return hrErr;
346: }
347:
348: #elif defined( OLE_CNTR )
349: {
350: /* the Container-Only version of Outline does NOT offer
351: ** IDataObject interface from its User documents. this is
352: ** required by objects which can be embedded or linked. the
353: ** Container-only app only allows linking to its contained
354: ** objects, NOT the data of the container itself.
355: */
356: OleDbgAssertSz(0, "User documents do NOT support IDataObject\r\n");
357: sc = E_NOTIMPL;
358: goto error;
359: }
360: #endif
361:
362: error:
363: OLEDBG_END2
364: return ResultFromScode(sc);
365: }
366:
367:
368: STDMETHODIMP OleDoc_DataObj_DUnadvise(LPDATAOBJECT lpThis, DWORD dwConnection)
369: {
370: LPOLEDOC lpOleDoc=((struct CDocDataObjectImpl FAR*)lpThis)->lpOleDoc;
371: LPOUTLINEDOC lpOutlineDoc = (LPOUTLINEDOC)lpOleDoc;
372: SCODE sc;
373:
374: OLEDBG_BEGIN2("OleDoc_DataObj_DUnadvise\r\n")
375:
376: /* OLE2NOTE: a document that is used to transfer data (either via
377: ** the clipboard or drag/drop) does NOT support Advise notifications.
378: */
379: if (lpOutlineDoc->m_fDataTransferDoc) {
380: sc = OLE_E_ADVISENOTSUPPORTED;
381: goto error;
382: }
383:
384: #if defined( OLE_SERVER )
385: {
386: LPSERVERDOC lpServerDoc = (LPSERVERDOC)lpOleDoc;
387: HRESULT hrErr;
388:
389: if (lpServerDoc->m_lpDataAdviseHldr == NULL) {
390: sc = E_FAIL;
391: goto error;
392: }
393:
394: OLEDBG_BEGIN2("IDataAdviseHolder::Unadvise called\r\n");
395: hrErr = lpServerDoc->m_lpDataAdviseHldr->lpVtbl->Unadvise(
396: lpServerDoc->m_lpDataAdviseHldr,
397: dwConnection
398: );
399: OLEDBG_END2
400:
401: OLEDBG_END2
402: return hrErr;
403: }
404: #elif defined( OLE_CNTR )
405: {
406: /* the Container-Only version of Outline does NOT offer
407: ** IDataObject interface from its User documents. this is
408: ** required by objects which can be embedded or linked. the
409: ** Container-only app only allows linking to its contained
410: ** objects, NOT the data of the container itself.
411: */
412: OleDbgAssertSz(0, "User documents do NOT support IDataObject\r\n");
413: sc = E_NOTIMPL;
414: goto error;
415: }
416: #endif
417:
418: error:
419: OLEDBG_END2
420: return ResultFromScode(sc);
421: }
422:
423:
424: STDMETHODIMP OleDoc_DataObj_EnumDAdvise(
425: LPDATAOBJECT lpThis,
426: LPENUMSTATDATA FAR* lplpenumAdvise
427: )
428: {
429: LPOLEDOC lpOleDoc=((struct CDocDataObjectImpl FAR*)lpThis)->lpOleDoc;
430: LPOUTLINEDOC lpOutlineDoc = (LPOUTLINEDOC)lpOleDoc;
431: SCODE sc;
432:
433: OLEDBG_BEGIN2("OleDoc_DataObj_EnumDAdvise\r\n")
434:
435: /* OLE2NOTE: we must make sure to set all out parameters to NULL. */
436: *lplpenumAdvise = NULL;
437:
438: /* OLE2NOTE: a document that is used to transfer data (either via
439: ** the clipboard or drag/drop) does NOT support Advise notifications.
440: */
441: if (lpOutlineDoc->m_fDataTransferDoc) {
442: sc = OLE_E_ADVISENOTSUPPORTED;
443: goto error;
444: }
445:
446: #if defined( OLE_SERVER )
447: {
448: LPSERVERDOC lpServerDoc = (LPSERVERDOC)lpOleDoc;
449: HRESULT hrErr;
450:
451: if (lpServerDoc->m_lpDataAdviseHldr == NULL) {
452: sc = E_FAIL;
453: goto error;
454: }
455:
456: OLEDBG_BEGIN2("IDataAdviseHolder::EnumAdvise called\r\n");
457: hrErr = lpServerDoc->m_lpDataAdviseHldr->lpVtbl->EnumAdvise(
458: lpServerDoc->m_lpDataAdviseHldr,
459: lplpenumAdvise
460: );
461: OLEDBG_END2
462:
463: OLEDBG_END2
464: return hrErr;
465: }
466: #elif defined( OLE_CNTR )
467: {
468: /* the Container-Only version of Outline does NOT offer
469: ** IDataObject interface from its User documents. this is
470: ** required by objects which can be embedded or linked. the
471: ** Container-only app only allows linking to its contained
472: ** objects, NOT the data of the container itself.
473: */
474: OleDbgAssertSz(0, "User documents do NOT support IDataObject\r\n");
475: sc = E_NOTIMPL;
476: goto error;
477: }
478: #endif
479:
480: error:
481: OLEDBG_END2
482: return ResultFromScode(sc);
483: }
484:
485:
486:
487: /*************************************************************************
488: ** OleDoc Supprt Functions common to both Container and Server versions
489: *************************************************************************/
490:
491: /* OleDoc_PasteCommand
492: ** -------------------
493: ** Paste default format data from the clipboard.
494: ** In this function we choose the highest fidelity format that the
495: ** source clipboard IDataObject* offers that we understand.
496: **
497: ** OLE2NOTE: clipboard handling in an OLE 2.0 application is
498: ** different than normal Windows clipboard handling. Data from the
499: ** clipboard is retieved by getting the IDataObject* pointer
500: ** returned by calling OleGetClipboard.
501: */
502: void OleDoc_PasteCommand(LPOLEDOC lpOleDoc)
503: {
504: LPOUTLINEDOC lpOutlineDoc = (LPOUTLINEDOC)lpOleDoc;
505: LPOUTLINEAPP lpOutlineApp = (LPOUTLINEAPP)g_lpApp;
506: LPDATAOBJECT lpClipboardDataObj = NULL;
507: BOOL fLink = FALSE;
508: BOOL fLocalDataObj = FALSE;
509: BOOL fStatus;
510: HRESULT hrErr;
511:
512: hrErr = OleGetClipboard((LPDATAOBJECT FAR*)&lpClipboardDataObj);
513: if (hrErr != NOERROR)
514: return; // Clipboard seems to be empty or can't be accessed
515:
516: OutlineDoc_SetRedraw ( lpOutlineDoc, FALSE );
517:
518: /* check if the data on the clipboard is local to our application
519: ** instance.
520: */
521: if (lpOutlineApp->m_lpClipboardDoc) {
522: LPOLEDOC lpOleDoc = (LPOLEDOC)lpOutlineApp->m_lpClipboardDoc;
523: if (lpClipboardDataObj == (LPDATAOBJECT)&lpOleDoc->m_DataObject)
524: fLocalDataObj = TRUE;
525: }
526:
527: fStatus = OleDoc_PasteFromData(
528: lpOleDoc,
529: lpClipboardDataObj,
530: fLocalDataObj,
531: fLink
532: );
533:
534: OutlineDoc_SetRedraw ( lpOutlineDoc, TRUE );
535:
536: if (! fStatus)
537: OutlineApp_ErrorMessage(g_lpApp,"Could not paste data from clipboard!");
538:
539: if (lpClipboardDataObj)
540: OleStdRelease((LPUNKNOWN)lpClipboardDataObj);
541: }
542:
543:
544: /* OleDoc_PasteSpecialCommand
545: ** --------------------------
546: ** Allow the user to paste data in a particular format from the
547: ** clipboard. The paste special command displays a dialog to the
548: ** user that allows him to choose the format to be pasted from the
549: ** list of formats available.
550: **
551: ** OLE2NOTE: the PasteSpecial dialog is one of the standard OLE 2.0
552: ** UI dialogs for which the dialog is implemented and in the OLE2UI
553: ** library.
554: **
555: ** OLE2NOTE: clipboard handling in an OLE 2.0 application is
556: ** different than normal Windows clipboard handling. Data from the
557: ** clipboard is retieved by getting the IDataObject* pointer
558: ** returned by calling OleGetClipboard.
559: */
560: void OleDoc_PasteSpecialCommand(LPOLEDOC lpOleDoc)
561: {
562: LPOUTLINEDOC lpOutlineDoc = (LPOUTLINEDOC)lpOleDoc;
563: LPOUTLINEAPP lpOutlineApp = (LPOUTLINEAPP)g_lpApp;
564: LPOLEAPP lpOleApp = (LPOLEAPP)g_lpApp;
565: LPDATAOBJECT lpClipboardDataObj = NULL;
566: CLIPFORMAT cfFormat;
567: int nFmtEtc;
568: UINT uInt;
569: BOOL fLink = FALSE;
570: BOOL fLocalDataObj = FALSE;
571: BOOL fStatus;
572: HRESULT hrErr;
573: OLEUIPASTESPECIAL ouiPasteSpl;
574: BOOL fDisplayAsIcon;
575:
576: hrErr = OleGetClipboard((LPDATAOBJECT FAR*)&lpClipboardDataObj);
577: if (hrErr != NOERROR)
578: return; // Clipboard seems to be empty or can't be accessed
579:
580: /* check if the data on the clipboard is local to our application
581: ** instance.
582: */
583: if (lpOutlineApp->m_lpClipboardDoc) {
584: LPOLEDOC lpOleDoc = (LPOLEDOC)lpOutlineApp->m_lpClipboardDoc;
585: if (lpClipboardDataObj == (LPDATAOBJECT)&lpOleDoc->m_DataObject)
586: fLocalDataObj = TRUE;
587: }
588:
589: /* Display the PasteSpecial dialog and allow the user to select the
590: ** format to paste.
591: */
592: ouiPasteSpl.cbStruct = sizeof(OLEUIPASTESPECIAL); //Structure Size
593: ouiPasteSpl.dwFlags = PSF_SELECTPASTE | PSF_SHOWHELP; //IN-OUT: Flags
594: ouiPasteSpl.hWndOwner = lpOutlineApp->m_lpDoc->m_hWndDoc; //Owning window
595: ouiPasteSpl.lpszCaption = "Paste Special"; //Dialog caption bar contents
596: ouiPasteSpl.lpfnHook = NULL; //Hook callback
597: ouiPasteSpl.lCustData = 0; //Custom data to pass to hook
598: ouiPasteSpl.hInstance = NULL; //Instance for customized template name
599: ouiPasteSpl.lpszTemplate = NULL; //Customized template name
600: ouiPasteSpl.hResource = NULL; //Customized template handle
601:
602: ouiPasteSpl.arrPasteEntries = lpOleApp->m_arrPasteEntries;
603: ouiPasteSpl.cPasteEntries = lpOleApp->m_nPasteEntries;
604: ouiPasteSpl.lpSrcDataObj = lpClipboardDataObj;
605: ouiPasteSpl.arrLinkTypes = lpOleApp->m_arrLinkTypes;
606: ouiPasteSpl.cLinkTypes = lpOleApp->m_nLinkTypes;
607:
608:
609: OLEDBG_BEGIN3("OleUIPasteSpecial called\r\n")
610: uInt = OleUIPasteSpecial(&ouiPasteSpl);
611: OLEDBG_END3
612:
613: fDisplayAsIcon =
614: (ouiPasteSpl.dwFlags & PSF_CHECKDISPLAYASICON ? TRUE : FALSE);
615:
616: if (uInt == OLEUI_OK) {
617: nFmtEtc = ouiPasteSpl.nSelectedIndex;
618: fLink = ouiPasteSpl.fLink;
619:
620: if (nFmtEtc < 0 || nFmtEtc >= lpOleApp->m_nPasteEntries) {
621: OutlineApp_ErrorMessage(lpOutlineApp, ErrMsgBadFmt);
622: goto error;
623: }
624:
625: OutlineDoc_SetRedraw ( lpOutlineDoc, FALSE );
626:
627: cfFormat = lpOleApp->m_arrPasteEntries[nFmtEtc].fmtetc.cfFormat;
628:
629: fStatus = OleDoc_PasteFormatFromData(
630: lpOleDoc,
631: cfFormat,
632: lpClipboardDataObj,
633: fLocalDataObj,
634: fLink,
635: fDisplayAsIcon,
636: ouiPasteSpl.hMetaPict
637: );
638:
639: OutlineDoc_SetRedraw ( lpOutlineDoc, TRUE );
640:
641: if (! fStatus) {
642: OutlineApp_ErrorMessage(lpOutlineApp, ErrMsgPasteFailed);
643: goto error;
644: }
645:
646: if (ouiPasteSpl.hMetaPict) {
647: // clean up metafile
648: OleUIMetafilePictIconFree(ouiPasteSpl.hMetaPict);
649: }
650:
651: }
652:
653: if (lpClipboardDataObj)
654: OleStdRelease((LPUNKNOWN)lpClipboardDataObj);
655:
656: return;
657:
658: error:
659:
660: if (lpClipboardDataObj)
661: OleStdRelease((LPUNKNOWN)lpClipboardDataObj);
662:
663: if (uInt == OLEUI_OK && ouiPasteSpl.hMetaPict)
664: // clean up metafile
665: OleUIMetafilePictIconFree(ouiPasteSpl.hMetaPict);
666: }
667:
668:
669: /* OleDoc_PasteFromData
670: ** --------------------
671: **
672: ** Paste data from an IDataObject*. The IDataObject* may come from
673: ** the clipboard (GetClipboard) or from a drag/drop operation.
674: ** In this function we choose the best format that we prefer.
675: **
676: ** Returns TRUE if data was successfully pasted.
677: ** FALSE if data could not be pasted.
678: */
679:
680: BOOL OleDoc_PasteFromData(
681: LPOLEDOC lpOleDoc,
682: LPDATAOBJECT lpSrcDataObj,
683: BOOL fLocalDataObj,
684: BOOL fLink
685: )
686: {
687: LPOLEAPP lpOleApp = (LPOLEAPP)g_lpApp;
688: CLIPFORMAT cfFormat;
689: BOOL fDisplayAsIcon = FALSE;
690: HGLOBAL hMem = NULL;
691: HGLOBAL hMetaPict = NULL;
692: STGMEDIUM medium;
693:
694: if (fLink) {
695: #if defined( OLE_SERVER )
696:
697: return FALSE; // server version of app does NOT support links
698:
699: #elif defined( OLE_CNTR )
700:
701: // container version of app only supports OLE object type links
702: cfFormat = lpOleApp->m_cfLinkSource;
703: #endif
704:
705: } else {
706:
707: int nFmtEtc;
708:
709: nFmtEtc = OleStdGetPriorityClipboardFormat(
710: lpSrcDataObj,
711: lpOleApp->m_arrPasteEntries,
712: lpOleApp->m_nPasteEntries
713: );
714:
715: if (nFmtEtc < 0)
716: return FALSE; // there is no format we like
717:
718: cfFormat = lpOleApp->m_arrPasteEntries[nFmtEtc].fmtetc.cfFormat;
719: }
720:
721: /* OLE2NOTE: we need to check what dwDrawAspect is being
722: ** transfered. if the data is an object that is displayed as an
723: ** icon in the source, then we want to keep it as an icon. the
724: ** aspect the object is displayed in at the source is transfered
725: ** via the CF_OBJECTDESCRIPTOR format for a Paste operation.
726: */
727: if (hMem = OleStdGetData(
728: lpSrcDataObj,
729: lpOleApp->m_cfObjectDescriptor,
730: NULL,
731: DVASPECT_CONTENT,
732: (LPSTGMEDIUM)&medium)) {
733: LPOBJECTDESCRIPTOR lpOD = GlobalLock(hMem);
734: fDisplayAsIcon = (lpOD->dwDrawAspect == DVASPECT_ICON ? TRUE : FALSE);
735: GlobalUnlock(hMem);
736: ReleaseStgMedium((LPSTGMEDIUM)&medium); // equiv to GlobalFree
737:
738: if (fDisplayAsIcon) {
739: hMetaPict = OleStdGetData(
740: lpSrcDataObj,
741: CF_METAFILEPICT,
742: NULL,
743: DVASPECT_ICON,
744: (LPSTGMEDIUM)&medium
745: );
746: if (hMetaPict == NULL)
747: fDisplayAsIcon = FALSE; // give up; failed to get icon MFP
748: }
749: }
750:
751: return OleDoc_PasteFormatFromData(
752: lpOleDoc,
753: cfFormat,
754: lpSrcDataObj,
755: fLocalDataObj,
756: fLink,
757: fDisplayAsIcon,
758: hMetaPict
759: );
760:
761: if (hMetaPict)
762: ReleaseStgMedium((LPSTGMEDIUM)&medium); // properly free METAFILEPICT
763: }
764:
765:
766: /* OleDoc_PasteFormatFromData
767: ** --------------------------
768: **
769: ** Paste a particular data format from a IDataObject*. The
770: ** IDataObject* may come from the clipboard (GetClipboard) or from a
771: ** drag/drop operation.
772: **
773: ** Returns TRUE if data was successfully pasted.
774: ** FALSE if data could not be pasted.
775: */
776:
777: BOOL OleDoc_PasteFormatFromData(
778: LPOLEDOC lpOleDoc,
779: CLIPFORMAT cfFormat,
780: LPDATAOBJECT lpSrcDataObj,
781: BOOL fLocalDataObj,
782: BOOL fLink,
783: BOOL fDisplayAsIcon,
784: HGLOBAL hMetaPict
785: )
786: {
787: #if defined( OLE_SERVER )
788:
789: /* call server specific version of the function. */
790: return ServerDoc_PasteFormatFromData(
791: (LPSERVERDOC)lpOleDoc,
792: cfFormat,
793: lpSrcDataObj,
794: fLocalDataObj,
795: fLink
796: );
797:
798: #elif defined( OLE_CNTR )
799:
800: /* call container specific version of the function. */
801: return ContainerDoc_PasteFormatFromData(
802: (LPCONTAINERDOC)lpOleDoc,
803: cfFormat,
804: lpSrcDataObj,
805: fLocalDataObj,
806: fLink,
807: fDisplayAsIcon,
808: hMetaPict
809: );
810:
811: #endif
812: }
813:
814:
815: /* OleDoc_QueryPasteFromData
816: ** -------------------------
817: **
818: ** Check if the IDataObject* offers data in a format that we can
819: ** paste. The IDataObject* may come from the clipboard
820: ** (GetClipboard) or from a drag/drop operation.
821: **
822: ** Returns TRUE if paste can be performed
823: ** FALSE if paste is not possible.
824: */
825:
826: BOOL OleDoc_QueryPasteFromData(
827: LPOLEDOC lpOleDoc,
828: LPDATAOBJECT lpSrcDataObj,
829: BOOL fLink
830: )
831: {
832: #if defined( OLE_SERVER )
833:
834: return ServerDoc_QueryPasteFromData(
835: (LPSERVERDOC) lpOleDoc,
836: lpSrcDataObj,
837: fLink
838: );
839:
840: #elif defined( OLE_CNTR )
841:
842: return ContainerDoc_QueryPasteFromData(
843: (LPCONTAINERDOC) lpOleDoc,
844: lpSrcDataObj,
845: fLink
846: );
847:
848: #endif
849: }
850:
851:
852: /* OleDoc_GetExtent
853: * ----------------
854: *
855: * Get the extent (width, height) of the entire document in Himetric.
856: */
857: void OleDoc_GetExtent(LPOLEDOC lpOleDoc, LPSIZEL lpsizel)
858: {
859: LPLINELIST lpLL = (LPLINELIST)&((LPOUTLINEDOC)lpOleDoc)->m_LineList;
860:
861: LineList_CalcSelExtentInHimetric(lpLL, NULL, lpsizel);
862: }
863:
864:
865: /* OleDoc_GetObjectDescriptorData
866: * ------------------------------
867: *
868: * Return a handle to an object's data in CF_OBJECTDESCRIPTOR form
869: *
870: */
871: HGLOBAL OleDoc_GetObjectDescriptorData(LPOLEDOC lpOleDoc, LPLINERANGE lplrSel)
872: {
873: LPOUTLINEDOC lpOutlineDoc = (LPOUTLINEDOC)lpOleDoc;
874:
875: /* Only our data transfer doc renders CF_OBJECTDESCRIPTOR */
876: OleDbgAssert(lpOutlineDoc->m_fDataTransferDoc);
877:
878: #if defined( OLE_SERVER )
879: {
880: LPSERVERDOC lpServerDoc = (LPSERVERDOC)lpOleDoc;
881: SIZEL sizel;
882: POINTL pointl;
883: LPSTR lpszSrcOfCopy = NULL;
884: IBindCtx FAR *pbc = NULL;
885: HGLOBAL hObjDesc;
886: DWORD dwStatus = 0;
887: LPOUTLINEDOC lpSrcDocOfCopy=(LPOUTLINEDOC)lpOleDoc->m_lpSrcDocOfCopy;
888: LPMONIKER lpSrcMonikerOfCopy = ServerDoc_GetSelFullMoniker(
889: (LPSERVERDOC)lpOleDoc->m_lpSrcDocOfCopy,
890: &lpServerDoc->m_lrSrcSelOfCopy,
891: GETMONIKER_TEMPFORUSER
892: );
893:
894: SvrDoc_OleObj_GetMiscStatus(
895: (LPOLEOBJECT)&lpServerDoc->m_OleObject,
896: DVASPECT_CONTENT,
897: &dwStatus
898: );
899:
900: OleDoc_GetExtent(lpOleDoc, &sizel);
901: pointl.x = pointl.y = 0;
902:
903: if (lpSrcMonikerOfCopy) {
904: CreateBindCtx(0, (LPBC FAR*)&pbc);
905: lpSrcMonikerOfCopy->lpVtbl->GetDisplayName(
906: lpSrcMonikerOfCopy, pbc, NULL, &lpszSrcOfCopy);
907: pbc->lpVtbl->Release(pbc);
908: lpSrcMonikerOfCopy->lpVtbl->Release(lpSrcMonikerOfCopy);
909: } else {
910: /* this document has no moniker; use our FullUserTypeName
911: ** as the description of the source of copy.
912: */
913: lpszSrcOfCopy = FULLUSERTYPENAME;
914: }
915:
916: hObjDesc = OleStdGetObjectDescriptorData(
917: CLSID_APP,
918: DVASPECT_CONTENT,
919: sizel,
920: pointl,
921: dwStatus,
922: FULLUSERTYPENAME,
923: lpszSrcOfCopy
924: );
925:
926: if (lpSrcMonikerOfCopy && lpszSrcOfCopy)
927: OleStdFreeString(lpszSrcOfCopy, NULL);
928: return hObjDesc;
929:
930: }
931: #elif defined( OLE_CNTR )
932: {
933: LPCONTAINERDOC lpContainerDoc = (LPCONTAINERDOC)lpOleDoc;
934: LPLINELIST lpLL = (LPLINELIST)&((LPOUTLINEDOC)lpOleDoc)->m_LineList;
935: LPCONTAINERLINE lpContainerLine;
936: HGLOBAL hObjDesc;
937: BOOL fSelIsOleObject = FALSE;
938: LPOLEOBJECT lpOleObj;
939: SIZEL sizel;
940: POINTL pointl;
941:
942: if ( lpLL->m_nNumLines == 1 ) {
943: fSelIsOleObject = ContainerDoc_IsSelAnOleObject(
944: lpContainerDoc,
945: &IID_IOleObject,
946: (LPUNKNOWN FAR*)&lpOleObj,
947: NULL, /* we don't need the line index */
948: (LPCONTAINERLINE FAR*)&lpContainerLine
949: );
950: }
951:
952: pointl.x = pointl.y = 0;
953:
954: if (fSelIsOleObject) {
955: /* OLE2NOTE: a single OLE object is being transfered via
956: ** this DataTransferDoc. we need to generate the
957: ** CF_ObjectDescrioptor which describes the OLE object.
958: */
959:
960: LPOUTLINEDOC lpSrcOutlineDoc =
961: (LPOUTLINEDOC)lpOleDoc->m_lpSrcDocOfCopy;
962: LPSTR lpszSrcOfCopy = lpSrcOutlineDoc->m_szFileName;
963: BOOL fFreeSrcOfCopy = FALSE;
964:
965: /* if the object copied can be linked to then get a
966: ** TEMPFORUSER form of the moniker which identifies the
967: ** source of copy. we do not want to force the
968: ** assignment of the moniker until CF_LINKSOURCE is
969: ** rendered.
970: ** if the object copied can not be a link source then use
971: ** the source filename to identify the source of copy.
972: ** there is no need to generate a moniker for the object
973: ** copied.
974: */
975: if (lpOleDoc->m_fLinkSourceAvail &&
976: lpContainerDoc->m_lpSrcContainerLine) {
977: LPBINDCTX pbc = NULL;
978: LPMONIKER lpSrcMonikerOfCopy = ContainerLine_GetFullMoniker(
979: lpContainerDoc->m_lpSrcContainerLine,
980: GETMONIKER_TEMPFORUSER
981: );
982: if (lpSrcMonikerOfCopy) {
983: CreateBindCtx(0, (LPBC FAR*)&pbc);
984: if (pbc != NULL) {
985: lpSrcMonikerOfCopy->lpVtbl->GetDisplayName(
986: lpSrcMonikerOfCopy, pbc, NULL,&lpszSrcOfCopy);
987: pbc->lpVtbl->Release(pbc);
988: fFreeSrcOfCopy = TRUE;
989: }
990: lpSrcMonikerOfCopy->lpVtbl->Release(lpSrcMonikerOfCopy);
991: }
992: }
993:
994: hObjDesc = OleStdGetObjectDescriptorDataFromOleObject(
995: lpOleObj,
996: lpszSrcOfCopy,
997: lpContainerLine->m_dwDrawAspect,
998: pointl
999: );
1000:
1001: if (fFreeSrcOfCopy && lpszSrcOfCopy)
1002: OleStdFreeString(lpszSrcOfCopy, NULL);
1003: OleStdRelease((LPUNKNOWN)lpOleObj);
1004: return hObjDesc;
1005: } else {
1006: /* OLE2NOTE: the data being transfered via this
1007: ** DataTransferDoc is NOT a single OLE object. thus in
1008: ** this case the CF_ObjectDescriptor data should
1009: ** describe our container app itself.
1010: */
1011: OleDoc_GetExtent(lpOleDoc, &sizel);
1012: return OleStdGetObjectDescriptorData(
1013: CLSID_NULL, /* not used if no object formats */
1014: DVASPECT_CONTENT,
1015: sizel,
1016: pointl,
1017: 0,
1018: NULL, /* UserTypeName not used if no obj fmt's */
1019: FULLUSERTYPENAME /* string to identify source of copy */
1020: );
1021:
1022: }
1023: }
1024: #endif
1025: }
1026:
1027:
1028: #if defined( OLE_SERVER )
1029:
1030: /*************************************************************************
1031: ** ServerDoc Supprt Functions Used by Server versions
1032: *************************************************************************/
1033:
1034:
1035: /* ServerDoc_PasteFormatFromData
1036: ** -----------------------------
1037: **
1038: ** Paste a particular data format from a IDataObject*. The
1039: ** IDataObject* may come from the clipboard (GetClipboard) or from a
1040: ** drag/drop operation.
1041: **
1042: ** NOTE: fLink is specified then FALSE if returned because the
1043: ** Server only version of the app can not support links.
1044: **
1045: ** Returns TRUE if data was successfully pasted.
1046: ** FALSE if data could not be pasted.
1047: */
1048: BOOL ServerDoc_PasteFormatFromData(
1049: LPSERVERDOC lpServerDoc,
1050: CLIPFORMAT cfFormat,
1051: LPDATAOBJECT lpSrcDataObj,
1052: BOOL fLocalDataObj,
1053: BOOL fLink
1054: )
1055: {
1056: LPLINELIST lpLL = (LPLINELIST)&((LPOUTLINEDOC)lpServerDoc)->m_LineList;
1057: LPOUTLINEAPP lpOutlineApp = (LPOUTLINEAPP)g_lpApp;
1058: LPOLEAPP lpOleApp = (LPOLEAPP)g_lpApp;
1059: int nIndex;
1060: int nCount = 0;
1061: HGLOBAL hData;
1062: STGMEDIUM medium;
1063: LINERANGE lrSel;
1064:
1065: if (LineList_GetCount(lpLL) == 0)
1066: nIndex = -1; // pasting to empty list
1067: else
1068: nIndex=LineList_GetFocusLineIndex(lpLL);
1069:
1070: if (fLink) {
1071: /* We should paste a Link to the data, but we do not support links */
1072: return FALSE;
1073:
1074: } else {
1075:
1076: if (cfFormat == lpOutlineApp->m_cfOutline) {
1077:
1078: hData = OleStdGetData(
1079: lpSrcDataObj,
1080: lpOutlineApp->m_cfOutline,
1081: NULL,
1082: DVASPECT_CONTENT,
1083: (LPSTGMEDIUM)&medium
1084: );
1085: if (hData == NULL)
1086: return FALSE;
1087:
1088: nCount = OutlineDoc_PasteOutlineData(
1089: (LPOUTLINEDOC)lpServerDoc,
1090: hData,
1091: nIndex
1092: );
1093: // OLE2NOTE: we must free data handle by releasing the medium
1094: ReleaseStgMedium((LPSTGMEDIUM)&medium);
1095:
1096: } else if(cfFormat == CF_TEXT) {
1097:
1098: hData = OleStdGetData(
1099: lpSrcDataObj,
1100: CF_TEXT,
1101: NULL,
1102: DVASPECT_CONTENT,
1103: (LPSTGMEDIUM)&medium
1104: );
1105: if (hData == NULL)
1106: return FALSE;
1107:
1108: nCount = OutlineDoc_PasteTextData(
1109: (LPOUTLINEDOC)lpServerDoc,
1110: hData,
1111: nIndex
1112: );
1113: // OLE2NOTE: we must free data handle by releasing the medium
1114: ReleaseStgMedium((LPSTGMEDIUM)&medium);
1115: }
1116: }
1117:
1118: lrSel.m_nEndLine = nIndex + 1;
1119: lrSel.m_nStartLine = nIndex + nCount;
1120: LineList_SetSel(lpLL, &lrSel);
1121: return TRUE;
1122: }
1123:
1124:
1125: /* ServerDoc_QueryPasteFromData
1126: ** ----------------------------
1127: **
1128: ** Check if the IDataObject* offers data in a format that we can
1129: ** paste. The IDataObject* may come from the clipboard
1130: ** (GetClipboard) or from a drag/drop operation.
1131: ** In this function we look if one of the following formats is
1132: ** offered:
1133: ** CF_OUTLINE
1134: ** CF_TEXT
1135: **
1136: ** NOTE: fLink is specified then FALSE if returned because the
1137: ** Server only version of the app can not support links.
1138: **
1139: ** Returns TRUE if paste can be performed
1140: ** FALSE if paste is not possible.
1141: */
1142: BOOL ServerDoc_QueryPasteFromData(
1143: LPSERVERDOC lpServerDoc,
1144: LPDATAOBJECT lpSrcDataObj,
1145: BOOL fLink
1146: )
1147: {
1148: LPOLEAPP lpOleApp = (LPOLEAPP)g_lpApp;
1149:
1150: if (fLink) {
1151: /* we do not support links */
1152: return FALSE;
1153:
1154: } else {
1155:
1156: int nFmtEtc;
1157:
1158: nFmtEtc = OleStdGetPriorityClipboardFormat(
1159: lpSrcDataObj,
1160: lpOleApp->m_arrPasteEntries,
1161: lpOleApp->m_nPasteEntries
1162: );
1163:
1164: if (nFmtEtc < 0)
1165: return FALSE; // there is no format we like
1166: }
1167:
1168: return TRUE;
1169: }
1170:
1171:
1172: /* ServerDoc_GetData
1173: * -----------------
1174: *
1175: * Render data from the document on a CALLEE allocated STGMEDIUM.
1176: * This routine is called via IDataObject::GetData.
1177: */
1178:
1179: HRESULT ServerDoc_GetData (
1180: LPSERVERDOC lpServerDoc,
1181: LPFORMATETC lpformatetc,
1182: LPSTGMEDIUM lpMedium
1183: )
1184: {
1185: LPOLEDOC lpOleDoc = (LPOLEDOC)lpServerDoc;
1186: LPOUTLINEDOC lpOutlineDoc = (LPOUTLINEDOC)lpServerDoc;
1187: LPSERVERAPP lpServerApp = (LPSERVERAPP)g_lpApp;
1188: LPOLEAPP lpOleApp = (LPOLEAPP)lpServerApp;
1189: LPOUTLINEAPP lpOutlineApp = (LPOUTLINEAPP)lpServerApp;
1190: HRESULT hrErr;
1191: SCODE sc;
1192:
1193: // OLE2NOTE: we must set out pointer parameters to NULL
1194: lpMedium->pUnkForRelease = NULL;
1195:
1196: /* OLE2NOTE: we must make sure to set all out parameters to NULL. */
1197: lpMedium->tymed = TYMED_NULL;
1198: lpMedium->pUnkForRelease = NULL; // we transfer ownership to caller
1199: lpMedium->u.hGlobal = NULL;
1200:
1201: if(lpformatetc->cfFormat == lpOutlineApp->m_cfOutline) {
1202: // Verify caller asked for correct medium
1203: if (!(lpformatetc->tymed & TYMED_HGLOBAL)) {
1204: sc = DATA_E_FORMATETC;
1205: goto error;
1206: }
1207: lpMedium->u.hGlobal = OutlineDoc_GetOutlineData (lpOutlineDoc,NULL);
1208: if (! lpMedium->u.hGlobal) {
1209: sc = E_OUTOFMEMORY;
1210: goto error;
1211: }
1212:
1213: lpMedium->tymed = TYMED_HGLOBAL;
1214: OleDbgOut3("ServerDoc_GetData: rendered CF_OUTLINE\r\n");
1215: return NOERROR;
1216:
1217: } else if (lpformatetc->cfFormat == CF_METAFILEPICT &&
1218: (lpformatetc->dwAspect & (DVASPECT_CONTENT | DVASPECT_DOCPRINT)) ) {
1219: // Verify caller asked for correct medium
1220: if (!(lpformatetc->tymed & TYMED_MFPICT)) {
1221: sc = DATA_E_FORMATETC;
1222: goto error;
1223: }
1224:
1225: lpMedium->u.hGlobal = ServerDoc_GetMetafilePictData(lpServerDoc,NULL);
1226: if (! lpMedium->u.hGlobal) {
1227: sc = E_OUTOFMEMORY;
1228: goto error;
1229: }
1230:
1231: lpMedium->tymed = TYMED_MFPICT;
1232: OleDbgOut3("ServerDoc_GetData: rendered CF_METAFILEPICT\r\n");
1233: return NOERROR;
1234:
1235: } else if (lpformatetc->cfFormat == CF_METAFILEPICT &&
1236: (lpformatetc->dwAspect & DVASPECT_ICON) ) {
1237: CLSID clsid;
1238: // Verify caller asked for correct medium
1239: if (!(lpformatetc->tymed & TYMED_MFPICT)) {
1240: sc = DATA_E_FORMATETC;
1241: goto error;
1242: }
1243:
1244: /* OLE2NOTE: we should return the default icon for our class.
1245: ** we must be carefull to use the correct CLSID here.
1246: ** if we are currently preforming a "TreatAs (aka. ActivateAs)"
1247: ** operation then we need to use the class of the object
1248: ** written in the storage of the object. otherwise we would
1249: ** use our own class id.
1250: */
1251: if (ServerDoc_GetClassID(lpServerDoc, (LPCLSID)&clsid) != NOERROR) {
1252: sc = DATA_E_FORMATETC;
1253: goto error;
1254: }
1255:
1256: lpMedium->u.hGlobal=GetIconOfClass(g_lpApp->m_hInst,(REFCLSID)&clsid, NULL, FALSE);
1257: if (! lpMedium->u.hGlobal) {
1258: sc = E_OUTOFMEMORY;
1259: goto error;
1260: }
1261:
1262: lpMedium->tymed = TYMED_MFPICT;
1263: OleDbgOut3("ServerDoc_GetData: rendered CF_METAFILEPICT (icon)\r\n");
1264: return NOERROR;
1265:
1266: } else if (lpformatetc->cfFormat == CF_TEXT) {
1267: // Verify caller asked for correct medium
1268: if (!(lpformatetc->tymed & TYMED_HGLOBAL)) {
1269: sc = DATA_E_FORMATETC;
1270: goto error;
1271: }
1272:
1273: lpMedium->u.hGlobal = OutlineDoc_GetTextData (
1274: (LPOUTLINEDOC)lpServerDoc,
1275: NULL
1276: );
1277: if (! lpMedium->u.hGlobal) {
1278: sc = E_OUTOFMEMORY;
1279: goto error;
1280: }
1281:
1282: lpMedium->tymed = TYMED_HGLOBAL;
1283: OleDbgOut3("ServerDoc_GetData: rendered CF_TEXT\r\n");
1284: return NOERROR;
1285: }
1286:
1287: /* the above are the only formats supports by a user document (ie.
1288: ** a non-data transfer doc). if the document is used for
1289: ** purposes of data transfer, then additional formats are offered.
1290: */
1291: if (! lpOutlineDoc->m_fDataTransferDoc) {
1292: sc = DATA_E_FORMATETC;
1293: goto error;
1294: }
1295:
1296: /* OLE2NOTE: ObjectDescriptor and LinkSrcDescriptor will
1297: ** contain the same data for the pure container and pure server
1298: ** type applications. only a container/server application may
1299: ** have different content for ObjectDescriptor and
1300: ** LinkSrcDescriptor. if a container/server copies a link for
1301: ** example, then the ObjectDescriptor would give the class
1302: ** of the link source but the LinkSrcDescriptor would give the
1303: ** class of the container/server itself. in this situation if a
1304: ** paste operation occurs, an equivalent link is pasted, but if
1305: ** a pastelink operation occurs, then a link to a pseudo object
1306: ** in the container/server is created.
1307: */
1308: if (lpformatetc->cfFormat == lpOleApp->m_cfObjectDescriptor ||
1309: (lpformatetc->cfFormat == lpOleApp->m_cfLinkSrcDescriptor &&
1310: lpOleDoc->m_fLinkSourceAvail)) {
1311: // Verify caller asked for correct medium
1312: if (!(lpformatetc->tymed & TYMED_HGLOBAL)) {
1313: sc = DATA_E_FORMATETC;
1314: goto error;
1315: }
1316:
1317: lpMedium->u.hGlobal = OleDoc_GetObjectDescriptorData (
1318: (LPOLEDOC)lpServerDoc,
1319: NULL
1320: );
1321: if (! lpMedium->u.hGlobal) {
1322: sc = E_OUTOFMEMORY;
1323: goto error;
1324: }
1325:
1326: lpMedium->tymed = TYMED_HGLOBAL;
1327: OleDbgOut3("ServerDoc_GetData: rendered CF_OBJECTDESCRIPTOR\r\n");
1328: return NOERROR;
1329:
1330: } else if (lpformatetc->cfFormat == lpOleApp->m_cfEmbedSource) {
1331: hrErr = OleStdGetOleObjectData(
1332: (LPPERSISTSTORAGE)&lpServerDoc->m_PersistStorage,
1333: lpformatetc,
1334: lpMedium,
1335: FALSE /* fUseMemory -- (use file-base stg) */
1336:
1337: );
1338: if (hrErr != NOERROR) {
1339: sc = GetScode(hrErr);
1340: goto error;
1341: }
1342: OleDbgOut3("ServerDoc_GetData: rendered CF_EMBEDSOURCE\r\n");
1343: return NOERROR;
1344:
1345: } else if (lpformatetc->cfFormat == lpOleApp->m_cfLinkSource) {
1346: if (lpOleDoc->m_fLinkSourceAvail) {
1347: LPMONIKER lpmk;
1348:
1349: lpmk = ServerDoc_GetSelFullMoniker(
1350: (LPSERVERDOC)lpOleDoc->m_lpSrcDocOfCopy,
1351: &lpServerDoc->m_lrSrcSelOfCopy,
1352: GETMONIKER_FORCEASSIGN
1353: );
1354: if (lpmk) {
1355: hrErr = OleStdGetLinkSourceData(
1356: lpmk,
1357: (LPCLSID)&CLSID_APP,
1358: lpformatetc,
1359: lpMedium
1360: );
1361: OleStdRelease((LPUNKNOWN)lpmk);
1362: if (hrErr != NOERROR) {
1363: sc = GetScode(hrErr);
1364: goto error;
1365: }
1366: OleDbgOut3("ServerDoc_GetData: rendered CF_LINKSOURCE\r\n");
1367: return NOERROR;
1368:
1369: } else {
1370: sc = E_FAIL;
1371: goto error;
1372: }
1373: } else {
1374: sc = DATA_E_FORMATETC;
1375: goto error;
1376: }
1377:
1378: } else {
1379: sc = DATA_E_FORMATETC;
1380: goto error;
1381: }
1382:
1383: return NOERROR;
1384:
1385: error:
1386: return ResultFromScode(sc);
1387: }
1388:
1389:
1390: /* ServerDoc_GetDataHere
1391: * ---------------------
1392: *
1393: * Render data from the document on a CALLER allocated STGMEDIUM.
1394: * This routine is called via IDataObject::GetDataHere.
1395: */
1396: HRESULT ServerDoc_GetDataHere (
1397: LPSERVERDOC lpServerDoc,
1398: LPFORMATETC lpformatetc,
1399: LPSTGMEDIUM lpMedium
1400: )
1401: {
1402: LPOLEDOC lpOleDoc = (LPOLEDOC)lpServerDoc;
1403: LPOUTLINEDOC lpOutlineDoc = (LPOUTLINEDOC)lpServerDoc;
1404: LPSERVERAPP lpServerApp = (LPSERVERAPP)g_lpApp;
1405: LPOLEAPP lpOleApp = (LPOLEAPP)lpServerApp;
1406: LPOUTLINEAPP lpOutlineApp = (LPOUTLINEAPP)lpServerApp;
1407: HRESULT hrErr;
1408: SCODE sc;
1409:
1410: // OLE2NOTE: we must set out pointer parameters to NULL
1411: lpMedium->pUnkForRelease = NULL;
1412:
1413: /* our user document does not support any formats for GetDataHere.
1414: ** if the document is used for
1415: ** purposes of data transfer, then additional formats are offered.
1416: */
1417: if (! lpOutlineDoc->m_fDataTransferDoc) {
1418: sc = DATA_E_FORMATETC;
1419: goto error;
1420: }
1421:
1422: if (lpformatetc->cfFormat == lpOleApp->m_cfEmbedSource) {
1423: hrErr = OleStdGetOleObjectData(
1424: (LPPERSISTSTORAGE)&lpServerDoc->m_PersistStorage,
1425: lpformatetc,
1426: lpMedium,
1427: FALSE /* fUseMemory -- (use file-base stg) */
1428: );
1429: if (hrErr != NOERROR) {
1430: sc = GetScode(hrErr);
1431: goto error;
1432: }
1433: OleDbgOut3("ServerDoc_GetDataHere: rendered CF_EMBEDSOURCE\r\n");
1434: return NOERROR;
1435:
1436: } else if (lpformatetc->cfFormat == lpOleApp->m_cfLinkSource) {
1437: if (lpOleDoc->m_fLinkSourceAvail) {
1438: LPMONIKER lpmk;
1439:
1440: lpmk = ServerDoc_GetSelFullMoniker(
1441: (LPSERVERDOC)lpOleDoc->m_lpSrcDocOfCopy,
1442: &lpServerDoc->m_lrSrcSelOfCopy,
1443: GETMONIKER_FORCEASSIGN
1444: );
1445: if (lpmk) {
1446: hrErr = OleStdGetLinkSourceData(
1447: lpmk,
1448: (LPCLSID)&CLSID_APP,
1449: lpformatetc,
1450: lpMedium
1451: );
1452: OleStdRelease((LPUNKNOWN)lpmk);
1453: if (hrErr != NOERROR) {
1454: sc = GetScode(hrErr);
1455: goto error;
1456: }
1457:
1458: OleDbgOut3(
1459: "ServerDoc_GetDataHere: rendered CF_LINKSOURCE\r\n");
1460: return NOERROR;
1461:
1462: } else {
1463: sc = E_FAIL;
1464: goto error;
1465: }
1466: } else {
1467: sc = DATA_E_FORMATETC;
1468: goto error;
1469: }
1470: } else {
1471:
1472: /* Caller is requesting data to be returned in Caller allocated
1473: ** medium, but we do NOT support this. we only support
1474: ** global memory blocks that WE allocate for the caller.
1475: */
1476: sc = DATA_E_FORMATETC;
1477: goto error;
1478: }
1479:
1480: return NOERROR;
1481:
1482: error:
1483: return ResultFromScode(sc);
1484: }
1485:
1486:
1487: /* ServerDoc_QueryGetData
1488: * ----------------------
1489: *
1490: * Answer if a particular data format is supported via GetData/GetDataHere.
1491: * This routine is called via IDataObject::QueryGetData.
1492: */
1493:
1494: HRESULT ServerDoc_QueryGetData (LPSERVERDOC lpServerDoc,LPFORMATETC lpformatetc)
1495: {
1496: LPOLEDOC lpOleDoc = (LPOLEDOC)lpServerDoc;
1497: LPOUTLINEDOC lpOutlineDoc = (LPOUTLINEDOC)lpServerDoc;
1498: LPSERVERAPP lpServerApp = (LPSERVERAPP)g_lpApp;
1499: LPOLEAPP lpOleApp = (LPOLEAPP)lpServerApp;
1500: LPOUTLINEAPP lpOutlineApp = (LPOUTLINEAPP)lpServerApp;
1501:
1502: /* Caller is querying if we support certain format but does not
1503: ** want any data actually returned.
1504: */
1505: if (lpformatetc->cfFormat == lpOutlineApp->m_cfOutline ||
1506: lpformatetc->cfFormat == CF_TEXT) {
1507: // we only support HGLOBAL
1508: return OleStdQueryFormatMedium(lpformatetc, TYMED_HGLOBAL);
1509: } else if (lpformatetc->cfFormat == CF_METAFILEPICT &&
1510: (lpformatetc->dwAspect &
1511: (DVASPECT_CONTENT | DVASPECT_CONTENT | DVASPECT_DOCPRINT)) ) {
1512: return OleStdQueryFormatMedium(lpformatetc, TYMED_MFPICT);
1513: }
1514:
1515: /* the above are the only formats supports by a user document (ie.
1516: ** a non-data transfer doc). if the document is used for
1517: ** purposes of data transfer, then additional formats are offered.
1518: */
1519: if (! lpOutlineDoc->m_fDataTransferDoc)
1520: return ResultFromScode(DATA_E_FORMATETC);
1521:
1522: if (lpformatetc->cfFormat == lpOleApp->m_cfEmbedSource) {
1523: return OleStdQueryOleObjectData(lpformatetc);
1524:
1525: } else if (lpformatetc->cfFormat == lpOleApp->m_cfLinkSource &&
1526: lpOleDoc->m_fLinkSourceAvail) {
1527: return OleStdQueryLinkSourceData(lpformatetc);
1528:
1529: } else if (lpformatetc->cfFormat == lpOleApp->m_cfObjectDescriptor) {
1530: return OleStdQueryObjectDescriptorData(lpformatetc);
1531:
1532: } else if (lpformatetc->cfFormat == lpOleApp->m_cfLinkSrcDescriptor &&
1533: lpOleDoc->m_fLinkSourceAvail) {
1534: return OleStdQueryObjectDescriptorData(lpformatetc);
1535: }
1536:
1537: return ResultFromScode(DATA_E_FORMATETC);
1538: }
1539:
1540:
1541: /* ServerDoc_EnumFormatEtc
1542: * -----------------------
1543: *
1544: * Return an enumerator which enumerates the data accepted/offered by
1545: * the document.
1546: * This routine is called via IDataObject::EnumFormatEtc.
1547: */
1548: HRESULT ServerDoc_EnumFormatEtc(
1549: LPSERVERDOC lpServerDoc,
1550: DWORD dwDirection,
1551: LPENUMFORMATETC FAR* lplpenumFormatEtc
1552: )
1553: {
1554: LPOLEDOC lpOleDoc = (LPOLEDOC)lpServerDoc;
1555: LPOLEAPP lpOleApp = (LPOLEAPP)g_lpApp;
1556: int nActualFmts;
1557: SCODE sc = S_OK;
1558:
1559: /* OLE2NOTE: the enumeration of formats for a data transfer
1560: ** document is not a static list. the list of formats offered
1561: ** may or may not include CF_LINKSOURCE depending on whether a
1562: ** moniker is available for our document. thus we can NOT use
1563: ** the default OLE enumerator which enumerates the formats that
1564: ** are registered for our app in the registration database.
1565: */
1566: if (dwDirection == DATADIR_GET) {
1567: nActualFmts = lpOleApp->m_nDocGetFmts;
1568:
1569: /* If the document does not have a Moniker, then exclude
1570: ** CF_LINKSOURCE and CF_LINKSRCDESCRIPTOR from the list of
1571: ** formats available. these formats are deliberately listed
1572: ** last in the array of possible "Get" formats.
1573: */
1574: if (! lpOleDoc->m_fLinkSourceAvail)
1575: nActualFmts -= 2;
1576:
1577: *lplpenumFormatEtc = OleStdEnumFmtEtc_Create(
1578: nActualFmts, lpOleApp->m_arrDocGetFmts);
1579: if (*lplpenumFormatEtc == NULL)
1580: sc = E_OUTOFMEMORY;
1581:
1582: } else if (dwDirection == DATADIR_SET) {
1583: /* OLE2NOTE: a document that is used to transfer data
1584: ** (either via the clipboard or drag/drop does NOT
1585: ** accept SetData on ANY format!
1586: */
1587: sc = E_NOTIMPL;
1588: goto error;
1589: } else {
1590: sc = E_INVALIDARG;
1591: goto error;
1592: }
1593:
1594: error:
1595: return ResultFromScode(sc);
1596: }
1597:
1598:
1599: /* ServerDoc_GetMetafilePictData
1600: * -----------------------------
1601: *
1602: * Return a handle to an object's picture data in metafile format.
1603: *
1604: *
1605: * RETURNS: A handle to the object's data in metafile format.
1606: *
1607: */
1608: HGLOBAL ServerDoc_GetMetafilePictData(
1609: LPSERVERDOC lpServerDoc,
1610: LPLINERANGE lplrSel
1611: )
1612: {
1613: LPOUTLINEAPP lpOutlineApp = (LPOUTLINEAPP)g_lpApp;
1614: LPOUTLINEDOC lpOutlineDoc=(LPOUTLINEDOC)lpServerDoc;
1615: LPLINELIST lpLL=(LPLINELIST)&lpOutlineDoc->m_LineList;
1616: LPLINE lpLine;
1617: LPMETAFILEPICT lppict = NULL;
1618: HGLOBAL hMFPict = NULL;
1619: HMETAFILE hMF = NULL;
1620: RECT rect;
1621: HDC hDC;
1622: int i;
1623: int nWidth;
1624: int nStart = (lplrSel ? lplrSel->m_nStartLine : 0);
1625: int nEnd =(lplrSel ? lplrSel->m_nEndLine : LineList_GetCount(lpLL)-1);
1626: int nLines = nEnd - nStart + 1;
1627: UINT fuAlign;
1628: POINT point;
1629: SIZE size;
1630:
1631: hDC = CreateMetaFile(NULL);
1632:
1633: rect.left = 0;
1634: rect.right = 0;
1635: rect.bottom = 0;
1636:
1637: if (nLines > 0) {
1638: // calculate the total height/width of LineList in HIMETRIC
1639: for(i = nStart; i <= nEnd; i++) {
1640: lpLine = LineList_GetLine(lpLL,i);
1641: nWidth = Line_GetTotalWidthInHimetric(lpLine);
1642: rect.right = max(rect.right, nWidth);
1643: rect.bottom -= Line_GetHeightInHimetric(lpLine);
1644: }
1645:
1646:
1647: SetMapMode(hDC, MM_ANISOTROPIC);
1648:
1649: SetWindowOrgEx(hDC, 0, 0, &point);
1650: SetWindowExtEx(hDC, rect.right, rect.bottom, &size);
1651:
1652: // Set the default font size, and font face name
1653: SelectObject(hDC, OutlineApp_GetActiveFont(lpOutlineApp));
1654:
1655: FillRect(hDC, (LPRECT) &rect, GetStockObject(WHITE_BRUSH));
1656:
1657: rect.bottom = 0;
1658:
1659: fuAlign = SetTextAlign(hDC, TA_LEFT | TA_TOP | TA_NOUPDATECP);
1660:
1661: /* While more lines print out the text */
1662: for(i = nStart; i <= nEnd; i++) {
1663: lpLine = LineList_GetLine(lpLL,i);
1664:
1665: rect.top = rect.bottom;
1666: rect.bottom -= Line_GetHeightInHimetric(lpLine);
1667:
1668: /* Draw the line */
1669: Line_Draw(lpLine, hDC, &rect);
1670: }
1671:
1672: SetTextAlign(hDC, fuAlign);
1673: }
1674:
1675: // Get handle to the metafile.
1676: if (!(hMF = CloseMetaFile (hDC)))
1677: return NULL;
1678:
1679: if (!(hMFPict = GlobalAlloc (GMEM_SHARE | GMEM_ZEROINIT,
1680: sizeof (METAFILEPICT)))) {
1681: DeleteMetaFile (hMF);
1682: return NULL;
1683: }
1684:
1685: if (!(lppict = (LPMETAFILEPICT)GlobalLock(hMFPict))) {
1686: DeleteMetaFile (hMF);
1687: GlobalFree (hMFPict);
1688: return NULL;
1689: }
1690:
1691: lppict->mm = MM_ANISOTROPIC;
1692: lppict->hMF = hMF;
1693: lppict->xExt = rect.right;
1694: lppict->yExt = - rect.bottom; // add minus sign to make it +ve
1695: GlobalUnlock (hMFPict);
1696:
1697: return hMFPict;
1698: }
1699:
1700: #endif // OLE_SERVER
1701:
1702:
1703:
1704: #if defined( OLE_CNTR )
1705:
1706: /*************************************************************************
1707: ** ContainerDoc Supprt Functions Used by Container versions
1708: *************************************************************************/
1709:
1710:
1711: /* Paste OLE Link from clipboard */
1712: void ContainerDoc_PasteLinkCommand(LPCONTAINERDOC lpContainerDoc)
1713: {
1714: LPOUTLINEAPP lpOutlineApp = (LPOUTLINEAPP)g_lpApp;
1715: LPOLEAPP lpOleApp = (LPOLEAPP)g_lpApp;
1716: LPDATAOBJECT lpClipboardDataObj = NULL;
1717: BOOL fLink = TRUE;
1718: BOOL fLocalDataObj = FALSE;
1719: BOOL fDisplayAsIcon = FALSE;
1720: HCURSOR hPrevCursor;
1721: HGLOBAL hMem = NULL;
1722: HGLOBAL hMetaPict = NULL;
1723: STGMEDIUM medium;
1724: BOOL fStatus;
1725: HRESULT hrErr;
1726:
1727: hrErr = OleGetClipboard((LPDATAOBJECT FAR*)&lpClipboardDataObj);
1728: if (hrErr != NOERROR)
1729: return; // Clipboard seems to be empty or can't be accessed
1730:
1731: // this may take a while, put up hourglass cursor
1732: hPrevCursor = SetCursor(LoadCursor(NULL, IDC_WAIT));
1733:
1734: /* check if the data on the clipboard is local to our application
1735: ** instance.
1736: */
1737: if (lpOutlineApp->m_lpClipboardDoc) {
1738: LPOLEDOC lpOleDoc = (LPOLEDOC)lpOutlineApp->m_lpClipboardDoc;
1739: if (lpClipboardDataObj == (LPDATAOBJECT)&lpOleDoc->m_DataObject)
1740: fLocalDataObj = TRUE;
1741: }
1742:
1743: /* OLE2NOTE: we need to check what dwDrawAspect is being
1744: ** transfered. if the data is an object that is displayed as an
1745: ** icon in the source, then we want to keep it as an icon. the
1746: ** aspect the object is displayed in at the source is transfered
1747: ** via the CF_LINKSOURCEDESCRIPTOR format for a PasteLink
1748: ** operation.
1749: */
1750: if (hMem = OleStdGetData(
1751: lpClipboardDataObj,
1752: lpOleApp->m_cfLinkSrcDescriptor,
1753: NULL,
1754: DVASPECT_CONTENT,
1755: (LPSTGMEDIUM)&medium)) {
1756: LPOBJECTDESCRIPTOR lpOD = GlobalLock(hMem);
1757: fDisplayAsIcon = (lpOD->dwDrawAspect == DVASPECT_ICON ? TRUE : FALSE);
1758: GlobalUnlock(hMem);
1759: ReleaseStgMedium((LPSTGMEDIUM)&medium); // equiv to GlobalFree
1760:
1761: if (fDisplayAsIcon) {
1762: hMetaPict = OleStdGetData(
1763: lpClipboardDataObj,
1764: CF_METAFILEPICT,
1765: NULL,
1766: DVASPECT_ICON,
1767: (LPSTGMEDIUM)&medium
1768: );
1769: if (hMetaPict == NULL)
1770: fDisplayAsIcon = FALSE; // give up; failed to get icon MFP
1771: }
1772: }
1773:
1774: fStatus = ContainerDoc_PasteFormatFromData(
1775: lpContainerDoc,
1776: lpOleApp->m_cfLinkSource,
1777: lpClipboardDataObj,
1778: fLocalDataObj,
1779: fLink,
1780: fDisplayAsIcon,
1781: hMetaPict
1782: );
1783:
1784: if (!fStatus)
1785: OutlineApp_ErrorMessage(g_lpApp, ErrMsgPasting);
1786:
1787: if (hMetaPict)
1788: ReleaseStgMedium((LPSTGMEDIUM)&medium); // properly free METAFILEPICT
1789:
1790: if (lpClipboardDataObj)
1791: OleStdRelease((LPUNKNOWN)lpClipboardDataObj);
1792:
1793: SetCursor(hPrevCursor); // restore original cursor
1794: }
1795:
1796:
1797: /* ContainerDoc_PasteFormatFromData
1798: ** --------------------------------
1799: **
1800: ** Paste a particular data format from a IDataObject*. The
1801: ** IDataObject* may come from the clipboard (GetClipboard) or from a
1802: ** drag/drop operation.
1803: **
1804: ** Returns TRUE if data was successfully pasted.
1805: ** FALSE if data could not be pasted.
1806: */
1807: BOOL ContainerDoc_PasteFormatFromData(
1808: LPCONTAINERDOC lpContainerDoc,
1809: CLIPFORMAT cfFormat,
1810: LPDATAOBJECT lpSrcDataObj,
1811: BOOL fLocalDataObj,
1812: BOOL fLink,
1813: BOOL fDisplayAsIcon,
1814: HGLOBAL hMetaPict
1815: )
1816: {
1817: LPLINELIST lpLL = (LPLINELIST)&((LPOUTLINEDOC)lpContainerDoc)->m_LineList;
1818: LPOUTLINEAPP lpOutlineApp = (LPOUTLINEAPP)g_lpApp;
1819: LPOLEAPP lpOleApp = (LPOLEAPP)g_lpApp;
1820: LPCONTAINERAPP lpContainerApp = (LPCONTAINERAPP)g_lpApp;
1821: int nIndex;
1822: int nCount = 0;
1823: HGLOBAL hData;
1824: STGMEDIUM medium;
1825: FORMATETC formatetc;
1826: HRESULT hrErr;
1827: LINERANGE lrSel;
1828:
1829: if (LineList_GetCount(lpLL) == 0)
1830: nIndex = -1; // pasting to empty list
1831: else
1832: nIndex=LineList_GetFocusLineIndex(lpLL);
1833:
1834: if (fLink) {
1835:
1836: /* We should paste a Link to the data */
1837:
1838: if (cfFormat != lpOleApp->m_cfLinkSource)
1839: return FALSE; // we only support OLE object type links
1840:
1841: nCount = ContainerDoc_PasteOleObject(
1842: lpContainerDoc,
1843: lpSrcDataObj,
1844: OLECREATEFROMDATA_LINK,
1845: cfFormat,
1846: nIndex,
1847: fDisplayAsIcon,
1848: hMetaPict
1849: );
1850: return (nCount > 0 ? TRUE : FALSE);
1851:
1852: } else {
1853:
1854: if (cfFormat == lpContainerApp->m_cfCntrOutl) {
1855: if (fLocalDataObj) {
1856:
1857: /* CASE I: IDataObject* is local to our app
1858: **
1859: ** if the source of the data is local to our
1860: ** application instance, then we can get direct
1861: ** access to the original OleDoc object that
1862: ** corresponds to the IDataObject* given.
1863: ** CF_CNTROUTL data is passed through a LPSTORAGE.
1864: ** if we call OleGetData asking for CF_CNTROUTL, we
1865: ** will be returned a copy of the existing open pStg
1866: ** of the original source document. we can NOT open
1867: ** streams and sub-storages again via this pStg
1868: ** since it is already open within our same
1869: ** application instance. we must copy the data from
1870: ** the original OleDoc source document.
1871: */
1872: LPLINELIST lpSrcLL;
1873: LPOLEDOC lpLocalSrcDoc =
1874: ((struct CDocDataObjectImpl FAR*)lpSrcDataObj)->lpOleDoc;
1875:
1876: /* copy all lines from SrcDoc to DestDoc. */
1877: lpSrcLL = &((LPOUTLINEDOC)lpLocalSrcDoc)->m_LineList;
1878: nCount = LineList_CopySelToDoc(
1879: lpSrcLL,
1880: NULL,
1881: (LPOUTLINEDOC)lpContainerDoc
1882: );
1883:
1884: } else {
1885:
1886: /* CASE II: IDataObject* is NOT local to our app
1887: **
1888: ** if the source of the data comes from another
1889: ** application instance. we can call GetDataHere to
1890: ** retrieve the CF_CNTROUTL data. CF_CNTROUTL data
1891: ** is passed through a LPSTORAGE. we MUST use
1892: ** IDataObject::GetDataHere. calling
1893: ** IDataObject::GetData does NOT work because OLE
1894: ** currently does NOT support remoting of a callee
1895: ** allocated root storage back to the caller. this
1896: ** hopefully will be supported in a future version.
1897: ** in order to call GetDataHere we must allocate an
1898: ** IStorage instance for the callee to write into.
1899: ** we will allocate an IStorage docfile that will
1900: ** delete-on-release. we could use either a
1901: ** memory-based storage or a file-based storage.
1902: */
1903: LPSTORAGE lpTmpStg = OleStdCreateTempStorage(
1904: FALSE /*fUseMemory*/,
1905: STGM_READWRITE | STGM_TRANSACTED |STGM_SHARE_EXCLUSIVE
1906: );
1907: if (! lpTmpStg)
1908: return FALSE;
1909:
1910: formatetc.cfFormat = cfFormat;
1911: formatetc.ptd = NULL;
1912: formatetc.dwAspect = DVASPECT_CONTENT;
1913: formatetc.tymed = TYMED_ISTORAGE;
1914: formatetc.lindex = -1;
1915:
1916: medium.tymed = TYMED_ISTORAGE;
1917: medium.u.pstg = lpTmpStg;
1918: medium.pUnkForRelease = NULL;
1919:
1920: OLEDBG_BEGIN2("IDataObject::GetDataHere called\r\n")
1921: hrErr = lpSrcDataObj->lpVtbl->GetDataHere(
1922: lpSrcDataObj,
1923: (LPFORMATETC)&formatetc,
1924: (LPSTGMEDIUM)&medium
1925: );
1926: OLEDBG_END2
1927:
1928: if (hrErr == NOERROR) {
1929: nCount = ContainerDoc_PasteCntrOutlData(
1930: lpContainerDoc,
1931: lpTmpStg,
1932: nIndex
1933: );
1934: }
1935: OleStdVerifyRelease(
1936: (LPUNKNOWN)lpTmpStg, "Temp stg NOT released!\r\n");
1937: return ((hrErr == NOERROR) ? TRUE : FALSE);
1938: }
1939:
1940: } else if (cfFormat == lpOutlineApp->m_cfOutline) {
1941:
1942: hData = OleStdGetData(
1943: lpSrcDataObj,
1944: lpOutlineApp->m_cfOutline,
1945: NULL,
1946: DVASPECT_CONTENT,
1947: (LPSTGMEDIUM)&medium
1948: );
1949: nCount = OutlineDoc_PasteOutlineData(
1950: (LPOUTLINEDOC)lpContainerDoc,
1951: hData,
1952: nIndex
1953: );
1954: // OLE2NOTE: we must free data handle by releasing the medium
1955: ReleaseStgMedium((LPSTGMEDIUM)&medium);
1956:
1957: } else if (cfFormat == lpOleApp->m_cfEmbedSource ||
1958: cfFormat == lpOleApp->m_cfEmbeddedObject ||
1959: cfFormat == lpOleApp->m_cfFileName) {
1960: /* OLE2NOTE: OleCreateFromData API creates an OLE object if
1961: ** CF_EMBEDDEDOBJECT, CF_EMBEDSOURCE, or CF_FILENAME are
1962: ** available from the source data object. the
1963: ** CF_FILENAME case arises when a file is copied to the
1964: ** clipboard from the FileManager. if the file has an
1965: ** associated class (see GetClassFile API), then an
1966: ** object of that class is created. otherwise an OLE 1.0
1967: ** Packaged object is created.
1968: */
1969: nCount = ContainerDoc_PasteOleObject(
1970: lpContainerDoc,
1971: lpSrcDataObj,
1972: OLECREATEFROMDATA_OBJECT,
1973: 0, /* N/A -- cfFormat */
1974: nIndex,
1975: fDisplayAsIcon,
1976: hMetaPict
1977: );
1978: return (nCount > 0 ? TRUE : FALSE);
1979:
1980: } else if (cfFormat == CF_METAFILEPICT
1981: || cfFormat == CF_DIB
1982: || cfFormat == CF_BITMAP) {
1983:
1984: /* OLE2NOTE: OleCreateStaticFromData API creates an static
1985: ** OLE object if CF_METAFILEPICT, CF_DIB, or CF_BITMAP is
1986: ** CF_EMBEDDEDOBJECT, CF_EMBEDSOURCE, or CF_FILENAME are
1987: ** available from the source data object.
1988: */
1989: nCount = ContainerDoc_PasteOleObject(
1990: lpContainerDoc,
1991: lpSrcDataObj,
1992: OLECREATEFROMDATA_STATIC,
1993: cfFormat,
1994: nIndex,
1995: fDisplayAsIcon,
1996: hMetaPict
1997: );
1998: return (nCount > 0 ? TRUE : FALSE);
1999:
2000: } else if(cfFormat == CF_TEXT) {
2001:
2002: hData = OleStdGetData(
2003: lpSrcDataObj,
2004: CF_TEXT,
2005: NULL,
2006: DVASPECT_CONTENT,
2007: (LPSTGMEDIUM)&medium
2008: );
2009: nCount = OutlineDoc_PasteTextData(
2010: (LPOUTLINEDOC)lpContainerDoc,
2011: hData,
2012: nIndex
2013: );
2014: // OLE2NOTE: we must free data handle by releasing the medium
2015: ReleaseStgMedium((LPSTGMEDIUM)&medium);
2016:
2017: } else {
2018: return FALSE; // no acceptable format available to paste
2019: }
2020: }
2021:
2022: lrSel.m_nStartLine = nIndex + nCount;
2023: lrSel.m_nEndLine = nIndex + 1;
2024: LineList_SetSel(lpLL, &lrSel);
2025: return TRUE;
2026: }
2027:
2028:
2029: /* ContainerDoc_PasteCntrOutlData
2030: * -------------------------------
2031: *
2032: * Load the lines stored in a lpSrcStg (stored in CF_CNTROUTL format)
2033: * into the document.
2034: *
2035: * Return the number of items added
2036: */
2037: int ContainerDoc_PasteCntrOutlData(
2038: LPCONTAINERDOC lpDestContainerDoc,
2039: LPSTORAGE lpSrcStg,
2040: int nStartIndex
2041: )
2042: {
2043: int nCount;
2044: LPOUTLINEAPP lpOutlineApp = (LPOUTLINEAPP)g_lpApp;
2045: LPOUTLINEDOC lpDestOutlineDoc = (LPOUTLINEDOC)lpDestContainerDoc;
2046: LPOUTLINEDOC lpSrcOutlineDoc;
2047: LPLINELIST lpSrcLL;
2048:
2049: // create a temp document that will be used to load the lpSrcStg data.
2050: lpSrcOutlineDoc = (LPOUTLINEDOC)OutlineApp_CreateDoc(lpOutlineApp, FALSE);
2051: if ( ! lpSrcOutlineDoc )
2052: return 0;
2053:
2054: if (! OutlineDoc_LoadFromStg(lpSrcOutlineDoc, lpSrcStg))
2055: goto error;
2056:
2057: /* copy all lines from the SrcDoc to the DestDoc. */
2058: lpSrcLL = &lpSrcOutlineDoc->m_LineList;
2059: nCount = LineList_CopySelToDoc(lpSrcLL, NULL, lpDestOutlineDoc);
2060:
2061: if (lpSrcOutlineDoc) // destroy temporary document.
2062: OutlineDoc_Close(lpSrcOutlineDoc, OLECLOSE_NOSAVE);
2063:
2064: return nCount;
2065:
2066: error:
2067: if (lpSrcOutlineDoc) // destroy temporary document.
2068: OutlineDoc_Close(lpSrcOutlineDoc, OLECLOSE_NOSAVE);
2069:
2070: return 0;
2071: }
2072:
2073:
2074: /* ContainerDoc_QueryPasteFromData
2075: ** -------------------------------
2076: **
2077: ** Check if the IDataObject* offers data in a format that we can
2078: ** paste. The IDataObject* may come from the clipboard
2079: ** (GetClipboard) or from a drag/drop operation.
2080: ** In this function we look if one of the following formats is
2081: ** offered:
2082: ** CF_OUTLINE
2083: ** <OLE object -- CF_EMBEDSOURCE or CF_EMBEDDEDOBJECT>
2084: ** CF_TEXT
2085: **
2086: ** NOTE: fLink is specified and CF_LINKSOURCE is available then TRUE
2087: ** is returned, else FALSE.
2088: **
2089: ** Returns TRUE if paste can be performed
2090: ** FALSE if paste is not possible.
2091: */
2092: BOOL ContainerDoc_QueryPasteFromData(
2093: LPCONTAINERDOC lpContainerDoc,
2094: LPDATAOBJECT lpSrcDataObj,
2095: BOOL fLink
2096: )
2097: {
2098: LPOLEAPP lpOleApp = (LPOLEAPP)g_lpApp;
2099:
2100: if (fLink) {
2101: /* check if we can paste a Link to the data */
2102: if (OleQueryLinkFromData(lpSrcDataObj) != NOERROR)
2103: return FALSE; // linking is NOT possible
2104: } else {
2105:
2106: int nFmtEtc;
2107:
2108: nFmtEtc = OleStdGetPriorityClipboardFormat(
2109: lpSrcDataObj,
2110: lpOleApp->m_arrPasteEntries,
2111: lpOleApp->m_nPasteEntries
2112: );
2113:
2114: if (nFmtEtc < 0)
2115: return FALSE; // there is no format we like
2116: }
2117:
2118: return TRUE;
2119: }
2120:
2121:
2122: /* ContainerDoc_PasteOleObject
2123: ** ---------------------------
2124: **
2125: ** Embed or link an OLE object. the source of the data is a pointer
2126: ** to an IDataObject. normally this lpSrcDataObj comes from the
2127: ** clipboard after call OleGetClipboard.
2128: **
2129: ** dwCreateType controls what type of object will created:
2130: ** OLECREATEFROMDATA_LINK -- OleCreateLinkFromData will be called
2131: ** OLECREATEFROMDATA_OBJECT -- OleCreateFromData will be called
2132: ** OLECREATEFROMDATA_STATIC -- OleCreateStaticFromData will be called
2133: ** cfFormat controls the type of static
2134: ** a CONTAINERLINE object is created to manage the OLE object. this
2135: ** CONTAINERLINE is added to the ContainerDoc after line nIndex.
2136: **
2137: */
2138: int ContainerDoc_PasteOleObject(
2139: LPCONTAINERDOC lpContainerDoc,
2140: LPDATAOBJECT lpSrcDataObj,
2141: DWORD dwCreateType,
2142: CLIPFORMAT cfFormat,
2143: int nIndex,
2144: BOOL fDisplayAsIcon,
2145: HGLOBAL hMetaPict
2146: )
2147: {
2148: LPLINELIST lpLL = &((LPOUTLINEDOC)lpContainerDoc)->m_LineList;
2149: LPLINE lpLine = NULL;
2150: HDC hDC;
2151: int nTab = 0;
2152: char szStgName[CWCSTORAGENAME];
2153: LPCONTAINERLINE lpContainerLine = NULL;
2154:
2155: ContainerDoc_GetNextStgName(lpContainerDoc, szStgName, sizeof(szStgName));
2156:
2157: /* default the new line to have the same indent as previous line */
2158: lpLine = LineList_GetLine(lpLL, nIndex);
2159: if (lpLine)
2160: nTab = Line_GetTabLevel(lpLine);
2161:
2162: hDC = LineList_GetDC(lpLL);
2163:
2164: lpContainerLine = ContainerLine_CreateFromData(
2165: hDC,
2166: nTab,
2167: lpContainerDoc,
2168: lpSrcDataObj,
2169: dwCreateType,
2170: cfFormat,
2171: fDisplayAsIcon,
2172: hMetaPict,
2173: szStgName
2174: );
2175: LineList_ReleaseDC(lpLL, hDC);
2176:
2177: if (! lpContainerLine)
2178: goto error;
2179:
2180: /* add a ContainerLine object to the document's LineList. The
2181: ** ContainerLine manages the rectangle on the screen occupied by
2182: ** the OLE object. later when the app is updated to support
2183: ** extended layout, there could be more than one Line associated
2184: ** with the OLE object.
2185: */
2186:
2187: LineList_AddLine(lpLL, (LPLINE)lpContainerLine, nIndex);
2188:
2189: // check to see if the object has any initial extents.
2190: ContainerLine_UpdateExtent(lpContainerLine, NULL);
2191:
2192: OutlineDoc_SetModified((LPOUTLINEDOC)lpContainerDoc, TRUE, TRUE, TRUE);
2193:
2194: return 1; // one line added to LineList
2195:
2196: error:
2197: // NOTE: if ContainerLine_CreateFromClip failed
2198: OutlineApp_ErrorMessage(g_lpApp, "Paste Object failed!");
2199: return 0; // no lines added to line list
2200: }
2201:
2202:
2203: /* ContainerDoc_GetData
2204: * --------------------
2205: *
2206: * Render data from the document on a CALLEE allocated STGMEDIUM.
2207: * This routine is called via IDataObject::GetData.
2208: */
2209: HRESULT ContainerDoc_GetData (
2210: LPCONTAINERDOC lpContainerDoc,
2211: LPFORMATETC lpformatetc,
2212: LPSTGMEDIUM lpMedium
2213: )
2214: {
2215: LPOLEDOC lpOleDoc = (LPOLEDOC)lpContainerDoc;
2216: LPOUTLINEDOC lpOutlineDoc = (LPOUTLINEDOC)lpContainerDoc;
2217: LPCONTAINERAPP lpContainerApp = (LPCONTAINERAPP)g_lpApp;
2218: LPOLEAPP lpOleApp = (LPOLEAPP)lpContainerApp;
2219: LPOUTLINEAPP lpOutlineApp = (LPOUTLINEAPP)lpContainerApp;
2220: HRESULT hrErr;
2221: SCODE sc;
2222:
2223: // OLE2NOTE: we must set out pointer parameters to NULL
2224: lpMedium->pUnkForRelease = NULL;
2225:
2226: /* OLE2NOTE: we must set all out pointer parameters to NULL. */
2227: lpMedium->tymed = TYMED_NULL;
2228: lpMedium->pUnkForRelease = NULL; // we transfer ownership to caller
2229: lpMedium->u.hGlobal = NULL;
2230:
2231: if (lpformatetc->cfFormat == lpContainerApp->m_cfCntrOutl) {
2232:
2233: /* OLE2NOTE: currently OLE does NOT support remoting a root
2234: ** level IStorage (either memory or file based) as an OUT
2235: ** parameter. thus, we can NOT support GetData for this
2236: ** TYMED_ISTORAGE based format. the caller MUST call GetDataHere.
2237: */
2238: sc = DATA_E_FORMATETC;
2239: goto error;
2240:
2241: } else if (lpformatetc->cfFormat == lpOutlineApp->m_cfOutline) {
2242: // Verify caller asked for correct medium
2243: if (!(lpformatetc->tymed & TYMED_HGLOBAL)) {
2244: sc = DATA_E_FORMATETC;
2245: goto error;
2246: }
2247:
2248: lpMedium->u.hGlobal = OutlineDoc_GetOutlineData(lpOutlineDoc, NULL);
2249: if (! lpMedium->u.hGlobal) {
2250: sc = E_OUTOFMEMORY;
2251: goto error;
2252: }
2253:
2254: lpMedium->tymed = TYMED_HGLOBAL;
2255: OleDbgOut3("ContainerDoc_GetData: rendered CF_OUTLINE\r\n");
2256: return NOERROR;
2257:
2258: } else if (lpformatetc->cfFormat == CF_TEXT) {
2259: // Verify caller asked for correct medium
2260: if (!(lpformatetc->tymed & TYMED_HGLOBAL)) {
2261: sc = DATA_E_FORMATETC;
2262: goto error;
2263: }
2264:
2265: lpMedium->u.hGlobal = OutlineDoc_GetTextData (
2266: (LPOUTLINEDOC)lpContainerDoc,
2267: NULL
2268: );
2269: if (! lpMedium->u.hGlobal) {
2270: sc = E_OUTOFMEMORY;
2271: goto error;
2272: }
2273:
2274: lpMedium->tymed = TYMED_HGLOBAL;
2275: OleDbgOut3("ContainerDoc_GetData: rendered CF_TEXT\r\n");
2276: return NOERROR;
2277:
2278: } else if ( lpformatetc->cfFormat == lpOleApp->m_cfObjectDescriptor ||
2279: (lpformatetc->cfFormat == lpOleApp->m_cfLinkSrcDescriptor &&
2280: lpOleDoc->m_fLinkSourceAvail) ) {
2281: // Verify caller asked for correct medium
2282: if (!(lpformatetc->tymed & TYMED_HGLOBAL)) {
2283: sc = DATA_E_FORMATETC;
2284: goto error;
2285: }
2286:
2287: lpMedium->u.hGlobal = OleDoc_GetObjectDescriptorData (
2288: (LPOLEDOC)lpContainerDoc,
2289: NULL
2290: );
2291: if (! lpMedium->u.hGlobal) {
2292: sc = E_OUTOFMEMORY;
2293: goto error;
2294: }
2295:
2296: lpMedium->tymed = TYMED_HGLOBAL;
2297: #if defined( _DEBUG )
2298: if (lpformatetc->cfFormat == lpOleApp->m_cfObjectDescriptor)
2299: OleDbgOut3(
2300: "ContainerDoc_GetData: rendered CF_OBJECTDESCRIPTOR\r\n");
2301: else
2302: OleDbgOut3(
2303: "ContainerDoc_GetData: rendered CF_LINKSRCDESCRIPTOR\r\n");
2304: #endif
2305: return NOERROR;
2306:
2307: } else if (lpContainerDoc->m_fEmbeddedObjectAvail) {
2308:
2309: /* OLE2NOTE: if this document contains a single OLE object
2310: ** (ie. cfEmbeddedObject data format is available), then
2311: ** the formats offered via our IDataObject must include
2312: ** the formats available from the OLE object itself.
2313: ** thus, we delegate this call to the IDataObject* of the
2314: ** OLE object.
2315: */
2316:
2317: if (lpformatetc->cfFormat == lpOleApp->m_cfEmbeddedObject) {
2318: LPPERSISTSTORAGE lpPersistStg =
2319: (LPPERSISTSTORAGE)ContainerDoc_GetSingleOleObject(
2320: lpContainerDoc,
2321: &IID_IPersistStorage,
2322: NULL
2323: );
2324:
2325: if (! lpPersistStg)
2326: return ResultFromScode(DATA_E_FORMATETC);
2327:
2328: /* render CF_EMBEDDEDOBJECT by asking the storage to save
2329: ** into the pStg of the caller.
2330: */
2331:
2332: hrErr = OleStdGetOleObjectData(
2333: lpPersistStg,
2334: lpformatetc,
2335: lpMedium,
2336: FALSE /* fUseMemory -- (use file-base stg) */
2337: );
2338: OleStdRelease((LPUNKNOWN)lpPersistStg);
2339: if (hrErr != NOERROR) {
2340: sc = GetScode(hrErr);
2341: goto error;
2342: }
2343: OleDbgOut3(
2344: "ContainerDoc_GetData: rendered CF_EMBEDDEDOBJECT\r\n");
2345: return hrErr;
2346:
2347: } else if (lpformatetc->cfFormat == CF_METAFILEPICT) {
2348:
2349: /* OLE2NOTE: as a container which draws objects, when a single
2350: ** OLE object is copied, we can give the Metafile picture of
2351: ** the object. we will offer this picture when asked either
2352: ** for the actual drawing aspect that we are displaying for
2353: ** the object or for DVASPECT_DOCPRINT (if asked to render
2354: ** it to a printer)
2355: */
2356: LPCONTAINERLINE lpContainerLine;
2357: LPOLEOBJECT lpOleObj;
2358:
2359: // Verify caller asked for correct medium
2360: if (!(lpformatetc->tymed & TYMED_MFPICT)) {
2361: sc = DATA_E_FORMATETC;
2362: goto error;
2363: }
2364:
2365: lpOleObj = (LPOLEOBJECT)ContainerDoc_GetSingleOleObject(
2366: lpContainerDoc,
2367: &IID_IOleObject,
2368: (LPCONTAINERLINE FAR*)&lpContainerLine
2369: );
2370:
2371: if (! lpOleObj) {
2372: sc = E_OUTOFMEMORY; // could not load object
2373: goto error;
2374: }
2375: if (lpformatetc->dwAspect &
2376: (lpContainerLine->m_dwDrawAspect | DVASPECT_DOCPRINT)) {
2377: /* render CF_METAFILEPICT by drawing the object into
2378: ** a metafile DC
2379: */
2380: lpMedium->u.hGlobal = OleStdGetMetafilePictFromOleObject(
2381: lpOleObj, lpContainerLine->m_dwDrawAspect);
2382: OleStdRelease((LPUNKNOWN)lpOleObj);
2383: if (! lpMedium->u.hGlobal) {
2384: sc = E_OUTOFMEMORY;
2385: goto error;
2386: }
2387:
2388: lpMedium->tymed = TYMED_MFPICT;
2389: OleDbgOut3(
2390: "ContainerDoc_GetData: rendered CF_METAFILEPICT\r\n");
2391: return NOERROR;
2392: } else {
2393: // improper aspect requested
2394: OleStdRelease((LPUNKNOWN)lpOleObj);
2395: return ResultFromScode(DATA_E_FORMATETC);
2396: }
2397:
2398: } else if (lpformatetc->cfFormat == lpOleApp->m_cfLinkSource) {
2399: if (lpOleDoc->m_fLinkSourceAvail) {
2400: LPMONIKER lpmk;
2401:
2402: lpmk = ContainerLine_GetFullMoniker(
2403: lpContainerDoc->m_lpSrcContainerLine,
2404: GETMONIKER_FORCEASSIGN
2405: );
2406: if (lpmk) {
2407: hrErr = OleStdGetLinkSourceData(
2408: lpmk,
2409: &lpContainerDoc->m_clsidOleObjCopied,
2410: lpformatetc,
2411: lpMedium
2412: );
2413: OleStdRelease((LPUNKNOWN)lpmk);
2414: if (hrErr != NOERROR) {
2415: sc = GetScode(hrErr);
2416: goto error;
2417: }
2418: OleDbgOut3(
2419: "ContainerDoc_GetData: rendered CF_LINKSOURCE\r\n");
2420: return hrErr;
2421: } else {
2422: sc = DATA_E_FORMATETC;
2423: goto error;
2424: }
2425: } else {
2426: sc = DATA_E_FORMATETC;
2427: goto error;
2428: }
2429:
2430: }
2431: #if defined( OPTIONAL_ADVANCED_DATA_TRANSFER )
2432: /* OLE2NOTE: optionally, a container that wants to have a
2433: ** potentially richer data transfer, can enumerate the data
2434: ** formats from the OLE object's cache and offer them too. if
2435: ** the object has a special handler, then it might be able to
2436: ** render additional data formats. in this case, the
2437: ** container must delegate the GetData call to the object if
2438: ** it does not directly support the format.
2439: **
2440: ** CNTROUTL does NOT enumerate the cache; it implements the
2441: ** simpler strategy of offering a static list of formats.
2442: ** thus the delegation is NOT required.
2443: */
2444: else {
2445:
2446: /* OLE2NOTE: we delegate this call to the IDataObject* of the
2447: ** OLE object.
2448: */
2449: LPDATAOBJECT lpDataObj;
2450:
2451: lpDataObj = (LPDATAOBJECT)ContainerDoc_GetSingleOleObject(
2452: lpContainerDoc,
2453: &IID_IDataObject,
2454: NULL
2455: );
2456:
2457: if (! lpDataObj) {
2458: sc = DATA_E_FORMATETC;
2459: goto error;
2460: }
2461:
2462: OLEDBG_BEGIN2("ContainerDoc_GetData: delegate to OLE obj\r\n")
2463: hrErr=lpDataObj->lpVtbl->GetData(lpDataObj,lpformatetc,lpMedium);
2464: OLEDBG_END2
2465:
2466: OleStdRelease((LPUNKNOWN)lpDataObj);
2467: return hrErr;
2468: }
2469: #endif // ! OPTIONAL_ADVANCED_DATA_TRANSFER
2470:
2471: }
2472:
2473: // if we get here then we do NOT support the requested format
2474: sc = DATA_E_FORMATETC;
2475:
2476: error:
2477: return ResultFromScode(sc);
2478: }
2479:
2480:
2481: /* ContainerDoc_GetDataHere
2482: * ------------------------
2483: *
2484: * Render data from the document on a CALLER allocated STGMEDIUM.
2485: * This routine is called via IDataObject::GetDataHere.
2486: */
2487: HRESULT ContainerDoc_GetDataHere (
2488: LPCONTAINERDOC lpContainerDoc,
2489: LPFORMATETC lpformatetc,
2490: LPSTGMEDIUM lpMedium
2491: )
2492: {
2493: LPOLEDOC lpOleDoc = (LPOLEDOC)lpContainerDoc;
2494: LPOUTLINEDOC lpOutlineDoc = (LPOUTLINEDOC)lpContainerDoc;
2495: LPCONTAINERAPP lpContainerApp = (LPCONTAINERAPP)g_lpApp;
2496: LPOLEAPP lpOleApp = (LPOLEAPP)lpContainerApp;
2497: LPOUTLINEAPP lpOutlineApp = (LPOUTLINEAPP)lpContainerApp;
2498: HRESULT hrErr;
2499:
2500: // OLE2NOTE: we must set out pointer parameters to NULL
2501: lpMedium->pUnkForRelease = NULL;
2502:
2503: // we only support IStorage medium
2504: if (lpformatetc->cfFormat == lpContainerApp->m_cfCntrOutl) {
2505: if (!(lpformatetc->tymed & TYMED_ISTORAGE))
2506: return ResultFromScode(DATA_E_FORMATETC);
2507:
2508: if (lpMedium->tymed == TYMED_ISTORAGE) {
2509: /* Caller has allocated the storage. we must copy all of our
2510: ** data into his storage.
2511: */
2512:
2513: /* OLE2NOTE: we must be sure to write our class ID into our
2514: ** storage. this information is used by OLE to determine the
2515: ** class of the data stored in our storage.
2516: */
2517: if((hrErr=WriteClassStg(lpMedium->u.pstg,&CLSID_APP)) != NOERROR)
2518: return hrErr;
2519:
2520: OutlineDoc_SaveSelToStg(
2521: (LPOUTLINEDOC)lpContainerDoc,
2522: NULL, /* entire doc */
2523: lpContainerApp->m_cfCntrOutl,
2524: lpMedium->u.pstg,
2525: FALSE
2526: );
2527: OleStdCommitStorage(lpMedium->u.pstg);
2528:
2529: OleDbgOut3("ContainerDoc_GetDataHere: rendered CF_CNTROUTL\r\n");
2530: return NOERROR;
2531: } else {
2532: // we only support IStorage medium
2533: return ResultFromScode(DATA_E_FORMATETC);
2534: }
2535:
2536: } else if (lpContainerDoc->m_fEmbeddedObjectAvail) {
2537:
2538: /* OLE2NOTE: if this document contains a single OLE object
2539: ** (ie. cfEmbeddedObject data format is available), then
2540: ** the formats offered via our IDataObject must include
2541: ** CF_EMBEDDEDOBJECT and the formats available from the OLE
2542: ** object itself.
2543: */
2544:
2545: if (lpformatetc->cfFormat == lpOleApp->m_cfEmbeddedObject) {
2546: LPPERSISTSTORAGE lpPersistStg =
2547: (LPPERSISTSTORAGE)ContainerDoc_GetSingleOleObject(
2548: lpContainerDoc,
2549: &IID_IPersistStorage,
2550: NULL
2551: );
2552:
2553: if (! lpPersistStg) {
2554: return ResultFromScode(E_OUTOFMEMORY);
2555: }
2556: /* render CF_EMBEDDEDOBJECT by asking the storage to save
2557: ** into the pStg of the caller.
2558: */
2559:
2560: hrErr = OleStdGetOleObjectData(
2561: lpPersistStg,
2562: lpformatetc,
2563: lpMedium,
2564: FALSE /* fUseMemory -- (use file-base stg) */
2565: );
2566: OleStdRelease((LPUNKNOWN)lpPersistStg);
2567: if (hrErr != NOERROR) {
2568: return hrErr;
2569: }
2570: OleDbgOut3(
2571: "ContainerDoc_GetDataHere: rendered CF_EMBEDDEDOBJECT\r\n");
2572: return hrErr;
2573:
2574: } else if (lpformatetc->cfFormat == lpOleApp->m_cfLinkSource) {
2575: if (lpOleDoc->m_fLinkSourceAvail) {
2576: LPMONIKER lpmk;
2577:
2578: lpmk = ContainerLine_GetFullMoniker(
2579: lpContainerDoc->m_lpSrcContainerLine,
2580: GETMONIKER_FORCEASSIGN
2581: );
2582: if (lpmk) {
2583: hrErr = OleStdGetLinkSourceData(
2584: lpmk,
2585: &lpContainerDoc->m_clsidOleObjCopied,
2586: lpformatetc,
2587: lpMedium
2588: );
2589: OleStdRelease((LPUNKNOWN)lpmk);
2590: OleDbgOut3(
2591: "ContainerDoc_GetDataHere: rendered CF_LINKSOURCE\r\n");
2592: return hrErr;
2593: } else {
2594: return ResultFromScode(E_FAIL);
2595: }
2596: } else {
2597: return ResultFromScode(DATA_E_FORMATETC);
2598: }
2599:
2600: }
2601: #if defined( OPTIONAL_ADVANCED_DATA_TRANSFER )
2602: /* OLE2NOTE: optionally, a container that wants to have a
2603: ** potentially richer data transfer, can enumerate the data
2604: ** formats from the OLE object's cache and offer them too. if
2605: ** the object has a special handler, then it might be able to
2606: ** render additional data formats. in this case, the
2607: ** container must delegate the GetData call to the object if
2608: ** it does not directly support the format.
2609: **
2610: ** CNTROUTL does NOT enumerate the cache; it implements the
2611: ** simpler strategy of offering a static list of formats.
2612: ** thus the delegation is NOT required.
2613: */
2614: else {
2615:
2616: /* OLE2NOTE: we delegate this call to the IDataObject* of the
2617: ** OLE object.
2618: */
2619: LPDATAOBJECT lpDataObj;
2620:
2621: lpDataObj = (LPDATAOBJECT)ContainerDoc_GetSingleOleObject(
2622: lpContainerDoc,
2623: &IID_IDataObject,
2624: NULL
2625: );
2626:
2627: if (! lpDataObj)
2628: return ResultFromScode(DATA_E_FORMATETC);
2629:
2630: OLEDBG_BEGIN2("ContainerDoc_GetDataHere: delegate to OLE obj\r\n")
2631: hrErr = lpDataObj->lpVtbl->GetDataHere(
2632: lpDataObj,
2633: lpformatetc,
2634: lpMedium
2635: );
2636: OLEDBG_END2
2637:
2638: OleStdRelease((LPUNKNOWN)lpDataObj);
2639: return hrErr;
2640: }
2641: #endif // OPTIONAL_ADVANCED_DATA_TRANSFER
2642: } else {
2643: return ResultFromScode(DATA_E_FORMATETC);
2644: }
2645: }
2646:
2647:
2648: /* ContainerDoc_QueryGetData
2649: * -------------------------
2650: *
2651: * Answer if a particular data format is supported via GetData/GetDataHere.
2652: * This routine is called via IDataObject::QueryGetData.
2653: */
2654: HRESULT ContainerDoc_QueryGetData (
2655: LPCONTAINERDOC lpContainerDoc,
2656: LPFORMATETC lpformatetc
2657: )
2658: {
2659: LPOLEDOC lpOleDoc = (LPOLEDOC)lpContainerDoc;
2660: LPOUTLINEDOC lpOutlineDoc = (LPOUTLINEDOC)lpContainerDoc;
2661: LPCONTAINERAPP lpContainerApp = (LPCONTAINERAPP)g_lpApp;
2662: LPOLEAPP lpOleApp = (LPOLEAPP)lpContainerApp;
2663: LPOUTLINEAPP lpOutlineApp = (LPOUTLINEAPP)lpContainerApp;
2664: LPDATAOBJECT lpDataObj = NULL;
2665: LPCONTAINERLINE lpContainerLine = NULL;
2666: SCODE sc;
2667: HRESULT hrErr;
2668:
2669: if (lpContainerDoc->m_fEmbeddedObjectAvail) {
2670: lpDataObj = (LPDATAOBJECT)ContainerDoc_GetSingleOleObject(
2671: lpContainerDoc,
2672: &IID_IDataObject,
2673: (LPCONTAINERLINE FAR*)&lpContainerLine
2674: );
2675: }
2676:
2677: /* Caller is querying if we support certain format but does not
2678: ** want any data actually returned.
2679: */
2680: if (lpformatetc->cfFormat == lpContainerApp->m_cfCntrOutl) {
2681: // we only support ISTORAGE medium
2682: sc = GetScode( OleStdQueryFormatMedium(lpformatetc, TYMED_ISTORAGE) );
2683:
2684: } else if (lpformatetc->cfFormat == lpOleApp->m_cfEmbeddedObject &&
2685: lpContainerDoc->m_fEmbeddedObjectAvail ) {
2686: sc = GetScode( OleStdQueryOleObjectData(lpformatetc) );
2687:
2688: } else if (lpformatetc->cfFormat == lpOleApp->m_cfLinkSource &&
2689: lpOleDoc->m_fLinkSourceAvail) {
2690: sc = GetScode( OleStdQueryLinkSourceData(lpformatetc) );
2691:
2692: } else if((lpformatetc->cfFormat == (lpOutlineApp)->m_cfOutline ||
2693: lpformatetc->cfFormat == CF_TEXT) ) {
2694: // we only support HGLOBAL medium
2695: sc = GetScode( OleStdQueryFormatMedium(lpformatetc, TYMED_HGLOBAL) );
2696:
2697: } else if ( lpformatetc->cfFormat == lpOleApp->m_cfObjectDescriptor ||
2698: (lpformatetc->cfFormat == lpOleApp->m_cfLinkSrcDescriptor &&
2699: lpOleDoc->m_fLinkSourceAvail) ) {
2700: sc = GetScode( OleStdQueryObjectDescriptorData(lpformatetc) );
2701:
2702: } else if (lpformatetc->cfFormat == CF_METAFILEPICT &&
2703: lpContainerDoc->m_fEmbeddedObjectAvail && lpContainerLine &&
2704: (lpformatetc->dwAspect &
2705: (lpContainerLine->m_dwDrawAspect | DVASPECT_DOCPRINT))) {
2706:
2707: /* OLE2NOTE: as a container which draws objects, when a single
2708: ** OLE object is copied, we can give the Metafile picture of
2709: ** the object. we will offer this picture when asked either
2710: ** for the actual drawing aspect that we are displaying for
2711: ** the object or for DVASPECT_DOCPRINT (if asked to render
2712: ** it to a printer)
2713: */
2714: // we only support MFPICT medium
2715: sc = GetScode( OleStdQueryFormatMedium(lpformatetc, TYMED_MFPICT) );
2716:
2717: } else if (lpDataObj) {
2718:
2719: /* OLE2NOTE: if this document contains a single OLE object
2720: ** (ie. cfEmbeddedObject data format is available), then
2721: ** the formats offered via our IDataObject must include
2722: ** the formats available from the OLE object itself.
2723: ** thus we delegate this call to the IDataObject* of the
2724: ** OLE object.
2725: */
2726: OLEDBG_BEGIN2("ContainerDoc_QueryGetData: delegate to OLE obj\r\n")
2727: hrErr = lpDataObj->lpVtbl->QueryGetData(lpDataObj, lpformatetc);
2728: OLEDBG_END2
2729:
2730: sc = GetScode(hrErr);
2731:
2732: } else {
2733: sc = DATA_E_FORMATETC;
2734: }
2735:
2736: if (lpDataObj)
2737: OleStdRelease((LPUNKNOWN)lpDataObj);
2738: return ResultFromScode(sc);
2739: }
2740:
2741:
2742:
2743: /* ContainerDoc_SetData
2744: * --------------------
2745: *
2746: * Set (modify) data of the document.
2747: * This routine is called via IDataObject::SetData.
2748: */
2749: HRESULT ContainerDoc_SetData (
2750: LPCONTAINERDOC lpContainerDoc,
2751: LPFORMATETC lpformatetc,
2752: LPSTGMEDIUM lpmedium,
2753: BOOL fRelease
2754: )
2755: {
2756: LPOUTLINEDOC lpOutlineDoc = (LPOUTLINEDOC)lpContainerDoc;
2757: LPOUTLINEAPP lpOutlineApp = (LPOUTLINEAPP)g_lpApp;
2758:
2759: if (lpformatetc->cfFormat == lpOutlineApp->m_cfOutline)
2760: OutlineDoc_PasteOutlineData(lpOutlineDoc,lpmedium->u.hGlobal,-1);
2761: else if (lpformatetc->cfFormat == CF_TEXT)
2762: OutlineDoc_PasteTextData(lpOutlineDoc,lpmedium->u.hGlobal,-1);
2763: else
2764: return ResultFromScode(DATA_E_FORMATETC);
2765:
2766: return NOERROR;
2767: }
2768:
2769:
2770: /* ContainerDoc_EnumFormatEtc
2771: * --------------------------
2772: *
2773: * Return an enumerator which enumerates the data accepted/offered by
2774: * the document.
2775: * This routine is called via IDataObject::SetData.
2776: */
2777: HRESULT ContainerDoc_EnumFormatEtc(
2778: LPCONTAINERDOC lpContainerDoc,
2779: DWORD dwDirection,
2780: LPENUMFORMATETC FAR* lplpenumFormatEtc
2781: )
2782: {
2783: LPOLEDOC lpOleDoc = (LPOLEDOC)lpContainerDoc;
2784: LPOUTLINEDOC lpOutlineDoc = (LPOUTLINEDOC)lpContainerDoc;
2785: LPOLEAPP lpOleApp = (LPOLEAPP)g_lpApp;
2786: LPCONTAINERAPP lpContainerApp = (LPCONTAINERAPP)lpOleApp;
2787: int nActualFmts;
2788: int i;
2789: SCODE sc = S_OK;
2790:
2791: /* the Container-Only version of Outline does NOT offer
2792: ** IDataObject interface from its User documents.
2793: */
2794: if (! lpOutlineDoc->m_fDataTransferDoc)
2795: return ResultFromScode(E_FAIL);
2796:
2797: if (dwDirection == DATADIR_GET) {
2798: if (lpContainerDoc->m_fEmbeddedObjectAvail) {
2799:
2800: /* OLE2NOTE: if this document contains a single OLE object
2801: ** (ie. cfEmbeddedObject data format is available), then
2802: ** the formats offered via our enumerator must include
2803: ** the formats available from the OLE object itself. we
2804: ** have previously set up a special array of FORMATETC's
2805: ** in OutlineDoc_CreateDataTransferDoc routine which includes
2806: ** the combination of data we offer directly and data
2807: ** offered by the OLE object.
2808: */
2809:
2810: /* If the document does not have a Moniker, then exclude
2811: ** CF_LINKSOURCE CF_LINKSRCDESCRIPTOR from the list of
2812: ** formats available. these formats are deliberately
2813: ** listed last in the array of possible "Get" formats.
2814: */
2815: nActualFmts = lpContainerApp->m_nSingleObjGetFmts;
2816: if (! lpOleDoc->m_fLinkSourceAvail)
2817: nActualFmts -= 2;
2818:
2819: // set correct dwDrawAspect for METAFILEPICT of object copied
2820: for (i = 0; i < nActualFmts; i++) {
2821: if (lpContainerApp->m_arrSingleObjGetFmts[i].cfFormat ==
2822: CF_METAFILEPICT) {
2823: lpContainerApp->m_arrSingleObjGetFmts[i].dwAspect =
2824: lpContainerDoc->m_dwAspectOleObjCopied;
2825: break; // DONE
2826: }
2827: }
2828: *lplpenumFormatEtc = OleStdEnumFmtEtc_Create(
2829: nActualFmts, lpContainerApp->m_arrSingleObjGetFmts);
2830: if (*lplpenumFormatEtc == NULL)
2831: sc = E_OUTOFMEMORY;
2832:
2833: } else {
2834:
2835: /* This document does NOT offer cfEmbeddedObject,
2836: ** therefore we can simply enumerate the
2837: ** static list of formats that we handle directly.
2838: */
2839: *lplpenumFormatEtc = OleStdEnumFmtEtc_Create(
2840: lpOleApp->m_nDocGetFmts, lpOleApp->m_arrDocGetFmts);
2841: if (*lplpenumFormatEtc == NULL)
2842: sc = E_OUTOFMEMORY;
2843: }
2844: } else if (dwDirection == DATADIR_SET) {
2845: /* OLE2NOTE: a document that is used to transfer data
2846: ** (either via the clipboard or drag/drop does NOT
2847: ** accept SetData on ANY format!
2848: */
2849: sc = E_NOTIMPL;
2850:
2851: } else {
2852: sc = E_NOTIMPL;
2853: }
2854:
2855: return ResultFromScode(sc);
2856: }
2857:
2858:
2859: #if defined( OPTIONAL_ADVANCED_DATA_TRANSFER )
2860: /* OLE2NOTE: optionally, a container that wants to have a
2861: ** potentially richer data transfer, can enumerate the data
2862: ** formats from the OLE object's cache and offer them too. if
2863: ** the object has a special handler, then it might be able to
2864: ** render additional data formats.
2865: **
2866: ** CNTROUTL does NOT enumerate the cache; it implements the simpler
2867: ** strategy of offering a static list of formats. the following
2868: ** function is included in order to illustrates how enumerating the
2869: ** cache could be done. CNTROUTL does NOT call this function.
2870: **
2871: */
2872:
2873: /* ContainerDoc_SetupDocGetFmts
2874: ** ----------------------------
2875: ** Setup the combined list of formats that this data transfer
2876: ** ContainerDoc which contains a single OLE object should offer.
2877: **
2878: ** OLE2NOTE: The list of formats that should be offered when a
2879: ** single OLE object is being transfered include the following:
2880: ** * any formats the container app wants to give
2881: ** * CF_EMBEDDEDOBJECT
2882: ** * CF_METAFILEPICT
2883: ** * any formats that the OLE object's cache can offer directly
2884: **
2885: ** We will offer the following formats in the order given:
2886: ** 1. CF_CNTROUTL
2887: ** 2. CF_EMBEDDEDOBJECT
2888: ** 3. CF_OBJECTDESCRIPTOR
2889: ** 4. CF_METAFILEPICT
2890: ** 5. <data formats from OLE object's cache>
2891: ** 6. CF_OUTLINE
2892: ** 7. CF_TEXT
2893: ** 8. CF_LINKSOURCE
2894: ** 9. CF_LINKSRCDESCRIPTOR
2895: */
2896: BOOL ContainerDoc_SetupDocGetFmts(
2897: LPCONTAINERDOC lpContainerDoc,
2898: LPCONTAINERLINE lpContainerLine
2899: )
2900: {
2901: LPOLEDOC lpOleDoc = (LPOLEDOC)lpContainerDoc;
2902: LPOLEAPP lpOleApp = (LPOLEAPP)g_lpApp;
2903: LPCONTAINERAPP lpContainerApp = (LPCONTAINERAPP)g_lpApp;
2904: LPOLECACHE lpOleCache;
2905: HRESULT hrErr;
2906: STATDATA StatData;
2907: LPENUMSTATDATA lpEnumStatData = NULL;
2908: LPFORMATETC lparrDocGetFmts = NULL;
2909: UINT nOleObjFmts = 0;
2910: UINT nTotalFmts;
2911: UINT i;
2912: UINT iFmt;
2913:
2914: lpOleCache = (LPOLECACHE)OleStdQueryInterface(
2915: (LPUNKNOWN)lpContainerLine->m_lpOleObj,
2916: &IID_IOleCache
2917: );
2918: if (lpOleCache) {
2919: OLEDBG_BEGIN2("IOleCache::EnumCache called\r\n")
2920: hrErr = lpOleCache->lpVtbl->EnumCache(
2921: lpOleCache,
2922: (LPENUMSTATDATA FAR*)&lpEnumStatData
2923: );
2924: OLEDBG_END2
2925: }
2926:
2927: if (lpEnumStatData) {
2928: /* Cache enumerator is available. count the number of
2929: ** formats that the OLE object's cache offers.
2930: */
2931: while(lpEnumStatData->lpVtbl->Next(
2932: lpEnumStatData,
2933: 1,
2934: (LPSTATDATA)&StatData,
2935: NULL) == NOERROR) {
2936: nOleObjFmts++;
2937: // OLE2NOTE: we MUST free the TargetDevice
2938: OleStdFree(StatData.formatetc.ptd);
2939: }
2940: lpEnumStatData->lpVtbl->Reset(lpEnumStatData); // reset for next loop
2941: }
2942:
2943: /* OLE2NOTE: the maximum total number of formats that our IDataObject
2944: ** could offer equals the sum of the following:
2945: ** n offered by the OLE object's cache
2946: ** + n normally offered by our app
2947: ** + 1 CF_EMBEDDEDOBJECT
2948: ** + 1 CF_METAFILEPICT
2949: ** + 1 CF_LINKSOURCE
2950: ** + 1 CF_LINKSRCDESCRIPTOR
2951: ** the actual number of formats that we can offer could be less
2952: ** than this total if there is any clash between the formats
2953: ** that we offer directly and those offered by the cache. if
2954: ** there is a clash, the container's rendering overrides that of
2955: ** the object. eg.: as a container transfering an OLE object we
2956: ** should directly offer CF_METAFILEPICT to guarantee that this
2957: ** format is always available. thus, if the cache offers
2958: ** CF_METAFILEPICT then it is skipped.
2959: */
2960: nTotalFmts = nOleObjFmts + lpOleApp->m_nDocGetFmts + 4;
2961: lparrDocGetFmts = (LPFORMATETC)New (nTotalFmts * sizeof(FORMATETC));
2962:
2963: if (! OleDbgVerifySz(lparrDocGetFmts != NULL,
2964: "Error allocating arrDocGetFmts"))
2965: return FALSE;
2966:
2967: for (i = 0, iFmt = 0; i < lpOleApp->m_nDocGetFmts; i++) {
2968: _fmemcpy((LPFORMATETC)&lparrDocGetFmts[iFmt++],
2969: (LPFORMATETC)&lpOleApp->m_arrDocGetFmts[i],
2970: sizeof(FORMATETC)
2971: );
2972: if (lpOleApp->m_arrDocGetFmts[i].cfFormat ==
2973: lpContainerApp->m_cfCntrOutl) {
2974: /* insert CF_EMBEDDEDOBJECT, CF_METAFILEPICT, and formats
2975: ** available from the OLE object's cache following
2976: ** CF_CNTROUTL.
2977: */
2978: lparrDocGetFmts[iFmt].cfFormat = lpOleApp->m_cfEmbeddedObject;
2979: lparrDocGetFmts[iFmt].ptd = NULL;
2980: lparrDocGetFmts[iFmt].dwAspect = DVASPECT_CONTENT;
2981: lparrDocGetFmts[iFmt].tymed = TYMED_ISTORAGE;
2982: lparrDocGetFmts[iFmt].lindex = -1;
2983: iFmt++;
2984: lparrDocGetFmts[iFmt].cfFormat = CF_METAFILEPICT;
2985: lparrDocGetFmts[iFmt].ptd = NULL;
2986: lparrDocGetFmts[iFmt].dwAspect = lpContainerLine->m_dwDrawAspect;
2987: lparrDocGetFmts[iFmt].tymed = TYMED_MFPICT;
2988: lparrDocGetFmts[iFmt].lindex = -1;
2989: iFmt++;
2990:
2991: if (lpEnumStatData) {
2992: /* Cache enumerator is available. enumerate all of
2993: ** the formats that the OLE object's cache offers.
2994: */
2995: while(lpEnumStatData->lpVtbl->Next(
2996: lpEnumStatData,
2997: 1,
2998: (LPSTATDATA)&StatData,
2999: NULL) == NOERROR) {
3000: /* check if the format clashes with one of our fmts */
3001: if (StatData.formatetc.cfFormat != CF_METAFILEPICT
3002: && ! OleStdIsDuplicateFormat(
3003: (LPFORMATETC)&StatData.formatetc,
3004: lpOleApp->m_arrDocGetFmts,
3005: lpOleApp->m_nDocGetFmts)) {
3006: OleStdCopyFormatEtc(
3007: &(lparrDocGetFmts[iFmt]),&StatData.formatetc);
3008: iFmt++;
3009: }
3010: // OLE2NOTE: we MUST free the TargetDevice
3011: OleStdFree(StatData.formatetc.ptd);
3012: }
3013: }
3014: }
3015: }
3016:
3017: if (lpOleCache)
3018: OleStdRelease((LPUNKNOWN)lpOleCache);
3019:
3020: /* append CF_LINKSOURCE format */
3021: lparrDocGetFmts[iFmt].cfFormat = lpOleApp->m_cfLinkSource;
3022: lparrDocGetFmts[iFmt].ptd = NULL;
3023: lparrDocGetFmts[iFmt].dwAspect = DVASPECT_CONTENT;
3024: lparrDocGetFmts[iFmt].tymed = TYMED_ISTREAM;
3025: lparrDocGetFmts[iFmt].lindex = -1;
3026: iFmt++;
3027:
3028: /* append CF_LINKSRCDESCRIPTOR format */
3029: lparrDocGetFmts[iFmt].cfFormat = lpOleApp->m_cfLinkSrcDescriptor;
3030: lparrDocGetFmts[iFmt].ptd = NULL;
3031: lparrDocGetFmts[iFmt].dwAspect = DVASPECT_CONTENT;
3032: lparrDocGetFmts[iFmt].tymed = TYMED_HGLOBAL;
3033: lparrDocGetFmts[iFmt].lindex = -1;
3034: iFmt++;
3035:
3036: lpContainerDoc->m_lparrDocGetFmts = lparrDocGetFmts;
3037: lpContainerDoc->m_nDocGetFmts = iFmt;
3038:
3039: if (lpEnumStatData)
3040: OleStdVerifyRelease(
3041: (LPUNKNOWN)lpEnumStatData,
3042: "Cache enumerator not released properly"
3043: );
3044:
3045: return TRUE;
3046: }
3047: #endif // OPTIONAL_ADVANCED_DATA_TRANSFER
3048:
3049: #endif // OLE_CNTR
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.