![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cntrline.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 cntrline.c CVS log | Up to [WindowsNT SDKs] / mstools / ole20 / samples / outline |
1.1 root 1: /*************************************************************************
2: **
3: ** OLE 2 Container Sample Code
4: **
5: ** cntrline.c
6: **
7: ** This file contains ContainerLine methods.
8: **
9: ** (c) Copyright Microsoft Corp. 1992 - 1993 All Rights Reserved
10: **
11: *************************************************************************/
12:
13: #include "outline.h"
14:
15: OLEDBGDATA
16:
17:
18:
19: extern LPOUTLINEAPP g_lpApp;
20: extern IUnknownVtbl g_CntrLine_UnknownVtbl;
21: extern IOleClientSiteVtbl g_CntrLine_OleClientSiteVtbl;
22: extern IAdviseSinkVtbl g_CntrLine_AdviseSinkVtbl;
23:
24: #if defined( INPLACE_CNTR )
25: extern IOleInPlaceSiteVtbl g_CntrLine_OleInPlaceSiteVtbl;
26: extern BOOL g_fInsideOutContainer;
27: #endif // INPLACE_CNTR
28:
29: // REVIEW: should use string resource for messages
30: char ErrMsgDoVerb[] = "OLE object action failed!";
31:
32:
33: /* prototype for static functions */
34: static void InvertDiffRect(LPRECT lprcPix, LPRECT lprcObj, HDC hDC);
35:
36:
37: /*************************************************************************
38: ** ContainerLine
39: ** This object represents the location within the container where
40: ** the embedded/linked object lives. It exposes interfaces to the
41: ** object that allow the object to get information about its
42: ** embedding site and to announce notifications of important events
43: ** (changed, closed, saved)
44: **
45: ** The ContainerLine exposes the following interfaces:
46: ** IOleClientSite
47: ** IAdviseSink
48: *************************************************************************/
49:
50:
51:
52: /* ContainerLine_Init
53: ** ------------------
54: ** Initialize fields in a newly constructed ContainerLine line object.
55: ** NOTE: ref cnt of ContainerLine initialized to 0
56: */
57: void ContainerLine_Init(LPCONTAINERLINE lpContainerLine, int nTab, HDC hDC)
58: {
59: Line_Init((LPLINE)lpContainerLine, nTab, hDC); // init base class fields
60:
61: ((LPLINE)lpContainerLine)->m_lineType = CONTAINERLINETYPE;
62: ((LPLINE)lpContainerLine)->m_nWidthInHimetric = DEFOBJWIDTH;
63: ((LPLINE)lpContainerLine)->m_nHeightInHimetric = DEFOBJHEIGHT;
64: lpContainerLine->m_cRef = 0;
65: lpContainerLine->m_szStgName[0] = '\0';
66: lpContainerLine->m_fObjWinOpen = FALSE;
67: lpContainerLine->m_fMonikerAssigned = FALSE;
68: lpContainerLine->m_dwDrawAspect = DVASPECT_CONTENT;
69:
70: /* when we initially create the ContainerLine we do not know the
71: ** extents of the object. force the extents to be updated the
72: ** first time the line is drawn.
73: */
74: lpContainerLine->m_fDoGetExtent = TRUE;
75: lpContainerLine->m_sizeInHimetric.cx = -1;
76: lpContainerLine->m_sizeInHimetric.cy = -1;
77:
78: lpContainerLine->m_lpStg = NULL;
79: lpContainerLine->m_lpOleObj = NULL;
80: lpContainerLine->m_lpViewObj = NULL;
81: lpContainerLine->m_lpPersistStg = NULL;
82: lpContainerLine->m_lpDoc = NULL;
83: lpContainerLine->m_fIsLink = FALSE;
84: lpContainerLine->m_fLinkUnavailable = FALSE;
85: lpContainerLine->m_lpszShortType = NULL;
86:
87: #if defined( INPLACE_CNTR )
88: lpContainerLine->m_fIpActive = FALSE;
89: lpContainerLine->m_fUIActive = FALSE;
90: lpContainerLine->m_fIpVisible = FALSE;
91: lpContainerLine->m_lpOleIPObj = NULL;
92: lpContainerLine->m_fInsideOutObj = FALSE;
93: lpContainerLine->m_fIpChangesUndoable = FALSE;
94: lpContainerLine->m_fIpServerRunning = FALSE;
95: #endif // INPLACE_CNTR
96:
97: INIT_INTERFACEIMPL(
98: &lpContainerLine->m_Unknown,
99: &g_CntrLine_UnknownVtbl,
100: lpContainerLine
101: );
102:
103: INIT_INTERFACEIMPL(
104: &lpContainerLine->m_OleClientSite,
105: &g_CntrLine_OleClientSiteVtbl,
106: lpContainerLine
107: );
108:
109: INIT_INTERFACEIMPL(
110: &lpContainerLine->m_AdviseSink,
111: &g_CntrLine_AdviseSinkVtbl,
112: lpContainerLine
113: );
114:
115: #if defined( INPLACE_CNTR )
116: INIT_INTERFACEIMPL(
117: &lpContainerLine->m_OleInPlaceSite,
118: &g_CntrLine_OleInPlaceSiteVtbl,
119: lpContainerLine
120: );
121: #endif // INPLACE_CNTR
122: }
123:
124:
125: /* Create an ContainerLine object and return the pointer */
126: LPCONTAINERLINE ContainerLine_Create(
127: DWORD dwOleCreateType,
128: HDC hDC,
129: UINT nTab,
130: LPCONTAINERDOC lpContainerDoc,
131: LPCLSID lpclsid,
132: LPSTR lpszFileName,
133: BOOL fDisplayAsIcon,
134: HGLOBAL hMetaPict,
135: LPSTR lpszStgName
136: )
137: {
138: LPCONTAINERLINE lpContainerLine = NULL;
139: LPOLEOBJECT lpObj = NULL;
140: LPSTORAGE lpDocStg = ContainerDoc_GetStg(lpContainerDoc);
141: DWORD dwDrawAspect =
142: (fDisplayAsIcon ? DVASPECT_ICON : DVASPECT_CONTENT);
143: DWORD dwOleRenderOpt =
144: (fDisplayAsIcon ? OLERENDER_NONE : OLERENDER_DRAW);
145: HRESULT hrErr;
146:
147: OLEDBG_BEGIN3("ContainerLine_Create\r\n")
148:
149: if (! OleDbgVerifySz(lpDocStg != NULL, "Doc storage is NULL"))
150: goto error;
151:
152: lpContainerLine=(LPCONTAINERLINE) New((DWORD)sizeof(CONTAINERLINE));
153: if (lpContainerLine == NULL) {
154: OleDbgAssertSz(
155: lpContainerLine!=NULL, "Error allocating ContainerLine");
156: goto error;
157: }
158:
159: ContainerLine_Init(lpContainerLine, nTab, hDC);
160:
161: /* OLE2NOTE: In order to have a stable ContainerLine object we must
162: ** AddRef the object's refcnt. this will be later released when
163: ** the ContainerLine is deleted.
164: */
165: ContainerLine_AddRef(lpContainerLine);
166:
167: lstrcpy(lpContainerLine->m_szStgName, lpszStgName);
168: lpContainerLine->m_lpDoc = lpContainerDoc;
169:
170: /* Create a new storage for the object inside the doc's storage */
171: lpContainerLine->m_lpStg = OleStdCreateChildStorage(lpDocStg,lpszStgName);
172: if (! OleDbgVerifySz(lpContainerLine->m_lpStg != NULL,
173: "Error creating child stg"))
174: goto error;
175:
176: lpContainerLine->m_fIsLink = FALSE;
177:
178: switch (dwOleCreateType) {
179:
180: case IOF_SELECTCREATENEW:
181:
182: OLEDBG_BEGIN2("OleCreate called\r\n")
183: hrErr = OleCreate (
184: lpclsid,
185: &IID_IOleObject,
186: dwOleRenderOpt,
187: NULL,
188: (LPOLECLIENTSITE)&lpContainerLine->m_OleClientSite,
189: lpContainerLine->m_lpStg,
190: (LPVOID FAR*)&lpContainerLine->m_lpOleObj
191: );
192: OLEDBG_END2
193:
194: #if defined( INPLACE_CNTR )
195: /* OLE2NOTE: an inside-out container should check if
196: ** the object is an inside-out and prefers to be
197: ** activated when visible type of object. if not the
198: ** object should not be allowed to keep its window
199: ** up after it gets UIDeactivated.
200: */
201: if (g_fInsideOutContainer &&
202: lpContainerLine->m_dwDrawAspect == DVASPECT_CONTENT) {
203: DWORD mstat;
204: OLEDBG_BEGIN2("IOleObject::GetMiscStatus called\r\n")
205: lpContainerLine->m_lpOleObj->lpVtbl->GetMiscStatus(
206: lpContainerLine->m_lpOleObj,
207: DVASPECT_CONTENT,
208: (DWORD FAR*)&mstat
209: );
210: OLEDBG_END2
211:
212: lpContainerLine->m_fInsideOutObj = (BOOL)
213: (mstat &
214: (OLEMISC_INSIDEOUT|OLEMISC_ACTIVATEWHENVISIBLE));
215: }
216: #endif // INPLACE_CNTR
217:
218: break;
219:
220: case IOF_SELECTCREATEFROMFILE:
221:
222: OLEDBG_BEGIN2("OleCreateFromFile called\r\n")
223:
224: hrErr = OleCreateFromFile (
225: &CLSID_NULL,
226: lpszFileName,
227: &IID_IOleObject,
228: dwOleRenderOpt,
229: NULL,
230: (LPOLECLIENTSITE)&lpContainerLine->m_OleClientSite,
231: lpContainerLine->m_lpStg,
232: (LPVOID FAR*)&lpContainerLine->m_lpOleObj
233: );
234:
235: OLEDBG_END2
236: break;
237:
238: case IOF_CHECKLINK:
239:
240: OLEDBG_BEGIN2("OleCreateLinkToFile called\r\n")
241:
242: hrErr = OleCreateLinkToFile (
243: lpszFileName,
244: &IID_IOleObject,
245: dwOleRenderOpt,
246: NULL,
247: (LPOLECLIENTSITE)&lpContainerLine->m_OleClientSite,
248: lpContainerLine->m_lpStg,
249: (LPVOID FAR*)&lpContainerLine->m_lpOleObj
250: );
251:
252: OLEDBG_END2
253: lpContainerLine->m_fIsLink = TRUE;
254: break;
255: }
256:
257: if (hrErr != NOERROR) {
258: OutlineApp_ErrorMessage(g_lpApp, "Could not create object!");
259: goto error;
260: }
261:
262: /* Setup the Advises (OLE notifications) that we are interested
263: ** in receiving.
264: */
265: OleStdSetupAdvises(
266: lpContainerLine->m_lpOleObj,
267: dwDrawAspect,
268: (LPSTR)APPNAME,
269: ((LPOUTLINEDOC)lpContainerDoc)->m_lpszDocTitle,
270: (LPADVISESINK)&lpContainerLine->m_AdviseSink
271: );
272:
273: if (fDisplayAsIcon) {
274: BOOL fMustUpdate;
275:
276: /* user has requested to display icon aspect instead of content
277: ** aspect.
278: ** NOTE: we do not have to delete the previous aspect cache
279: ** because one did not get set up.
280: */
281: OleStdSwitchDisplayAspect(
282: lpContainerLine->m_lpOleObj,
283: &lpContainerLine->m_dwDrawAspect,
284: dwDrawAspect,
285: hMetaPict,
286: FALSE, /* fDeleteOldAspect */
287: TRUE, /* fSetupViewAdvise */
288: (LPADVISESINK)&lpContainerLine->m_AdviseSink,
289: (BOOL FAR*)&fMustUpdate // this can be ignored; update
290: // for switch to icon not req'd
291: );
292: }
293: OLEDBG_END3
294: return lpContainerLine;
295:
296: error:
297: // Destroy partially created OLE object
298: if (lpContainerLine)
299: ContainerLine_Delete(lpContainerLine);
300: OLEDBG_END3
301: return NULL;
302: }
303:
304:
305: LPCONTAINERLINE ContainerLine_CreateFromData(
306: HDC hDC,
307: UINT nTab,
308: LPCONTAINERDOC lpContainerDoc,
309: LPDATAOBJECT lpSrcDataObj,
310: DWORD dwCreateType,
311: CLIPFORMAT cfFormat,
312: BOOL fDisplayAsIcon,
313: HGLOBAL hMetaPict,
314: LPSTR lpszStgName
315: )
316: {
317: HGLOBAL hData = NULL;
318: LPCONTAINERLINE lpContainerLine = NULL;
319: LPOLEOBJECT lpObj = NULL;
320: LPSTORAGE lpDocStg = ContainerDoc_GetStg(lpContainerDoc);
321: DWORD dwDrawAspect =
322: (fDisplayAsIcon ? DVASPECT_ICON : DVASPECT_CONTENT);
323: DWORD dwOleRenderOpt =
324: (fDisplayAsIcon ? OLERENDER_NONE : OLERENDER_DRAW);
325: FORMATETC renderFmtEtc;
326: LPFORMATETC lpRenderFmtEtc = NULL;
327: HRESULT hrErr;
328: LPUNKNOWN lpUnk = NULL;
329:
330: OLEDBG_BEGIN3("ContainerLine_CreateFromData\r\n")
331:
332: if (dwCreateType == OLECREATEFROMDATA_STATIC && cfFormat != 0) {
333: // a particular type of static object should be created
334:
335: dwOleRenderOpt = OLERENDER_FORMAT;
336: lpRenderFmtEtc = (LPFORMATETC)&renderFmtEtc;
337:
338: if (cfFormat == CF_METAFILEPICT)
339: SETDEFAULTFORMATETC(renderFmtEtc, cfFormat, TYMED_MFPICT);
340: else if (cfFormat == CF_BITMAP)
341: SETDEFAULTFORMATETC(renderFmtEtc, cfFormat, TYMED_GDI);
342: else
343: SETDEFAULTFORMATETC(renderFmtEtc, cfFormat, TYMED_HGLOBAL);
344: } else if (fDisplayAsIcon) {
345: dwOleRenderOpt = OLERENDER_NONE;
346:
347: } else {
348: dwOleRenderOpt = OLERENDER_DRAW;
349: }
350:
351: if (! OleDbgVerifySz(lpDocStg != NULL, "Doc storage is NULL"))
352: goto error;
353:
354: lpContainerLine=(LPCONTAINERLINE) New((DWORD)sizeof(CONTAINERLINE));
355: if (lpContainerLine == NULL) {
356: OleDbgAssertSz(
357: lpContainerLine!=NULL, "Error allocating ContainerLine");
358: goto error;
359: }
360:
361: ContainerLine_Init(lpContainerLine, nTab, hDC);
362:
363: /* OLE2NOTE: In order to have a stable ContainerLine object we must
364: ** AddRef the object's refcnt. this will be later released when
365: ** the ContainerLine is deleted.
366: */
367: ContainerLine_AddRef(lpContainerLine);
368:
369: lstrcpy(lpContainerLine->m_szStgName, lpszStgName);
370: lpContainerLine->m_lpDoc = lpContainerDoc;
371:
372: /* Create a new storage for the object inside the doc's storage */
373: lpContainerLine->m_lpStg = OleStdCreateChildStorage(lpDocStg,lpszStgName);
374: if (! OleDbgVerifySz(lpContainerLine->m_lpStg != NULL,
375: "Error creating child stg"))
376: goto error;
377:
378: switch (dwCreateType) {
379:
380: case OLECREATEFROMDATA_LINK:
381:
382: OLEDBG_BEGIN2("OleCreateLinkFromData called\r\n")
383: hrErr = OleCreateLinkFromData (
384: lpSrcDataObj,
385: &IID_IOleObject,
386: dwOleRenderOpt,
387: lpRenderFmtEtc,
388: (LPOLECLIENTSITE)&lpContainerLine->m_OleClientSite,
389: lpContainerLine->m_lpStg,
390: (LPVOID FAR*)&lpContainerLine->m_lpOleObj
391: );
392: OLEDBG_END2
393:
394: if (hrErr != NOERROR) {
395: OleDbgOutHResult("OleCreateLinkFromData returned", hrErr);
396: }
397:
398: lpContainerLine->m_fIsLink = TRUE;
399: break;
400:
401: case OLECREATEFROMDATA_OBJECT:
402:
403: OLEDBG_BEGIN2("OleCreateFromData called\r\n")
404: hrErr = OleCreateFromData (
405: lpSrcDataObj,
406: &IID_IOleObject,
407: dwOleRenderOpt,
408: lpRenderFmtEtc,
409: (LPOLECLIENTSITE)&lpContainerLine->m_OleClientSite,
410: lpContainerLine->m_lpStg,
411: (LPVOID FAR*)&lpContainerLine->m_lpOleObj
412: );
413: OLEDBG_END2
414:
415: if (hrErr != NOERROR) {
416: OleDbgOutHResult("OleCreateFromData returned", hrErr);
417: }
418:
419: lpUnk=ContainerLine_GetOleObject(lpContainerLine,&IID_IOleLink);
420: if (lpUnk) {
421: OleStdRelease(lpUnk);
422: lpContainerLine->m_fIsLink = TRUE;
423: }
424: else {
425: lpContainerLine->m_fIsLink = FALSE;
426:
427: #if defined( INPLACE_CNTR )
428: /* OLE2NOTE: an inside-out container should check if
429: ** the object is an inside-out and prefers to be
430: ** activated when visible type of object. if not the
431: ** object should not be allowed to keep its window
432: ** up after it gets UIDeactivated.
433: */
434: if (g_fInsideOutContainer &&
435: lpContainerLine->m_dwDrawAspect == DVASPECT_CONTENT) {
436: DWORD mstat;
437: OLEDBG_BEGIN2("IOleObject::GetMiscStatus called\r\n")
438: lpContainerLine->m_lpOleObj->lpVtbl->GetMiscStatus(
439: lpContainerLine->m_lpOleObj,
440: DVASPECT_CONTENT,
441: (DWORD FAR*)&mstat
442: );
443: OLEDBG_END2
444:
445: lpContainerLine->m_fInsideOutObj = (BOOL)
446: (mstat &
447: (OLEMISC_INSIDEOUT|OLEMISC_ACTIVATEWHENVISIBLE));
448: }
449: #endif // INPLACE_CNTR
450:
451: }
452: break;
453:
454: case OLECREATEFROMDATA_STATIC:
455:
456: OLEDBG_BEGIN2("OleCreateStaticFromData called\r\n")
457: hrErr = OleCreateStaticFromData (
458: lpSrcDataObj,
459: &IID_IOleObject,
460: dwOleRenderOpt,
461: lpRenderFmtEtc,
462: (LPOLECLIENTSITE)&lpContainerLine->m_OleClientSite,
463: lpContainerLine->m_lpStg,
464: (LPVOID FAR*)&lpContainerLine->m_lpOleObj
465: );
466: OLEDBG_END2
467:
468: if (hrErr != NOERROR) {
469: OleDbgOutHResult("OleCreateStaticFromData returned", hrErr);
470: }
471:
472: lpContainerLine->m_fIsLink = FALSE;
473: break;
474: }
475:
476: if (hrErr != NOERROR) {
477: OutlineApp_ErrorMessage(g_lpApp, "Could not create object!");
478: goto error;
479: }
480:
481: /* Setup the Advises (OLE notifications) that we are interested
482: ** in receiving.
483: */
484: OleStdSetupAdvises(
485: lpContainerLine->m_lpOleObj,
486: dwDrawAspect,
487: (LPSTR)APPNAME,
488: ((LPOUTLINEDOC)lpContainerDoc)->m_lpszDocTitle,
489: (LPADVISESINK)&lpContainerLine->m_AdviseSink
490: );
491:
492: if (fDisplayAsIcon) {
493: BOOL fMustUpdate;
494:
495: /* user has requested to display icon aspect instead of content
496: ** aspect.
497: ** NOTE: we do not have to delete the previous aspect cache
498: ** because one did not get set up.
499: */
500: OleStdSwitchDisplayAspect(
501: lpContainerLine->m_lpOleObj,
502: &lpContainerLine->m_dwDrawAspect,
503: dwDrawAspect,
504: hMetaPict,
505: FALSE, /* fDeleteOldAspect */
506: TRUE, /* fSetupViewAdvise */
507: (LPADVISESINK)&lpContainerLine->m_AdviseSink,
508: (BOOL FAR*)&fMustUpdate // this can be ignored; update
509: // for switch to icon not req'd
510: );
511: }
512:
513: OLEDBG_END3
514: return lpContainerLine;
515:
516: error:
517: // Destroy partially created OLE object
518: if (lpContainerLine)
519: ContainerLine_Delete(lpContainerLine);
520: OLEDBG_END3
521: return NULL;
522: }
523:
524:
525: /* ContainerLine_AddRef
526: ** --------------------
527: **
528: ** increment the ref count of the line object.
529: **
530: ** Returns the new ref count on the object
531: */
532: ULONG ContainerLine_AddRef(LPCONTAINERLINE lpContainerLine)
533: {
534: ++lpContainerLine->m_cRef;
535:
536: OleDbgOutRefCnt4(
537: "ContainerLine_AddRef: cRef++\r\n",
538: lpContainerLine,
539: lpContainerLine->m_cRef
540: );
541:
542: return lpContainerLine->m_cRef;
543: }
544:
545:
546: /* ContainerLine_Release
547: ** ---------------------
548: **
549: ** decrement the ref count of the line object.
550: ** if the ref count goes to 0, then the line is destroyed.
551: **
552: ** Returns the remaining ref count on the object
553: */
554: ULONG ContainerLine_Release(LPCONTAINERLINE lpContainerLine)
555: {
556: ULONG cRef;
557:
558: OleDbgAssertSz(lpContainerLine->m_cRef > 0,"Release called with cRef == 0");
559:
560: /*********************************************************************
561: ** OLE2NOTE: when the obj refcnt == 0, then destroy the object. **
562: ** otherwise the object is still in use. **
563: *********************************************************************/
564:
565: cRef = --lpContainerLine->m_cRef;
566:
567: OleDbgOutRefCnt4(
568: "ContainerLine_AddRef: cRef--\r\n",
569: lpContainerLine,
570: cRef
571: );
572:
573: if (cRef == 0)
574: ContainerLine_Destroy(lpContainerLine);
575:
576: return cRef;
577: }
578:
579:
580: /* ContainerLine_QueryInterface
581: ** ----------------------------
582: **
583: ** Retrieve a pointer to an interface on the ContainerLine object.
584: **
585: ** Returns NOERROR if interface is successfully retrieved.
586: ** E_NOINTERFACE if the interface is not supported
587: */
588: HRESULT ContainerLine_QueryInterface(
589: LPCONTAINERLINE lpContainerLine,
590: REFIID riid,
591: LPVOID FAR* lplpvObj
592: )
593: {
594: SCODE sc = E_NOINTERFACE;
595:
596: /* OLE2NOTE: we must make sure to set all out ptr parameters to NULL. */
597: *lplpvObj = NULL;
598:
599: if (IsEqualIID(riid, &IID_IUnknown)) {
600: OleDbgOut4("ContainerLine_QueryInterface: IUnknown* RETURNED\r\n");
601:
602: *lplpvObj = (LPVOID) &lpContainerLine->m_Unknown;
603: ContainerLine_AddRef(lpContainerLine);
604: sc = S_OK;
605: }
606: else if (IsEqualIID(riid, &IID_IOleClientSite)) {
607: OleDbgOut4("ContainerLine_QueryInterface: IOleClientSite* RETURNED\r\n");
608:
609: *lplpvObj = (LPVOID) &lpContainerLine->m_OleClientSite;
610: ContainerLine_AddRef(lpContainerLine);
611: sc = S_OK;
612: }
613: else if (IsEqualIID(riid, &IID_IAdviseSink)) {
614: OleDbgOut4("ContainerLine_QueryInterface: IAdviseSink* RETURNED\r\n");
615:
616: *lplpvObj = (LPVOID) &lpContainerLine->m_AdviseSink;
617: ContainerLine_AddRef(lpContainerLine);
618: sc = S_OK;
619: }
620: #if defined( INPLACE_CNTR )
621: else if (IsEqualIID(riid, &IID_IOleWindow)
622: || IsEqualIID(riid, &IID_IOleInPlaceSite)) {
623: OleDbgOut4("ContainerLine_QueryInterface: IOleInPlaceSite* RETURNED\r\n");
624:
625: *lplpvObj = (LPVOID) &lpContainerLine->m_OleInPlaceSite;
626: ContainerLine_AddRef(lpContainerLine);
627: sc = S_OK;
628: }
629: #endif // INPLACE_CNTR
630:
631: OleDbgQueryInterfaceMethod(*lplpvObj);
632:
633: return ResultFromScode(sc);
634: }
635:
636:
637: BOOL ContainerLine_LoadOleObject(LPCONTAINERLINE lpContainerLine)
638: {
639: LPOUTLINEDOC lpOutlineDoc = (LPOUTLINEDOC)lpContainerLine->m_lpDoc;
640: LPSTORAGE lpDocStg = ContainerDoc_GetStg(lpContainerLine->m_lpDoc);
641: LPOLECLIENTSITE lpOleClientSite;
642: LPMONIKER lpmkObj;
643: HRESULT hrErr;
644:
645: if (lpContainerLine->m_lpOleObj)
646: return TRUE; // object already loaded
647:
648: OLEDBG_BEGIN3("ContainerLine_LoadOleObject\r\n")
649:
650: /* if object storage is not already open, then open it */
651: if (! lpContainerLine->m_lpStg) {
652: lpContainerLine->m_lpStg = OleStdOpenChildStorage(
653: lpDocStg,
654: lpContainerLine->m_szStgName,
655: STGM_READWRITE
656: );
657: if (lpContainerLine->m_lpStg == NULL) {
658: OleDbgAssertSz(
659: lpContainerLine->m_lpStg != NULL, "Error opening child stg");
660: OLEDBG_END3
661: return FALSE;
662: }
663: }
664:
665: /* OLE2NOTE: if the OLE object being loaded is in a data transfer
666: ** document, then we should NOT pass a IOleClientSite* pointer
667: ** to the OleLoad call. This particularly critical if the OLE
668: ** object is an OleLink object. If a non-NULL client site is
669: ** passed to the OleLoad function, then the link will bind to
670: ** the source if its is running. in the situation that we are
671: ** loading the object as part of a data transfer document we do
672: ** not want this connection to be established. even worse, if
673: ** the link source is currently blocked or busy, then this could
674: ** hang the system. it is simplest to never pass a
675: ** IOleClientSite* when loading an object in a data transfer
676: ** document.
677: */
678: lpOleClientSite = (lpOutlineDoc->m_fDataTransferDoc ?
679: NULL : (LPOLECLIENTSITE)&lpContainerLine->m_OleClientSite);
680:
681: OLEDBG_BEGIN2("OleLoad called\r\n")
682:
683: hrErr = OleLoad (
684: lpContainerLine->m_lpStg,
685: &IID_IOleObject,
686: lpOleClientSite,
687: (LPVOID FAR*)&lpContainerLine->m_lpOleObj
688: );
689:
690: OLEDBG_END2
691:
692: if (! OleDbgVerifySz(hrErr == NOERROR, "Could not load object!")) {
693: OleDbgOutHResult("OleLoad returned", hrErr);
694: goto error;
695: }
696:
697: // Cache a pointer to the IViewObject* interface.
698: // we need this everytime we draw the object.
699: lpContainerLine->m_lpViewObj = (LPVIEWOBJECT)OleStdQueryInterface(
700: (LPUNKNOWN)lpContainerLine->m_lpOleObj, &IID_IViewObject);
701: if (! lpContainerLine->m_lpViewObj) {
702: OleDbgAssert(lpContainerLine->m_lpViewObj);
703: goto error;
704: }
705:
706: // Cache a pointer to the IPersistStorage* interface.
707: // we need this everytime we save the object.
708: lpContainerLine->m_lpPersistStg = (LPPERSISTSTORAGE)OleStdQueryInterface(
709: (LPUNKNOWN)lpContainerLine->m_lpOleObj, &IID_IPersistStorage);
710: if (! lpContainerLine->m_lpPersistStg) {
711: OleDbgAssert(lpContainerLine->m_lpPersistStg);
712: goto error;
713: }
714:
715: /* OLE2NOTE: similarly, if the OLE object being loaded is in a data
716: ** transfer document, then we do NOT need to setup any advises,
717: ** call SetHostNames, SetMoniker, etc.
718: */
719: if (lpOleClientSite) {
720: /* Setup the Advises (OLE notifications) that we are interested
721: ** in receiving.
722: */
723: OleStdSetupAdvises(
724: lpContainerLine->m_lpOleObj,
725: lpContainerLine->m_dwDrawAspect,
726: (LPSTR)APPNAME,
727: lpOutlineDoc->m_lpszDocTitle,
728: (LPADVISESINK)&lpContainerLine->m_AdviseSink
729: );
730:
731: /* OLE2NOTE: if the OLE object has a moniker assigned, we need to
732: ** inform the object by calling IOleObject::SetMoniker. this
733: ** will force the OLE object to register in the
734: ** RunningObjectTable when it enters the running state.
735: */
736: if (lpContainerLine->m_fMonikerAssigned) {
737: lpmkObj = ContainerLine_GetRelMoniker(
738: lpContainerLine,
739: GETMONIKER_ONLYIFTHERE
740: );
741:
742: if (lpmkObj) {
743: OLEDBG_BEGIN2("IOleObject::SetMoniker called\r\n")
744: lpContainerLine->m_lpOleObj->lpVtbl->SetMoniker(
745: lpContainerLine->m_lpOleObj,
746: OLEWHICHMK_OBJREL,
747: lpmkObj
748: );
749: OLEDBG_END2
750: OleStdRelease((LPUNKNOWN)lpmkObj);
751: }
752: }
753:
754: /* get the Short form of the user type name of the object. this
755: ** is used all the time when we have to build the object
756: ** verb menu. we will cache this information to make it
757: ** quicker to build the verb menu.
758: */
759: OLEDBG_BEGIN2("IOleObject::GetUserType called\r\n")
760: lpContainerLine->m_lpOleObj->lpVtbl->GetUserType(
761: lpContainerLine->m_lpOleObj,
762: USERCLASSTYPE_SHORT,
763: (LPSTR FAR*)&lpContainerLine->m_lpszShortType
764: );
765: OLEDBG_END2
766:
767: /* OLE2NOTE: if the object we just loaded is a link then it
768: ** might have immediately bound to its link source if it was
769: ** already running. when this happens the link will get an
770: ** immediate update of data if the link is automatic. in
771: ** this situation, it is possible that the extents of the
772: ** linked object have changed.
773: */
774: if (lpContainerLine->m_fIsLink) {
775: if (OleIsRunning(lpContainerLine->m_lpOleObj)) {
776: ContainerLine_UpdateExtent(lpContainerLine, NULL);
777: }
778: }
779: #if defined( INPLACE_CNTR )
780: /* OLE2NOTE: an inside-out container should check if the object
781: ** is an inside-out and prefers to be activated when visible
782: ** type of object. if so, the object should be immediately
783: ** activated in-place, BUT NOT UIActived.
784: */
785: else if (g_fInsideOutContainer &&
786: lpContainerLine->m_dwDrawAspect == DVASPECT_CONTENT) {
787: DWORD mstat;
788: OLEDBG_BEGIN2("IOleObject::GetMiscStatus called\r\n")
789: lpContainerLine->m_lpOleObj->lpVtbl->GetMiscStatus(
790: lpContainerLine->m_lpOleObj,
791: DVASPECT_CONTENT,
792: (DWORD FAR*)&mstat
793: );
794: OLEDBG_END2
795:
796: lpContainerLine->m_fInsideOutObj = (BOOL)
797: (mstat & (OLEMISC_INSIDEOUT|OLEMISC_ACTIVATEWHENVISIBLE));
798:
799: if ( lpContainerLine->m_fInsideOutObj ) {
800: HWND hWndDoc = OutlineDoc_GetWindow(lpOutlineDoc);
801:
802: ContainerLine_DoVerb(
803: lpContainerLine,OLEIVERB_INPLACEACTIVATE,FALSE,FALSE);
804:
805: /* OLE2NOTE: following this DoVerb(INPLACEACTIVATE) the
806: ** object may have taken focus. but because the
807: ** object is NOT UIActive it should NOT have focus.
808: ** we will make sure our document has focus.
809: */
810: SetFocus(hWndDoc);
811: }
812: }
813: #endif // INPLACE_CNTR
814: OLEDBG_END2
815:
816: }
817:
818: OLEDBG_END2
819: return TRUE;
820:
821: error:
822: OLEDBG_END2
823: return FALSE;
824: }
825:
826:
827: /* ContainerLine_CloseOleObject
828: ** ----------------------------
829: ** Close the OLE object associated with the ContainerLine.
830: **
831: ** Closing the object forces the object to transition from the
832: ** running state to the loaded state. if the object was not running,
833: ** then there is no effect. it is necessary to close the OLE object
834: ** before releasing the pointers to the OLE object.
835: **
836: ** Returns TRUE if successfully closed,
837: ** FALSE if closing was aborted.
838: */
839: BOOL ContainerLine_CloseOleObject(LPCONTAINERLINE lpContainerLine)
840: {
841: HRESULT hrErr;
842: SCODE sc;
843:
844: if (lpContainerLine->m_lpOleObj) {
845:
846: OLEDBG_BEGIN2("IOleObject::Close called\r\n")
847: hrErr = lpContainerLine->m_lpOleObj->lpVtbl->Close(
848: lpContainerLine->m_lpOleObj,
849: OLECLOSE_SAVEIFDIRTY
850: );
851: OLEDBG_END2
852:
853: if (hrErr != NOERROR) {
854: OleDbgOutHResult("IOleObject::Close returned", hrErr);
855: sc = GetScode(hrErr);
856: if (sc == RPC_E_CALL_REJECTED || sc==OLE_E_PROMPTSAVECANCELLED) {
857: return FALSE; // object aborted shutdown
858: }
859: }
860: }
861: return TRUE;
862: }
863:
864:
865: /* ContainerLine_UnloadOleObject
866: ** -----------------------------
867: ** Close the OLE object associated with the ContainerLine and
868: ** release all pointer held to the object.
869: **
870: ** Closing the object forces the object to transition from the
871: ** running state to the loaded state. if the object was not running,
872: ** then there is no effect. it is necessary to close the OLE object
873: ** before releasing the pointers to the OLE object. releasing all
874: ** pointers to the object allows the object to transition from
875: ** loaded to unloaded (or passive).
876: */
877: void ContainerLine_UnloadOleObject(LPCONTAINERLINE lpContainerLine)
878: {
879: if (lpContainerLine->m_lpOleObj) {
880:
881: OLEDBG_BEGIN2("IOleObject::Close called\r\n")
882: lpContainerLine->m_lpOleObj->lpVtbl->Close(
883: lpContainerLine->m_lpOleObj,
884: OLECLOSE_SAVEIFDIRTY
885: );
886: OLEDBG_END2
887:
888: OleStdRelease((LPUNKNOWN)lpContainerLine->m_lpOleObj);
889: lpContainerLine->m_lpOleObj = NULL;
890:
891: if (lpContainerLine->m_lpViewObj) {
892: OleStdRelease((LPUNKNOWN)lpContainerLine->m_lpViewObj);
893: lpContainerLine->m_lpViewObj = NULL;
894: }
895: if (lpContainerLine->m_lpPersistStg) {
896: OleStdRelease((LPUNKNOWN)lpContainerLine->m_lpPersistStg);
897: lpContainerLine->m_lpPersistStg = NULL;
898: }
899: }
900: }
901:
902:
903: /* ContainerLine_Delete
904: ** --------------------
905: ** Delete the ContainerLine.
906: **
907: ** NOTE: we can NOT directly destroy the memory for the
908: ** ContainerLine; the ContainerLine maintains a reference count. a
909: ** non-zero reference count indicates that the object is still
910: ** in-use. The OleObject keeps a reference-counted pointer to the
911: ** ClientLine object. we must take the actions necessary so that the
912: ** ContainerLine object receives Releases for outstanding
913: ** references. when the reference count of the ContainerLine reaches
914: ** zero, then the memory for the object will actually be destroyed
915: ** (ContainerLine_Destroy called).
916: **
917: */
918: void ContainerLine_Delete(LPCONTAINERLINE lpContainerLine)
919: {
920: OLEDBG_BEGIN2("ContainerLine_Delete\r\n")
921:
922: #if defined( INPLACE_CNTR )
923: if (lpContainerLine == lpContainerLine->m_lpDoc->m_lpLastIpActiveLine)
924: lpContainerLine->m_lpDoc->m_lpLastIpActiveLine = NULL;
925: if (lpContainerLine == lpContainerLine->m_lpDoc->m_lpLastUIActiveLine)
926: lpContainerLine->m_lpDoc->m_lpLastUIActiveLine = NULL;
927: #endif
928:
929: /* OLE2NOTE: in order to have a stable line object during the
930: ** process of deleting, we intially AddRef the line ref cnt and
931: ** later Release it. This initial AddRef is artificial; it is
932: ** simply done to guarantee that our object does not destroy
933: ** itself until the END of this routine.
934: */
935: ContainerLine_AddRef(lpContainerLine);
936:
937: // Unload the loaded OLE object
938: if (lpContainerLine->m_lpOleObj)
939: ContainerLine_UnloadOleObject(lpContainerLine);
940:
941: /* OLE2NOTE: we can NOT directly free the memory for the ContainerLine
942: ** data structure until everyone holding on to a pointer to our
943: ** ClientSite interface and IAdviseSink interface has released
944: ** their pointers. There is one refcnt on the ContainerLine object
945: ** which is held by the container itself. we will release this
946: ** refcnt here.
947: */
948: ContainerLine_Release(lpContainerLine);
949:
950: ContainerLine_Release(lpContainerLine); // release artificial AddRef above
951: OLEDBG_END2
952: }
953:
954:
955: /* ContainerLine_Destroy
956: ** ---------------------
957: ** Destroy (Free) the memory used by a ContainerLine structure.
958: ** This function is called when the ref count of the ContainerLine goes
959: ** to zero. the ref cnt goes to zero after ContainerLine_Delete forces
960: ** the OleObject to unload and release its pointers to the
961: ** ContainerLine IOleClientSite and IAdviseSink interfaces.
962: */
963:
964: void ContainerLine_Destroy(LPCONTAINERLINE lpContainerLine)
965: {
966: LPUNKNOWN lpTmpObj;
967:
968: OLEDBG_BEGIN2("ContainerLine_Destroy\r\n")
969:
970: // Release the storage opened for the OLE object
971: if (lpContainerLine->m_lpStg) {
972: lpTmpObj = (LPUNKNOWN)lpContainerLine->m_lpStg;
973: lpContainerLine->m_lpStg = NULL;
974:
975: OleStdVerifyRelease(lpTmpObj, "Object stg not released");
976: }
977:
978: if (lpContainerLine->m_lpszShortType)
979: OleStdFreeString(lpContainerLine->m_lpszShortType, NULL);
980:
981: Delete(lpContainerLine); // Free the memory for the structure itself
982: OLEDBG_END2
983: }
984:
985:
986: /* ContainerLine_CopyToDoc
987: * -----------------------
988: *
989: * Copy a ContainerLine to another Document (usually ClipboardDoc)
990: */
991: BOOL ContainerLine_CopyToDoc(
992: LPCONTAINERLINE lpSrcLine,
993: LPOUTLINEDOC lpDestDoc,
994: int nIndex
995: )
996: {
997: LPCONTAINERLINE lpDestLine = NULL;
998: LPLINELIST lpDestLL = &lpDestDoc->m_LineList;
999: HDC hDC;
1000: HRESULT hrErr;
1001: BOOL fStatus;
1002: LPSTORAGE lpDestDocStg = ((LPCONTAINERDOC)lpDestDoc)->m_lpStg;
1003: LPSTORAGE lpDestObjStg = NULL;
1004:
1005: lpDestLine = (LPCONTAINERLINE) New((DWORD)sizeof(CONTAINERLINE));
1006: if (lpDestLine == NULL) {
1007: OleDbgAssertSz(
1008: lpDestLine!=NULL, "Error allocating ContainerLine");
1009: return FALSE;
1010: }
1011:
1012: hDC = LineList_GetDC(lpDestLL);
1013: ContainerLine_Init(lpDestLine, ((LPLINE)lpSrcLine)->m_nTabLevel, hDC);
1014: LineList_ReleaseDC(lpDestLL, hDC);
1015:
1016: /* OLE2NOTE: In order to have a stable ContainerLine object we must
1017: ** AddRef the object's refcnt. this will be later released when
1018: ** the ContainerLine is deleted.
1019: */
1020: ContainerLine_AddRef(lpDestLine);
1021:
1022: lpDestLine->m_lpDoc = (LPCONTAINERDOC)lpDestDoc;
1023:
1024: // Copy data of the original source ContainerLine.
1025: ((LPLINE)lpDestLine)->m_nWidthInHimetric =
1026: ((LPLINE)lpSrcLine)->m_nWidthInHimetric;
1027: ((LPLINE)lpDestLine)->m_nHeightInHimetric =
1028: ((LPLINE)lpSrcLine)->m_nHeightInHimetric;
1029: lpDestLine->m_fMonikerAssigned = lpSrcLine->m_fMonikerAssigned;
1030: lpDestLine->m_dwDrawAspect = lpSrcLine->m_dwDrawAspect;
1031: lpDestLine->m_sizeInHimetric = lpSrcLine->m_sizeInHimetric;
1032: lpDestLine->m_fIsLink = lpSrcLine->m_fIsLink;
1033:
1034:
1035: /* We must create a new sub-storage for the embedded object within
1036: ** the destination document's storage. We will first attempt to
1037: ** use the same storage name as the source line. if this name is
1038: ** in use, then we will allocate a new name. in this way we try
1039: ** to keep the name associated with the OLE object unchanged
1040: ** through a Cut/Paste operation.
1041: */
1042: lpDestObjStg = OleStdCreateChildStorage(
1043: lpDestDocStg,
1044: lpSrcLine->m_szStgName
1045: );
1046: if (lpDestObjStg) {
1047: lstrcpy(lpDestLine->m_szStgName, lpSrcLine->m_szStgName);
1048: } else {
1049: /* the original name was in use, make up a new name. */
1050: ContainerDoc_GetNextStgName(
1051: (LPCONTAINERDOC)lpDestDoc,
1052: lpDestLine->m_szStgName,
1053: sizeof(lpDestLine->m_szStgName)
1054: );
1055: lpDestObjStg = OleStdCreateChildStorage(
1056: lpDestDocStg,
1057: lpDestLine->m_szStgName
1058: );
1059: }
1060: if (! OleDbgVerifySz(lpDestObjStg != NULL, "Error creating child stg"))
1061: goto error;
1062:
1063: // Copy over storage of the embedded object itself
1064:
1065: if (! lpSrcLine->m_lpOleObj) {
1066:
1067: /*****************************************************************
1068: ** CASE 1: object is NOT loaded.
1069: ** because the object is not loaded, we can simply copy the
1070: ** object's current storage to the new storage.
1071: *****************************************************************/
1072:
1073: /* if current object storage is not already open, then open it */
1074: if (! lpSrcLine->m_lpStg) {
1075: LPSTORAGE lpSrcDocStg = lpSrcLine->m_lpDoc->m_lpStg;
1076:
1077: if (! lpSrcDocStg) goto error;
1078:
1079: // open object storage.
1080: lpSrcLine->m_lpStg = OleStdOpenChildStorage(
1081: lpSrcDocStg,
1082: lpSrcLine->m_szStgName,
1083: STGM_READWRITE
1084: );
1085: if (! OleDbgVerifySz(lpSrcLine->m_lpStg != NULL,
1086: "Error opening child stg"))
1087: goto error;
1088: }
1089:
1090: hrErr = lpSrcLine->m_lpStg->lpVtbl->CopyTo(
1091: lpSrcLine->m_lpStg,
1092: 0,
1093: NULL,
1094: NULL,
1095: lpDestObjStg
1096: );
1097: if (hrErr != NOERROR) {
1098: OleDbgOutHResult("WARNING: lpSrcObjStg->CopyTo returned", hrErr);
1099: goto error;
1100: }
1101:
1102: fStatus = OleStdCommitStorage(lpDestObjStg);
1103:
1104: } else {
1105:
1106: /*****************************************************************
1107: ** CASE 2: object IS loaded.
1108: ** we must tell the object to save into the new storage.
1109: *****************************************************************/
1110:
1111: hrErr = ContainerLine_SaveOleObject(
1112: lpSrcLine,
1113: lpDestObjStg,
1114: FALSE, /* fSameAsLoad */
1115: FALSE, /* fRemember */
1116: TRUE /* fForceUpdate */
1117: );
1118:
1119: if (hrErr != NOERROR)
1120: goto error;
1121: }
1122:
1123: OutlineDoc_AddLine(lpDestDoc, (LPLINE)lpDestLine, nIndex);
1124: OleStdVerifyRelease(
1125: (LPUNKNOWN)lpDestObjStg,
1126: "Copied object stg not released"
1127: );
1128:
1129: return TRUE;
1130:
1131: error:
1132:
1133: // Delete any partially created storage.
1134: if (lpDestObjStg) {
1135: OleStdVerifyRelease(
1136: (LPUNKNOWN)lpDestObjStg,
1137: "Copied object stg not released"
1138: );
1139:
1140: lpDestDocStg->lpVtbl->DestroyElement(
1141: lpDestDocStg,
1142: lpDestLine->m_szStgName
1143: );
1144: lpDestLine->m_szStgName[0] = '\0';
1145: }
1146:
1147: // destroy partially created ContainerLine
1148: if (lpDestLine)
1149: ContainerLine_Delete(lpDestLine);
1150: return FALSE;
1151: }
1152:
1153:
1154: /* ContainerLine_UpdateExtent
1155: ** --------------------------
1156: ** Update the size of the ContainerLine because the extents of the
1157: ** object may have changed.
1158: **
1159: ** NOTE: because we are using a Windows OwnerDraw ListBox, we must
1160: ** constrain the maximum possible height of a line. the ListBox has
1161: ** a limitation (unfortunately) that no line can become larger than
1162: ** 255 pixels. thus we force the object to scale maintaining its
1163: ** aspect ratio if this maximum line height limit is reached. the
1164: ** actual maximum size for an object at 100% Zoom is
1165: ** 255-2*LINE_BOUNDARY_WIDTH.
1166: **
1167: ** RETURNS TRUE -- if the extents of the object changed
1168: ** FALSE -- if the extents did NOT change
1169: */
1170: BOOL ContainerLine_UpdateExtent(
1171: LPCONTAINERLINE lpContainerLine,
1172: LPSIZEL lpsizelHim
1173: )
1174: {
1175: LPOUTLINEDOC lpOutlineDoc = (LPOUTLINEDOC)lpContainerLine->m_lpDoc;
1176: LPLINELIST lpLL = OutlineDoc_GetLineList(lpOutlineDoc);
1177: LPLINE lpLine = (LPLINE)lpContainerLine;
1178: int nIndex = LineList_GetLineIndex(lpLL, lpLine);
1179: UINT nOrgWidthInHimetric = lpLine->m_nWidthInHimetric;
1180: UINT nOrgHeightInHimetric = lpLine->m_nHeightInHimetric;
1181: BOOL fWidthChanged = FALSE;
1182: BOOL fHeightChanged = FALSE;
1183: SIZEL sizelHim;
1184: HRESULT hrErr;
1185:
1186: if (!lpContainerLine || !lpContainerLine->m_lpOleObj)
1187: return FALSE;
1188:
1189: OLEDBG_BEGIN3("ContainerLine_UpdateExtent\r\n");
1190:
1191: lpContainerLine->m_fDoGetExtent = FALSE;
1192:
1193: if (! lpsizelHim) {
1194: OLEDBG_BEGIN2("IOleObject::GetExtent called\r\n")
1195: hrErr = lpContainerLine->m_lpOleObj->lpVtbl->GetExtent(
1196: lpContainerLine->m_lpOleObj,
1197: lpContainerLine->m_dwDrawAspect,
1198: (LPSIZEL)&sizelHim
1199: );
1200: OLEDBG_END2
1201: if (hrErr != NOERROR)
1202: sizelHim.cx = sizelHim.cy = 0;
1203:
1204: lpsizelHim = (LPSIZEL)&sizelHim;
1205: }
1206:
1207: if (lpsizelHim->cx == lpContainerLine->m_sizeInHimetric.cx &&
1208: lpsizelHim->cy == lpContainerLine->m_sizeInHimetric.cy) {
1209: goto noupdate;
1210: }
1211:
1212: if (lpsizelHim->cx > 0 || lpsizelHim->cy > 0) {
1213: lpContainerLine->m_sizeInHimetric = *lpsizelHim;
1214: } else {
1215: /* object does not have any extents; let's use our container
1216: ** chosen arbitrary size for OLE objects.
1217: */
1218: lpContainerLine->m_sizeInHimetric.cx = (long)DEFOBJWIDTH;
1219: lpContainerLine->m_sizeInHimetric.cy = (long)DEFOBJHEIGHT;
1220: }
1221:
1222: ContainerLine_CalcExtents(
1223: lpContainerLine,
1224: (LPSIZEL)&lpContainerLine->m_sizeInHimetric);
1225:
1226: // if height of object changed, then reset the height of line in LineList
1227: if (nOrgHeightInHimetric != lpLine->m_nHeightInHimetric) {
1228: LineList_SetLineHeight(lpLL, nIndex, lpLine->m_nHeightInHimetric);
1229: fHeightChanged = TRUE;
1230: }
1231:
1232: fWidthChanged = LineList_RecalcMaxLineWidthInHimetric(
1233: lpLL,
1234: nOrgWidthInHimetric
1235: );
1236: fWidthChanged |= (nOrgWidthInHimetric != lpLine->m_nWidthInHimetric);
1237:
1238: if (fHeightChanged || fWidthChanged) {
1239: OutlineDoc_ForceRedraw(lpOutlineDoc, TRUE);
1240:
1241: // mark ContainerDoc as now dirty
1242: OutlineDoc_SetModified(lpOutlineDoc, TRUE, TRUE, TRUE);
1243: }
1244:
1245: OLEDBG_END3
1246: return TRUE;
1247:
1248: noupdate:
1249: OLEDBG_END3
1250: return FALSE; // No UPDATE necessary
1251: }
1252:
1253:
1254: /* ContainerLine_DoVerb
1255: ** --------------------
1256: ** Activate the OLE object and perform a specific verb.
1257: */
1258: BOOL ContainerLine_DoVerb(LPCONTAINERLINE lpContainerLine, LONG iVerb, BOOL fMessage, BOOL fAction)
1259: {
1260: HRESULT hrErr;
1261: LPOUTLINEDOC lpOutlineDoc = (LPOUTLINEDOC)lpContainerLine->m_lpDoc;
1262: RECT rcPosRect;
1263:
1264: OLEDBG_BEGIN3("ContainerLine_DoVerb\r\n")
1265: /* if object is not already loaded, then load it now. objects are
1266: ** loaded lazily in this manner.
1267: */
1268: if (! lpContainerLine->m_lpOleObj)
1269: ContainerLine_LoadOleObject(lpContainerLine);
1270:
1271: if (! lpContainerLine->m_lpOleObj) {
1272: OleDbgAssertSz(lpContainerLine->m_lpOleObj != NULL,
1273: "OLE object not loaded");
1274: goto error;
1275: }
1276:
1277: #if defined( INPLACE_CNTR )
1278: /* OLE2NOTE: we want to keep only 1 inplace server active at any
1279: ** given time. so when we start to do a DoVerb on another line,
1280: ** then we want to shut down the previously activated server. in
1281: ** this way we keep at most one inplace server active at a time.
1282: */
1283: if (!g_fInsideOutContainer) {
1284: ContainerDoc_ShutDownLastInPlaceServerIfNotNeeded(
1285: lpContainerLine->m_lpDoc, lpContainerLine);
1286: }
1287: #endif // INPLACE_CNTR
1288:
1289: ContainerLine_GetOleObjectRectInPixels(
1290: lpContainerLine,
1291: (LPRECT)&rcPosRect
1292: );
1293:
1294: // run the object
1295: hrErr = ContainerLine_RunOleObject(lpContainerLine);
1296: if (hrErr != NOERROR)
1297: goto error;
1298:
1299: /* Tell object server to perform a "verb". */
1300: OLEDBG_BEGIN2("IOleObject::DoVerb called\r\n")
1301: hrErr = lpContainerLine->m_lpOleObj->lpVtbl->DoVerb (
1302: lpContainerLine->m_lpOleObj,
1303: iVerb,
1304: NULL,
1305: (LPOLECLIENTSITE)&lpContainerLine->m_OleClientSite,
1306: -1,
1307: OutlineDoc_GetWindow(lpOutlineDoc),
1308: (LPCRECT)&rcPosRect
1309: );
1310: OLEDBG_END2
1311:
1312: /* OLE2NOTE: IOleObject::DoVerb may return a success code
1313: ** OLE_S_INVALIDVERB. this SCODE should NOT be considered an
1314: ** error; thus it is important to use the "FAILED" macro to
1315: ** check for an error SCODE.
1316: */
1317: if (FAILED(GetScode(hrErr))) {
1318: OleDbgOutHResult("WARNING: lpOleObj->DoVerb returned", hrErr);
1319: goto error;
1320: }
1321:
1322: OLEDBG_END3
1323: return TRUE;
1324:
1325: error:
1326: if (lpContainerLine->m_fIsLink)
1327: lpContainerLine->m_fLinkUnavailable = TRUE;
1328:
1329: /* OLE2NOTE: if an error occurs we must give the appropriate error
1330: ** message box. there are many potential errors that can occur.
1331: ** the OLE2.0 user model has specific guidelines as to the
1332: ** dialogs that should be displayed given the various potential
1333: ** errors (eg. server not registered, unavailable link source.
1334: ** the OLE2UI library includes support for most of the
1335: ** recommended message dialogs. (see OleUIPrompUser function)
1336: */
1337: if (fMessage) {
1338: ProcessError(hrErr, lpContainerLine, fAction);
1339: }
1340:
1341: OLEDBG_END3
1342: return FALSE;
1343: }
1344:
1345:
1346: /* ContainerLine_GetOleObject
1347: ** --------------------------
1348: ** return pointer to desired interface of embedded/linked object.
1349: **
1350: ** NOTE: this function causes an AddRef to the object. when the caller is
1351: ** finished with the object, it must call Release.
1352: ** this function does not AddRef the ContainerLine object.
1353: */
1354: LPUNKNOWN ContainerLine_GetOleObject(
1355: LPCONTAINERLINE lpContainerLine,
1356: REFIID riid
1357: )
1358: {
1359: /* if object is not already loaded, then load it now. objects are
1360: ** loaded lazily in this manner.
1361: */
1362: if (! lpContainerLine->m_lpOleObj)
1363: ContainerLine_LoadOleObject(lpContainerLine);
1364:
1365: if (lpContainerLine->m_lpOleObj)
1366: return OleStdQueryInterface(
1367: (LPUNKNOWN)lpContainerLine->m_lpOleObj,
1368: riid
1369: );
1370: else
1371: return NULL;
1372: }
1373:
1374:
1375:
1376: /* ContainerLine_RunOleObject
1377: ** --------------------------
1378: ** Load and run the object. Upon running and if size of object has changed,
1379: ** use SetExtent to change to new size.
1380: **
1381: */
1382: HRESULT ContainerLine_RunOleObject(LPCONTAINERLINE lpContainerLine)
1383: {
1384: LPUNKNOWN lpUnk;
1385: LPLINE lpLine = (LPLINE)lpContainerLine;
1386: SIZEL sizelNew;
1387: HRESULT hrErr;
1388: HCURSOR hPrevCursor;
1389:
1390: if (! lpContainerLine)
1391: return NOERROR;
1392:
1393: if (lpContainerLine->m_lpOleObj &&
1394: OleIsRunning(lpContainerLine->m_lpOleObj))
1395: return NOERROR; // object already running
1396:
1397: // this may take a while, put up hourglass cursor
1398: hPrevCursor = SetCursor(LoadCursor(NULL, IDC_WAIT));
1399:
1400: OLEDBG_BEGIN3("ContainerLine_RunOleObject\r\n")
1401:
1402: lpUnk = ContainerLine_GetOleObject(lpContainerLine, &IID_IUnknown);
1403:
1404: OLEDBG_BEGIN2("OleRun called\r\n")
1405: hrErr = OleRun(lpUnk); // FORCE object to RUN
1406: OLEDBG_END2
1407:
1408: OleStdRelease(lpUnk);
1409:
1410: SetCursor(hPrevCursor); // restore original cursor
1411:
1412: if (hrErr != NOERROR) {
1413: OleDbgOutHResult("OleRun returned", hrErr);
1414: OLEDBG_END3
1415: return hrErr;
1416: }
1417:
1418: sizelNew.cx = lpLine->m_nWidthInHimetric - XformWidthInPixelsToHimetric(
1419: NULL, LINE_BOUNDARY_WIDTH * 2);
1420: sizelNew.cy = lpLine->m_nHeightInHimetric - XformHeightInPixelsToHimetric(
1421: NULL, LINE_BOUNDARY_WIDTH * 2);
1422:
1423: if ((sizelNew.cx != lpContainerLine->m_sizeInHimetric.cx) ||
1424: (sizelNew.cy != lpContainerLine->m_sizeInHimetric.cy)) {
1425:
1426: OLEDBG_BEGIN2("IOleObject::SetExtent called\r\n")
1427:
1428: lpContainerLine->m_lpOleObj->lpVtbl->SetExtent(
1429: lpContainerLine->m_lpOleObj,
1430: lpContainerLine->m_dwDrawAspect,
1431: (LPSIZEL)&sizelNew);
1432:
1433: OLEDBG_END2
1434:
1435: }
1436:
1437: OLEDBG_END3
1438: return NOERROR;
1439:
1440: }
1441:
1442:
1443: /* ContainerLine_IsOleLink
1444: ** -----------------------
1445: **
1446: ** return TRUE if the ContainerLine has an OleLink.
1447: ** FALSE if the ContainerLine has an embedding
1448: */
1449: BOOL ContainerLine_IsOleLink(LPCONTAINERLINE lpContainerLine)
1450: {
1451: if (!lpContainerLine)
1452: return FALSE;
1453:
1454: return lpContainerLine->m_fIsLink;
1455: }
1456:
1457:
1458: /* ContainerLine_Draw
1459: ** ------------------
1460: **
1461: ** Draw a ContainerLine object on a DC.
1462: **
1463: ** Parameters:
1464: ** hDC - DC to which the line will be drawn
1465: ** lpRect - the object rect in logical coordinates
1466: */
1467: void ContainerLine_Draw(
1468: LPCONTAINERLINE lpContainerLine,
1469: HDC hDC,
1470: LPRECT lpRect
1471: )
1472: {
1473: LPLINE lpLine = (LPLINE) lpContainerLine;
1474: HRESULT hrErr = NOERROR;
1475: RECTL rclHim;
1476: RECT rcHim;
1477:
1478: /* if object is not already loaded, then load it now. objects are
1479: ** loaded lazily in this manner.
1480: */
1481: if (! lpContainerLine->m_lpOleObj)
1482: ContainerLine_LoadOleObject(lpContainerLine);
1483:
1484: if (! lpContainerLine->m_lpViewObj) {
1485: lpContainerLine->m_lpViewObj = (LPVIEWOBJECT)OleStdQueryInterface(
1486: (LPUNKNOWN)lpContainerLine->m_lpOleObj, &IID_IViewObject);
1487: if (! lpContainerLine->m_lpViewObj) {
1488: OleDbgAssert(lpContainerLine->m_lpViewObj);
1489: return; // Error: no IViewObject* available
1490: }
1491: }
1492:
1493: /* construct bounds rectangle for the object.
1494: ** offset origin for object to correct tab indentation
1495: */
1496: rclHim.left = (long) lpRect->left;
1497: rclHim.bottom = (long) lpRect->bottom;
1498: rclHim.top = (long) lpRect->top;
1499: rclHim.right = (long) lpRect->right;
1500:
1501: rclHim.left += (long) ((LPLINE)lpContainerLine)->m_nTabWidthInHimetric;
1502: rclHim.right += (long) ((LPLINE)lpContainerLine)->m_nTabWidthInHimetric;
1503:
1504: #if defined( INPLACE_CNTR )
1505: /* OLE2NOTE: if the OLE object is currently does has a visible in-place
1506: ** window, then we do NOT want to draw on top of its window.
1507: ** this could interfere with the object's display.
1508: */
1509: if ( !lpContainerLine->m_fIpVisible )
1510: #endif
1511: {
1512: hrErr = lpContainerLine->m_lpViewObj->lpVtbl->Draw(
1513: lpContainerLine->m_lpViewObj,
1514: lpContainerLine->m_dwDrawAspect,
1515: -1,
1516: NULL,
1517: NULL,
1518: NULL,
1519: hDC,
1520: (LPRECTL)&rclHim,
1521: (LPRECTL)&rclHim,
1522: NULL,
1523: 0
1524: );
1525: if (hrErr != NOERROR)
1526: OleDbgOutHResult("IViewObject::Draw returned", hrErr);
1527:
1528: if (lpContainerLine->m_fObjWinOpen) {
1529:
1530: rcHim.left = (int) rclHim.left;
1531: rcHim.top = (int) rclHim.top;
1532: rcHim.right = (int) rclHim.right;
1533: rcHim.bottom = (int) rclHim.bottom;
1534:
1535: /* OLE2NOTE: if the object servers window is Open (ie. not active
1536: ** in-place) then we must shade the object in our document to
1537: ** indicate to the user that the object is open elsewhere.
1538: */
1539: OleUIDrawShading((LPRECT)&rcHim, hDC, OLEUI_SHADE_FULLRECT, 0);
1540: }
1541: }
1542: return;
1543: }
1544:
1545:
1546: void ContainerLine_DrawSelHilight(
1547: LPCONTAINERLINE lpContainerLine,
1548: HDC hDC, // MM_TEXT mode
1549: LPRECT lprcPix, // listbox rect
1550: UINT itemAction,
1551: UINT itemState
1552: )
1553: {
1554: LPLINE lpLine = (LPLINE)lpContainerLine;
1555: RECT rcObj;
1556: DWORD dwFlags = OLEUI_HANDLES_INSIDE | OLEUI_HANDLES_USEINVERSE;
1557: int nHandleSize;
1558: LPCONTAINERDOC lpContainerDoc;
1559:
1560: if (!lpContainerLine || !hDC || !lprcPix)
1561: return;
1562:
1563: lpContainerDoc = lpContainerLine->m_lpDoc;
1564:
1565: // Get size of OLE object
1566: ContainerLine_GetOleObjectRectInPixels(lpContainerLine, (LPRECT)&rcObj);
1567:
1568: InflateRect(&rcObj, 1, 1); // get feedback rect
1569: nHandleSize = GetProfileInt("windows", "oleinplaceborderwidth",
1570: DEFAULT_HATCHBORDER_WIDTH) + 1;
1571:
1572: if (itemAction & ODA_SELECT) {
1573: // check if there is a selection state change
1574: if (itemState & ODS_SELECTED) {
1575: if (!lpLine->m_fSelected) {
1576: lpLine->m_fSelected = TRUE;
1577: OleUIDrawHandles((LPRECT)&rcObj, hDC, dwFlags, nHandleSize,
1578: TRUE);
1579: InvertDiffRect(lprcPix, (LPRECT)&rcObj, hDC);
1580: }
1581: } else {
1582: if (lpLine->m_fSelected) {
1583: lpLine->m_fSelected = FALSE;
1584: OleUIDrawHandles((LPRECT)&rcObj, hDC, dwFlags, nHandleSize,
1585: FALSE);
1586: InvertDiffRect(lprcPix, (LPRECT)&rcObj, hDC);
1587: }
1588: }
1589: } else if (itemAction & ODA_DRAWENTIRE) {
1590: lpLine->m_fSelected=((itemState & ODS_SELECTED) ? TRUE : FALSE);
1591: if (lpLine->m_fSelected) {
1592: OleUIDrawHandles((LPRECT)&rcObj, hDC, dwFlags, nHandleSize, TRUE);
1593: InvertDiffRect(lprcPix, (LPRECT)&rcObj, hDC);
1594: } else {
1595: OleUIDrawHandles((LPRECT)&rcObj, hDC, dwFlags, nHandleSize,
1596: FALSE);
1597: InvertDiffRect(lprcPix, (LPRECT)&rcObj, hDC);
1598: }
1599:
1600: }
1601: }
1602:
1603: /* InvertDiffRect
1604: ** --------------
1605: **
1606: ** Paint the surrounding of the Obj rect black but within lprcPix
1607: ** (similar to the lprcPix minus lprcObj)
1608: */
1609: static void InvertDiffRect(LPRECT lprcPix, LPRECT lprcObj, HDC hDC)
1610: {
1611: RECT rcBlack;
1612:
1613: // draw black in all space outside of object's rectangle
1614: rcBlack.top = lprcPix->top;
1615: rcBlack.bottom = lprcPix->bottom;
1616:
1617: rcBlack.left = lprcPix->left + 1;
1618: rcBlack.right = lprcObj->left - 1;
1619: InvertRect(hDC, (LPRECT)&rcBlack);
1620:
1621: rcBlack.left = lprcObj->right + 1;
1622: rcBlack.right = lprcPix->right - 1;
1623: InvertRect(hDC, (LPRECT)&rcBlack);
1624:
1625: rcBlack.top = lprcPix->top;
1626: rcBlack.bottom = lprcPix->top + 1;
1627: rcBlack.left = lprcObj->left - 1;
1628: rcBlack.right = lprcObj->right + 1;
1629: InvertRect(hDC, (LPRECT)&rcBlack);
1630:
1631: rcBlack.top = lprcPix->bottom;
1632: rcBlack.bottom = lprcPix->bottom - 1;
1633: rcBlack.left = lprcObj->left - 1;
1634: rcBlack.right = lprcObj->right + 1;
1635: InvertRect(hDC, (LPRECT)&rcBlack);
1636: }
1637:
1638:
1639: /* Edit the ContainerLine line object.
1640: ** returns TRUE if line was changed
1641: ** FALSE if the line was NOT changed
1642: */
1643: BOOL ContainerLine_Edit(LPCONTAINERLINE lpContainerLine, HWND hWndDoc,HDC hDC)
1644: {
1645: ContainerLine_DoVerb(lpContainerLine, OLEIVERB_PRIMARY, TRUE, TRUE);
1646:
1647: /* assume object was NOT changed, if it was obj will send Changed
1648: ** or Saved notification.
1649: */
1650: return FALSE;
1651: }
1652:
1653:
1654:
1655: /* ContainerLine_SetHeightInHimetric
1656: ** ---------------------------------
1657: **
1658: ** Set the height of a ContainerLine object. The widht will be changed
1659: ** to keep the aspect ratio
1660: */
1661: void ContainerLine_SetHeightInHimetric(LPCONTAINERLINE lpContainerLine, int nHeight)
1662: {
1663: LPLINE lpLine = (LPLINE)lpContainerLine;
1664: SIZEL sizelOleObject;
1665: HRESULT hrErr;
1666:
1667: if (!lpContainerLine)
1668: return;
1669:
1670: if (nHeight != -1) {
1671:
1672: /* if object is not already loaded, then load it now. objects are
1673: ** loaded lazily in this manner.
1674: */
1675: if (! lpContainerLine->m_lpOleObj)
1676: ContainerLine_LoadOleObject(lpContainerLine);
1677:
1678: sizelOleObject.cy = nHeight - XformHeightInPixelsToHimetric(NULL,
1679: LINE_BOUNDARY_WIDTH * 2);
1680:
1681: sizelOleObject.cx = (int)(sizelOleObject.cy *
1682: lpContainerLine->m_sizeInHimetric.cx /
1683: lpContainerLine->m_sizeInHimetric.cy);
1684:
1685: hrErr = lpContainerLine->m_lpOleObj->lpVtbl->SetExtent(
1686: lpContainerLine->m_lpOleObj,
1687: lpContainerLine->m_dwDrawAspect,
1688: (LPSIZEL)&sizelOleObject);
1689:
1690: OleDbgOutHResult("IOleObj::SetExtent returned",hrErr);
1691:
1692: if (hrErr == NOERROR) {
1693: /*****************************************************************
1694: ** OLE Object accepts size changes, update the extents in the **
1695: ** ContainerLine and Line **
1696: *****************************************************************/
1697: ContainerLine_UpdateExtent(lpContainerLine,
1698: (LPSIZEL)&sizelOleObject);
1699: }
1700: else {
1701: /*****************************************************************
1702: ** OLE Object refuses size changes, change extents of Line only **
1703: *****************************************************************/
1704: ContainerLine_CalcExtents(lpContainerLine,
1705: (LPSIZEL)&sizelOleObject);
1706: }
1707: }
1708: else {
1709: /*****************************************************************
1710: ** Use default OLE Object size **
1711: *****************************************************************/
1712: ContainerLine_CalcExtents(
1713: lpContainerLine,
1714: (LPSIZEL)&lpContainerLine->m_sizeInHimetric);
1715: }
1716:
1717: }
1718:
1719:
1720: /* ContainerLine_CalcExtents
1721: *
1722: * Purpose:
1723: * Calculate the corresponding line height from the OleObject size
1724: * Scale the line height to fit the limit if necessary
1725: *
1726: * Parameters:
1727: * lpsizelOleObject pointer to size of OLE Object
1728: *
1729: * Returns:
1730: * nil
1731: */
1732: void ContainerLine_CalcExtents(LPCONTAINERLINE lpContainerLine, LPSIZEL lpsizelOleObject)
1733: {
1734: LPLINE lpLine = (LPLINE)lpContainerLine;
1735:
1736: UINT uMaxObjectHeight = XformHeightInPixelsToHimetric(NULL,
1737: LISTBOX_HEIGHT_LIMIT - 2 * LINE_BOUNDARY_WIDTH);
1738:
1739: if (!lpContainerLine || !lpsizelOleObject)
1740: return;
1741:
1742: lpLine->m_nWidthInHimetric = (int)lpsizelOleObject->cx;
1743: lpLine->m_nHeightInHimetric = (int)lpsizelOleObject->cy;
1744:
1745: // Rescale the object if height is greater than the limit
1746: if (lpLine->m_nHeightInHimetric > (UINT)uMaxObjectHeight) {
1747:
1748: lpLine->m_nWidthInHimetric = (UINT)
1749: ((long)lpLine->m_nWidthInHimetric *
1750: (long)uMaxObjectHeight /
1751: (long)lpLine->m_nHeightInHimetric);
1752:
1753: lpLine->m_nHeightInHimetric = uMaxObjectHeight;
1754: }
1755:
1756: // Add boundary space
1757: lpLine->m_nWidthInHimetric +=
1758: XformWidthInPixelsToHimetric(NULL, LINE_BOUNDARY_WIDTH) * 2;
1759: lpLine->m_nHeightInHimetric +=
1760: XformHeightInPixelsToHimetric(NULL, LINE_BOUNDARY_WIDTH) * 2;
1761: }
1762:
1763:
1764: /* ContainerLine_SaveToStg
1765: ** -----------------------
1766: ** Save a given ContainerLine and associated OLE object to an IStorage*.
1767: */
1768: BOOL ContainerLine_SaveToStg(
1769: LPCONTAINERLINE lpContainerLine,
1770: UINT uFormat,
1771: LPSTORAGE lpSrcStg,
1772: LPSTORAGE lpDestStg,
1773: LPSTREAM lpLLStm,
1774: BOOL fRemember
1775: )
1776: {
1777: LPCONTAINERAPP lpContainerApp = (LPCONTAINERAPP)g_lpApp;
1778: HRESULT hrErr;
1779: BOOL fStatus;
1780: ULONG nWritten;
1781: BOOL fSameAsLoad = (lpSrcStg==lpDestStg ? TRUE : FALSE);
1782: CONTAINERLINERECORD objLineRecord;
1783: LPSTORAGE lpObjDestStg;
1784: LARGE_INTEGER dlibSavePos;
1785: LARGE_INTEGER dlibZeroOffset;
1786: LISet32( dlibZeroOffset, 0 );
1787:
1788: // only save the ContainerLine (with OLE object) if format is compatible.
1789: if (uFormat != lpContainerApp->m_cfCntrOutl)
1790: return FALSE;
1791:
1792: /* save seek position before line record is written in case of error */
1793: hrErr = lpLLStm->lpVtbl->Seek(
1794: lpLLStm,
1795: dlibZeroOffset,
1796: STREAM_SEEK_CUR,
1797: (ULARGE_INTEGER FAR*)&dlibSavePos
1798: );
1799: if (hrErr != NOERROR) goto error;
1800:
1801: lstrcpy(objLineRecord.m_szStgName, lpContainerLine->m_szStgName);
1802: objLineRecord.m_fMonikerAssigned = lpContainerLine->m_fMonikerAssigned;
1803: objLineRecord.m_dwDrawAspect = lpContainerLine->m_dwDrawAspect;
1804: objLineRecord.m_sizeInHimetric = lpContainerLine->m_sizeInHimetric;
1805: objLineRecord.m_fIsLink = lpContainerLine->m_fIsLink;
1806:
1807: /* write line record */
1808: hrErr = lpLLStm->lpVtbl->Write(
1809: lpLLStm,
1810: (LPVOID)&objLineRecord,
1811: sizeof(CONTAINERLINERECORD),
1812: &nWritten
1813: );
1814:
1815: if (! OleDbgVerifySz(hrErr == NOERROR,
1816: "Could not write to LineList stream"))
1817: goto error;
1818:
1819: if (! lpContainerLine->m_lpOleObj) {
1820:
1821: /*****************************************************************
1822: ** CASE 1: object is NOT loaded.
1823: *****************************************************************/
1824:
1825: if (fSameAsLoad) {
1826: /*************************************************************
1827: ** CASE 1A: we are saving to the current storage. because
1828: ** the object is not loaded, it is up-to-date
1829: ** (ie. nothing to do).
1830: *************************************************************/
1831:
1832: ;
1833:
1834: } else {
1835: /*************************************************************
1836: ** CASE 1B: we are saving to a new storage. because
1837: ** the object is not loaded, we can simply copy the
1838: ** object's current storage to the new storage.
1839: *************************************************************/
1840:
1841: /* if current object storage is not already open, then open it */
1842: if (! lpContainerLine->m_lpStg) {
1843: lpContainerLine->m_lpStg = OleStdOpenChildStorage(
1844: lpSrcStg,
1845: lpContainerLine->m_szStgName,
1846: STGM_READWRITE
1847: );
1848: if (! OleDbgVerifySz(lpContainerLine->m_lpStg != NULL,
1849: "Error opening child stg"))
1850: goto error;
1851: }
1852:
1853: /* Create a child storage inside the destination storage. */
1854: lpObjDestStg = OleStdCreateChildStorage(
1855: lpDestStg,
1856: lpContainerLine->m_szStgName
1857: );
1858:
1859: if (! OleDbgVerifySz(lpObjDestStg != NULL,
1860: "Could not create obj storage!"))
1861: goto error;
1862:
1863: hrErr = lpContainerLine->m_lpStg->lpVtbl->CopyTo(
1864: lpContainerLine->m_lpStg,
1865: 0,
1866: NULL,
1867: NULL,
1868: lpObjDestStg
1869: );
1870: // REVIEW: should we handle error here?
1871: fStatus = OleStdCommitStorage(lpObjDestStg);
1872:
1873: /* if we are supposed to remember this storage as the new
1874: ** storage for the object, then release the old one and
1875: ** save the new one. else, throw away the new one.
1876: */
1877: if (fRemember) {
1878: OleStdVerifyRelease(
1879: (LPUNKNOWN)lpContainerLine->m_lpStg,
1880: "Original object stg not released"
1881: );
1882: lpContainerLine->m_lpStg = lpObjDestStg;
1883: } else {
1884: OleStdVerifyRelease(
1885: (LPUNKNOWN)lpObjDestStg,
1886: "Copied object stg not released"
1887: );
1888: }
1889: }
1890:
1891: } else {
1892:
1893: /*****************************************************************
1894: ** CASE 2: object IS loaded.
1895: *****************************************************************/
1896:
1897: if (fSameAsLoad) {
1898: /*************************************************************
1899: ** CASE 2A: we are saving to the current storage. if the object
1900: ** is not dirty, then the current storage is up-to-date
1901: ** (ie. nothing to do).
1902: *************************************************************/
1903:
1904: LPPERSISTSTORAGE lpPersistStg;
1905:
1906: if (! lpContainerLine->m_lpPersistStg) {
1907: lpContainerLine->m_lpPersistStg =
1908: (LPPERSISTSTORAGE)OleStdQueryInterface(
1909: (LPUNKNOWN)lpContainerLine->m_lpOleObj,
1910: &IID_IPersistStorage);
1911: }
1912:
1913: lpPersistStg = lpContainerLine->m_lpPersistStg;
1914: OleDbgAssertSz(
1915: lpPersistStg!=NULL,"IPersistStorage NOT supported");
1916:
1917: if (! lpPersistStg)
1918: goto error;
1919:
1920: hrErr = lpPersistStg->lpVtbl->IsDirty(lpPersistStg);
1921:
1922: if (hrErr != NOERROR) {
1923: return TRUE; /* OLE object is NOT dirty */
1924: } else {
1925: /* OLE object IS dirty */
1926: hrErr = ContainerLine_SaveOleObject(
1927: lpContainerLine,
1928: lpContainerLine->m_lpStg,
1929: fSameAsLoad,
1930: fRemember,
1931: TRUE /* fForceUpdate */
1932: );
1933:
1934: return ((hrErr == NOERROR) ? TRUE : FALSE);
1935: }
1936:
1937: } else {
1938: /*************************************************************
1939: ** CASE 2B: we are saving to a new storage. we must
1940: ** tell the object to save into the new storage.
1941: *************************************************************/
1942:
1943: /* Create a child storage inside the destination storage. */
1944: lpObjDestStg = OleStdCreateChildStorage(
1945: lpDestStg,
1946: lpContainerLine->m_szStgName
1947: );
1948:
1949: if (! OleDbgVerifySz(lpObjDestStg != NULL,
1950: "Could not create object storage!")) {
1951: goto error;
1952: }
1953:
1954: hrErr = ContainerLine_SaveOleObject(
1955: lpContainerLine,
1956: lpObjDestStg,
1957: fSameAsLoad,
1958: fRemember,
1959: TRUE /* fForceUpdate */
1960: );
1961:
1962: if (hrErr != NOERROR)
1963: goto error;
1964:
1965: /* if we are supposed to remember this storage as the new
1966: ** storage for the object, then release the old one and
1967: ** save the new one. else, throw away the new one.
1968: */
1969: if (fRemember) {
1970: OleStdVerifyRelease(
1971: (LPUNKNOWN)lpContainerLine->m_lpStg,
1972: "Original object stg not released"
1973: );
1974: lpContainerLine->m_lpStg = lpObjDestStg;
1975: } else {
1976: OleStdVerifyRelease(
1977: (LPUNKNOWN)lpObjDestStg,
1978: "Copied object stg not released"
1979: );
1980: }
1981: }
1982: return TRUE;
1983: }
1984:
1985: return TRUE;
1986:
1987: error:
1988:
1989: /* retore seek position prior to writing Line record */
1990: lpLLStm->lpVtbl->Seek(
1991: lpLLStm,
1992: dlibSavePos,
1993: STREAM_SEEK_SET,
1994: NULL
1995: );
1996:
1997: return FALSE;
1998: }
1999:
2000:
2001: /* ContainerLine_SaveOleObject
2002: ** ---------------------------
2003: ** Save the OLE object associated with the ContainerLine.
2004: **
2005: ** OLE2NOTE: this function demonstrates the most basic form of
2006: ** saving an OLE object. see the OLE 2.0 documentation for a
2007: ** discussion of other more advanced strategies for saving (eg.
2008: ** saving with backup file and low memory save).
2009: */
2010: HRESULT ContainerLine_SaveOleObject(
2011: LPCONTAINERLINE lpContainerLine,
2012: LPSTORAGE lpStg,
2013: BOOL fSameAsLoad,
2014: BOOL fRemember,
2015: BOOL fForceUpdate
2016: )
2017: {
2018: LPPERSISTSTORAGE lpPersistStg;
2019: SCODE sc = S_OK;
2020: HRESULT hrErr;
2021:
2022: if (! lpContainerLine->m_lpPersistStg) {
2023: lpContainerLine->m_lpPersistStg =
2024: (LPPERSISTSTORAGE)OleStdQueryInterface(
2025: (LPUNKNOWN)lpContainerLine->m_lpOleObj, &IID_IPersistStorage);
2026: if (! lpContainerLine->m_lpPersistStg) {
2027: OleDbgAssert(lpContainerLine->m_lpPersistStg);
2028: return ResultFromScode(E_FAIL);
2029: }
2030: }
2031:
2032: lpPersistStg = lpContainerLine->m_lpPersistStg;
2033:
2034: /* OLE2NOTE: the container should NOT call IOleObject::Update
2035: ** before calling OleSave on an embedded object. an earlier
2036: ** version of the Outline sample incorrectly called
2037: ** IOleObject::Update here in order to guarantee that we get the
2038: ** latest presentation of the object when it has a coarse update
2039: ** granularity (eg. OLE 1.0 embeddings). it is the
2040: ** responsibility of the Object application to send an
2041: ** OnDataChange when IPersistStorage::Save is called if there
2042: ** currently are un-broadcast change notifications BEFORE
2043: ** returning from IPersistStorage::Save. these data change
2044: ** notifications will get through and cause the cache to be
2045: ** updated prior to the saving of the cache. (this discussion is
2046: ** only pertinent to EXE based servers that use OLE's
2047: ** DefHandler. calling IOleObject::Update would have the
2048: ** undesireable side-effect of causing any nested manual links
2049: ** to be updated automatically.
2050: */
2051:
2052: OLEDBG_BEGIN2("OleSave called\r\n")
2053: hrErr = OleSave(lpPersistStg, lpStg, fSameAsLoad);
2054: OLEDBG_END2
2055:
2056: // OLE2NOTE: if OleSave returns an error, you must still call
2057: // SaveCompleted.
2058: if (hrErr != NOERROR) {
2059: OleDbgOutHResult("WARNING: OleSave returned", hrErr);
2060: sc = GetScode(hrErr);
2061: }
2062:
2063: /* OLE2NOTE: a root level container should immediately
2064: ** call IPersistStorage::SaveCompleted after calling OleSave. a
2065: ** nested level container should not call SaveCompleted now, but
2066: ** must wait until SaveCompleted is call on it by its container.
2067: ** since our container is not a container/server, then we always
2068: ** call SaveComplete here.
2069: **
2070: ** if this is a SaveAs operation, then we need to pass the lpStg
2071: ** back in SaveCompleted to inform the object of its new storage
2072: ** that it may hold on to.
2073: ** if this is a Save or a SaveCopyAs operation, then we simply
2074: ** pass NULL in SaveCompleted; the object can continue to hold
2075: ** its current storage. if an error occurs during the OleSave
2076: ** call we must still call SaveCompleted but we must pass NULL.
2077: */
2078: OLEDBG_BEGIN2("IPersistStorage::SaveCompleted called\r\n")
2079: hrErr = lpPersistStg->lpVtbl->SaveCompleted(
2080: lpPersistStg,
2081: ((FAILED(sc) || !fRemember || fSameAsLoad) ? NULL : lpStg)
2082: );
2083: OLEDBG_END2
2084:
2085: if (hrErr != NOERROR) {
2086: OleDbgOutHResult("WARNING: SaveCompleted returned",hrErr);
2087: if (sc == S_OK)
2088: sc = GetScode(hrErr);
2089: }
2090:
2091: return ResultFromScode(sc);
2092: }
2093:
2094:
2095: /* ContainerLine_LoadFromStg
2096: ** -------------------------
2097: ** Create a ContainerLine object and initialize it with data that
2098: ** was previously writen to an IStorage*. this function does not
2099: ** immediately OleLoad the associated OLE object, only the data of
2100: ** the ContainerLine object itself is loaded from the IStorage*.
2101: */
2102: LPLINE ContainerLine_LoadFromStg(
2103: LPSTORAGE lpSrcStg,
2104: LPSTREAM lpLLStm,
2105: LPOUTLINEDOC lpDestDoc
2106: )
2107: {
2108: HDC hDC;
2109: LPLINELIST lpDestLL = &lpDestDoc->m_LineList;
2110: ULONG nRead;
2111: HRESULT hrErr;
2112: LPCONTAINERLINE lpContainerLine;
2113: CONTAINERLINERECORD objLineRecord;
2114:
2115: lpContainerLine=(LPCONTAINERLINE) New((DWORD)sizeof(CONTAINERLINE));
2116: if (lpContainerLine == NULL) {
2117: OleDbgAssertSz(
2118: lpContainerLine!=NULL, "Error allocating ContainerLine");
2119: return NULL;
2120: }
2121:
2122: hDC = LineList_GetDC(lpDestLL);
2123: ContainerLine_Init(lpContainerLine, 0, hDC);
2124: LineList_ReleaseDC(lpDestLL, hDC);
2125:
2126: /* OLE2NOTE: In order to have a stable ContainerLine object we must
2127: ** AddRef the object's refcnt. this will be later released when
2128: ** the ContainerLine is deleted.
2129: */
2130: ContainerLine_AddRef(lpContainerLine);
2131:
2132: lpContainerLine->m_lpDoc = (LPCONTAINERDOC) lpDestDoc;
2133:
2134: /* read line record */
2135: hrErr = lpLLStm->lpVtbl->Read(
2136: lpLLStm,
2137: (LPVOID)&objLineRecord,
2138: sizeof(CONTAINERLINERECORD),
2139: &nRead
2140: );
2141:
2142: if (!OleDbgVerifySz(hrErr==NOERROR,"Could not read from LineList stream"))
2143: goto error;
2144:
2145: lstrcpy(lpContainerLine->m_szStgName, objLineRecord.m_szStgName);
2146: lpContainerLine->m_fMonikerAssigned = objLineRecord.m_fMonikerAssigned;
2147: lpContainerLine->m_dwDrawAspect = objLineRecord.m_dwDrawAspect;
2148: lpContainerLine->m_sizeInHimetric = objLineRecord.m_sizeInHimetric;
2149: lpContainerLine->m_fIsLink = objLineRecord.m_fIsLink;
2150:
2151: return (LPLINE)lpContainerLine;
2152:
2153: error:
2154: // destroy partially created ContainerLine
2155: if (lpContainerLine)
2156: ContainerLine_Delete(lpContainerLine);
2157: return NULL;
2158: }
2159:
2160:
2161: /* ContainerLine_GetRelMoniker
2162: ** ---------------------------
2163: ** Retrieve the relative item moniker which identifies the OLE object
2164: ** relative to the container document.
2165: **
2166: ** Returns NULL if a moniker can NOT be created.
2167: */
2168: LPMONIKER ContainerLine_GetRelMoniker(
2169: LPCONTAINERLINE lpContainerLine,
2170: DWORD dwAssign
2171: )
2172: {
2173: LPMONIKER lpmk = NULL;
2174:
2175: /* OLE2NOTE: we should only give out a moniker for the OLE object
2176: ** if the object is allowed to be linked to from the inside. if
2177: ** so we are allowed to give out a moniker which binds to the
2178: ** running OLE object). if the object is an OLE 2.0 embedded
2179: ** object then it is allowed to be linked to from the inside. if
2180: ** the object is either an OleLink or an OLE 1.0 embedding
2181: ** then it can not be linked to from the inside.
2182: ** if we were a container/server app then we could offer linking
2183: ** to the outside of the object (ie. a pseudo object within our
2184: ** document). we are a container only app that does not support
2185: ** linking to ranges of its data.
2186: */
2187:
2188: switch (dwAssign) {
2189:
2190: case GETMONIKER_FORCEASSIGN:
2191:
2192: /* Force the assignment of the name. This is called when a
2193: ** Paste Link actually occurs. From now on we want
2194: ** to inform the OLE object that its moniker is
2195: ** assigned and is thus necessary to register itself
2196: ** in the RunningObjectTable.
2197: */
2198: CreateItemMoniker(
2199: OLESTDDELIM,
2200: lpContainerLine->m_szStgName,
2201: &lpmk
2202: );
2203:
2204: /* OLE2NOTE: if the OLE object is already loaded and it
2205: ** is being assigned a moniker for the first time,
2206: ** then we need to inform it that it now has a moniker
2207: ** assigned by calling IOleObject::SetMoniker. this
2208: ** will force the OLE object to register in the
2209: ** RunningObjectTable when it enters the running
2210: ** state. if the object is not currently loaded,
2211: ** SetMoniker will be called automatically later when
2212: ** the object is loaded by the function
2213: ** ContainerLine_LoadOleObject.
2214: */
2215: if (lpContainerLine->m_lpOleObj &&
2216: !lpContainerLine->m_fMonikerAssigned) {
2217: OLEDBG_BEGIN2("IOleObject::SetMoniker called\r\n")
2218: lpContainerLine->m_lpOleObj->lpVtbl->SetMoniker(
2219: lpContainerLine->m_lpOleObj,
2220: OLEWHICHMK_OBJREL,
2221: lpmk
2222: );
2223: OLEDBG_END2
2224: }
2225:
2226: /* we must remember forever more that this object has a
2227: ** moniker assigned.
2228: */
2229: lpContainerLine->m_fMonikerAssigned = TRUE;
2230: break;
2231:
2232: case GETMONIKER_ONLYIFTHERE:
2233:
2234: /* If the OLE object currently has a moniker assigned,
2235: ** then return it.
2236: */
2237: if (lpContainerLine->m_fMonikerAssigned) {
2238: CreateItemMoniker(
2239: OLESTDDELIM,
2240: lpContainerLine->m_szStgName,
2241: &lpmk
2242: );
2243: }
2244: break;
2245:
2246: case GETMONIKER_TEMPFORUSER:
2247:
2248: /* Return the moniker that would be used for the OLE
2249: ** object but do NOT force moniker assignment at
2250: ** this point. Since our strategy is to use the
2251: ** storage name of the object as its item name, we
2252: ** can simply create the corresponding ItemMoniker
2253: ** (indepenedent of whether the moniker is currently
2254: ** assigned or not).
2255: */
2256: CreateItemMoniker(
2257: OLESTDDELIM,
2258: lpContainerLine->m_szStgName,
2259: &lpmk
2260: );
2261: break;
2262:
2263: case GETMONIKER_UNASSIGN:
2264:
2265: lpContainerLine->m_fMonikerAssigned = FALSE;
2266: break;
2267:
2268: }
2269:
2270: return lpmk;
2271: }
2272:
2273:
2274: /* ContainerLine_GetFullMoniker
2275: ** ----------------------------
2276: ** Retrieve the full absolute moniker which identifies the OLE object
2277: ** in the container document.
2278: ** this moniker is created as a composite of the absolute moniker for
2279: ** the entire document appended with an item moniker which identifies
2280: ** the OLE object relative to the document.
2281: ** Returns NULL if a moniker can NOT be created.
2282: */
2283: LPMONIKER ContainerLine_GetFullMoniker(
2284: LPCONTAINERLINE lpContainerLine,
2285: DWORD dwAssign
2286: )
2287: {
2288: LPMONIKER lpmkDoc = NULL;
2289: LPMONIKER lpmkItem = NULL;
2290: LPMONIKER lpmkFull = NULL;
2291:
2292: lpmkDoc = OleDoc_GetFullMoniker(
2293: (LPOLEDOC)lpContainerLine->m_lpDoc,
2294: dwAssign
2295: );
2296: if (! lpmkDoc) return NULL;
2297:
2298: lpmkItem = ContainerLine_GetRelMoniker(lpContainerLine, dwAssign);
2299:
2300: if (lpmkItem) {
2301: CreateGenericComposite(lpmkDoc, lpmkItem, (LPMONIKER FAR*)&lpmkFull);
2302: OleStdRelease((LPUNKNOWN)lpmkItem);
2303: }
2304:
2305: if (lpmkDoc)
2306: OleStdRelease((LPUNKNOWN)lpmkDoc);
2307:
2308: return lpmkFull;
2309: }
2310:
2311:
2312: /* ContainerLine_GetTextLen
2313: * ------------------------
2314: *
2315: * Return length of the string representation of the ContainerLine
2316: * (not considering the tab level). we will use the following as the
2317: * string representation of a ContainerLine:
2318: * "<" + user type name of OLE object + ">"
2319: * eg:
2320: * <Microsoft Excel Worksheet>
2321: */
2322: int ContainerLine_GetTextLen(LPCONTAINERLINE lpContainerLine)
2323: {
2324: LPSTR lpszUserType = NULL;
2325: HRESULT hrErr;
2326: int nLen;
2327: BOOL fIsLink = ContainerLine_IsOleLink(lpContainerLine);
2328:
2329: /* if object is not already loaded, then load it now. objects are
2330: ** loaded lazily in this manner.
2331: */
2332: if (! lpContainerLine->m_lpOleObj)
2333: ContainerLine_LoadOleObject(lpContainerLine);
2334:
2335: OLEDBG_BEGIN2("IOleObject::GetUserType called\r\n")
2336: hrErr = lpContainerLine->m_lpOleObj->lpVtbl->GetUserType(
2337: lpContainerLine->m_lpOleObj,
2338: USERCLASSTYPE_FULL,
2339: &lpszUserType
2340: );
2341: OLEDBG_END2
2342:
2343: if (hrErr != NOERROR) {
2344: // user type is NOT available
2345: nLen = sizeof(UNKNOWN_OLEOBJ_TYPE) + 2; // allow space for '<' + '>'
2346: nLen += lstrlen((LPSTR)(fIsLink ? szOLELINK : szOLEOBJECT)) + 1;
2347: } else {
2348: nLen = lstrlen(lpszUserType) + 2; // allow space for '<' + '>'
2349: nLen += lstrlen((LPSTR)(fIsLink ? szOLELINK : szOLEOBJECT)) + 1;
2350:
2351: /* OLE2NOTE: we must free the string that was allocated by the
2352: ** IOleObject::GetUserType method.
2353: */
2354: OleStdFreeString(lpszUserType, NULL);
2355: }
2356:
2357: return nLen;
2358: }
2359:
2360:
2361: /* ContainerLine_GetTextData
2362: * -------------------------
2363: *
2364: * Return the string representation of the ContainerLine
2365: * (not considering the tab level). we will use the following as the
2366: * string representation of a ContainerLine:
2367: * "<" + user type name of OLE object + ">"
2368: * eg:
2369: * <Microsoft Excel Worksheet>
2370: */
2371: void ContainerLine_GetTextData(LPCONTAINERLINE lpContainerLine, LPSTR lpszBuf)
2372: {
2373: LPSTR lpszUserType = NULL;
2374: BOOL fIsLink = ContainerLine_IsOleLink(lpContainerLine);
2375: HRESULT hrErr;
2376:
2377: /* if object is not already loaded, then load it now. objects are
2378: ** loaded lazily in this manner.
2379: */
2380: if (! lpContainerLine->m_lpOleObj)
2381: ContainerLine_LoadOleObject(lpContainerLine);
2382:
2383: hrErr = lpContainerLine->m_lpOleObj->lpVtbl->GetUserType(
2384: lpContainerLine->m_lpOleObj,
2385: USERCLASSTYPE_FULL,
2386: &lpszUserType
2387: );
2388:
2389: if (hrErr != NOERROR) {
2390: // user type is NOT available
2391: wsprintf(
2392: lpszBuf,
2393: "<%s %s>",
2394: UNKNOWN_OLEOBJ_TYPE,
2395: (LPSTR)(fIsLink ? szOLELINK : szOLEOBJECT)
2396: );
2397: } else {
2398: wsprintf(
2399: lpszBuf,
2400: "<%s %s>",
2401: lpszUserType,
2402: (LPSTR)(fIsLink ? szOLELINK : szOLEOBJECT)
2403: );
2404:
2405: /* OLE2NOTE: we must free the string that was allocated by the
2406: ** IOleObject::GetUserType method.
2407: */
2408: OleStdFreeString(lpszUserType, NULL);
2409: }
2410: }
2411:
2412:
2413: /* ContainerLine_GetOutlineData
2414: * ----------------------------
2415: *
2416: * Return the CF_OUTLINE format data for the ContainerLine.
2417: */
2418: BOOL ContainerLine_GetOutlineData(
2419: LPCONTAINERLINE lpContainerLine,
2420: LPTEXTLINE lpBuf
2421: )
2422: {
2423: LPLINE lpLine = (LPLINE)lpContainerLine;
2424: LPLINELIST lpLL = &((LPOUTLINEDOC)lpContainerLine->m_lpDoc)->m_LineList;
2425: HDC hDC;
2426: char szTmpBuf[MAXSTRLEN+1];
2427: LPTEXTLINE lpTmpTextLine;
2428:
2429: // Create a TextLine with the Text representation of the ContainerLine.
2430: ContainerLine_GetTextData(lpContainerLine, (LPSTR)szTmpBuf);
2431:
2432: hDC = LineList_GetDC(lpLL);
2433: lpTmpTextLine = TextLine_Create(hDC, lpLine->m_nTabLevel, szTmpBuf);
2434: LineList_ReleaseDC(lpLL, hDC);
2435:
2436: TextLine_Copy(lpTmpTextLine, lpBuf);
2437:
2438: // Delete the temporary TextLine
2439: TextLine_Delete(lpTmpTextLine);
2440: return TRUE;
2441: }
2442:
2443:
2444: /* ContainerLine_GetOleObjectRectInPixels
2445: ** --------------------------------------
2446: ** Get the extent of the OLE Object contained in the given Line in
2447: ** client coordinates after scaling.
2448: */
2449: void ContainerLine_GetOleObjectRectInPixels(LPCONTAINERLINE lpContainerLine, LPRECT lprc)
2450: {
2451: LPOUTLINEDOC lpOutlineDoc;
2452: LPSCALEFACTOR lpscale;
2453: LPLINELIST lpLL;
2454: LPLINE lpLine;
2455: int nIndex;
2456: HDC hdcLL;
2457:
2458: if (!lpContainerLine || !lprc)
2459: return;
2460:
2461: lpOutlineDoc = (LPOUTLINEDOC)lpContainerLine->m_lpDoc;
2462: lpscale = OutlineDoc_GetScaleFactor(lpOutlineDoc);
2463: lpLL = OutlineDoc_GetLineList(lpOutlineDoc);
2464: lpLine = (LPLINE)lpContainerLine;
2465: nIndex = LineList_GetLineIndex(lpLL, lpLine);
2466:
2467: LineList_GetLineRect(lpLL, nIndex, lprc);
2468:
2469: hdcLL = GetDC(lpLL->m_hWndListBox);
2470:
2471: /* lprc is set to be size of Line Object (including the boundary) */
2472: lprc->left += (int)(
2473: (long)XformWidthInHimetricToPixels(hdcLL,
2474: lpLine->m_nTabWidthInHimetric +
2475: LOWORD(OutlineDoc_GetMargin(lpOutlineDoc))) *
2476: lpscale->dwSxN / lpscale->dwSxD);
2477: lprc->right = (int)(
2478: lprc->left + (long)
2479: XformWidthInHimetricToPixels(hdcLL, lpLine->m_nWidthInHimetric) *
2480: lpscale->dwSxN / lpscale->dwSxD);
2481:
2482: // Remove the boundary from rect
2483: InflateRect(
2484: lprc,
2485: (int)(-LINE_BOUNDARY_WIDTH * lpscale->dwSxN / lpscale->dwSxD),
2486: (int)(-LINE_BOUNDARY_WIDTH * lpscale->dwSyN / lpscale->dwSyD)
2487: );
2488:
2489: ReleaseDC(lpLL->m_hWndListBox, hdcLL);
2490: }
2491:
2492:
2493: /* ContainerLine_GetOleObjectSizeInHimetric
2494: ** ----------------------------------------
2495: ** Get the size of the OLE Object contained in the given Line
2496: */
2497: void ContainerLine_GetOleObjectSizeInHimetric(LPCONTAINERLINE lpContainerLine, LPSIZEL lpsizel)
2498: {
2499: if (!lpContainerLine || !lpsizel)
2500: return;
2501:
2502: *lpsizel = lpContainerLine->m_sizeInHimetric;
2503: }
2504:
2505:
2506:
2507: /*************************************************************************
2508: ** ContainerLine::IUnknown interface implementation
2509: *************************************************************************/
2510:
2511: STDMETHODIMP CntrLine_Unk_QueryInterface(
2512: LPUNKNOWN lpThis,
2513: REFIID riid,
2514: LPVOID FAR* lplpvObj
2515: )
2516: {
2517: LPCONTAINERLINE lpContainerLine =
2518: ((struct COleClientSiteImpl FAR*)lpThis)->lpContainerLine;
2519:
2520: return ContainerLine_QueryInterface(lpContainerLine, riid, lplpvObj);
2521: }
2522:
2523:
2524: STDMETHODIMP_(ULONG) CntrLine_Unk_AddRef(LPUNKNOWN lpThis)
2525: {
2526: LPCONTAINERLINE lpContainerLine =
2527: ((struct COleClientSiteImpl FAR*)lpThis)->lpContainerLine;
2528:
2529: OleDbgAddRefMethod(lpThis, "IUnknown");
2530:
2531: return ContainerLine_AddRef(lpContainerLine);
2532: }
2533:
2534:
2535: STDMETHODIMP_(ULONG) CntrLine_Unk_Release(LPUNKNOWN lpThis)
2536: {
2537: LPCONTAINERLINE lpContainerLine =
2538: ((struct COleClientSiteImpl FAR*)lpThis)->lpContainerLine;
2539:
2540: OleDbgReleaseMethod(lpThis, "IUnknown");
2541:
2542: return ContainerLine_Release(lpContainerLine);
2543: }
2544:
2545:
2546: /*************************************************************************
2547: ** ContainerLine::IOleClientSite interface implementation
2548: *************************************************************************/
2549:
2550: STDMETHODIMP CntrLine_CliSite_QueryInterface(
2551: LPOLECLIENTSITE lpThis,
2552: REFIID riid,
2553: LPVOID FAR* lplpvObj
2554: )
2555: {
2556: LPCONTAINERLINE lpContainerLine =
2557: ((struct COleClientSiteImpl FAR*)lpThis)->lpContainerLine;
2558:
2559: return ContainerLine_QueryInterface(lpContainerLine, riid, lplpvObj);
2560: }
2561:
2562:
2563: STDMETHODIMP_(ULONG) CntrLine_CliSite_AddRef(LPOLECLIENTSITE lpThis)
2564: {
2565: LPCONTAINERLINE lpContainerLine =
2566: ((struct COleClientSiteImpl FAR*)lpThis)->lpContainerLine;
2567:
2568: OleDbgAddRefMethod(lpThis, "IOleClientSite");
2569:
2570: return ContainerLine_AddRef(lpContainerLine);
2571: }
2572:
2573:
2574: STDMETHODIMP_(ULONG) CntrLine_CliSite_Release(LPOLECLIENTSITE lpThis)
2575: {
2576: LPCONTAINERLINE lpContainerLine =
2577: ((struct COleClientSiteImpl FAR*)lpThis)->lpContainerLine;
2578:
2579: OleDbgReleaseMethod(lpThis, "IOleClientSite");
2580:
2581: return ContainerLine_Release(lpContainerLine);
2582: }
2583:
2584:
2585: STDMETHODIMP CntrLine_CliSite_SaveObject(LPOLECLIENTSITE lpThis)
2586: {
2587: LPCONTAINERLINE lpContainerLine =
2588: ((struct COleClientSiteImpl FAR*)lpThis)->lpContainerLine;
2589: SCODE sc = E_FAIL;
2590: HRESULT hrErr;
2591: BOOL fSameAsLoad = TRUE;
2592: BOOL fRemember = TRUE;
2593:
2594: OLEDBG_BEGIN2("CntrLine_CliSite_SaveObject\r\n")
2595:
2596: if (lpContainerLine->m_lpOleObj == NULL) {
2597: OleDbgAssertSz(
2598: lpContainerLine->m_lpOleObj != NULL, "OLE object not loaded");
2599: sc = E_FAIL;
2600: goto error;
2601: }
2602:
2603: // mark ContainerDoc as now dirty
2604: OutlineDoc_SetModified(
2605: (LPOUTLINEDOC)lpContainerLine->m_lpDoc, TRUE, TRUE, FALSE);
2606:
2607: /* Tell OLE object to save itself */
2608: hrErr = ContainerLine_SaveOleObject(
2609: lpContainerLine,
2610: lpContainerLine->m_lpStg,
2611: fSameAsLoad,
2612: fRemember,
2613: FALSE /* fForceUpdate */
2614: );
2615:
2616: if (hrErr != NOERROR) {
2617: sc = GetScode(hrErr);
2618: goto error;
2619: }
2620:
2621: OLEDBG_END2
2622: return NOERROR;
2623:
2624: error:
2625: OLEDBG_END2
2626: return ResultFromScode(sc);
2627: }
2628:
2629:
2630: STDMETHODIMP CntrLine_CliSite_GetMoniker(
2631: LPOLECLIENTSITE lpThis,
2632: DWORD dwAssign,
2633: DWORD dwWhichMoniker,
2634: LPMONIKER FAR* lplpmk
2635: )
2636: {
2637: LPCONTAINERLINE lpContainerLine;
2638:
2639: lpContainerLine=((struct COleClientSiteImpl FAR*)lpThis)->lpContainerLine;
2640:
2641: OLEDBG_BEGIN2("CntrLine_CliSite_GetMoniker\r\n")
2642:
2643: // OLE2NOTE: we must make sure to set output pointer parameters to NULL
2644: *lplpmk = NULL;
2645:
2646: switch (dwWhichMoniker) {
2647:
2648: case OLEWHICHMK_CONTAINER:
2649: /* OLE2NOTE: create a FileMoniker which identifies the
2650: ** entire container document.
2651: */
2652: *lplpmk = OleDoc_GetFullMoniker(
2653: (LPOLEDOC)lpContainerLine->m_lpDoc,
2654: dwAssign
2655: );
2656: break;
2657:
2658: case OLEWHICHMK_OBJREL:
2659:
2660: /* OLE2NOTE: create an ItemMoniker which identifies the
2661: ** OLE object relative to the container document.
2662: */
2663: *lplpmk = ContainerLine_GetRelMoniker(lpContainerLine, dwAssign);
2664: break;
2665:
2666: case OLEWHICHMK_OBJFULL:
2667: {
2668: /* OLE2NOTE: create an absolute moniker which identifies the
2669: ** OLE object in the container document. this moniker is
2670: ** created as a composite of the absolute moniker for the
2671: ** entire document appended with an item moniker which
2672: ** identifies the OLE object relative to the document.
2673: */
2674:
2675: *lplpmk = ContainerLine_GetFullMoniker(lpContainerLine, dwAssign);
2676: break;
2677: }
2678: }
2679:
2680: OLEDBG_END2
2681:
2682: if (*lplpmk != NULL)
2683: return NOERROR;
2684: else
2685: return ResultFromScode(E_FAIL);
2686: }
2687:
2688:
2689: STDMETHODIMP CntrLine_CliSite_GetContainer(
2690: LPOLECLIENTSITE lpThis,
2691: LPOLECONTAINER FAR* lplpContainer
2692: )
2693: {
2694: LPCONTAINERLINE lpContainerLine;
2695: HRESULT hrErr;
2696:
2697: OLEDBG_BEGIN2("CntrLine_CliSite_GetContainer\r\n")
2698:
2699: lpContainerLine=((struct COleClientSiteImpl FAR*)lpThis)->lpContainerLine;
2700:
2701: hrErr = OleDoc_QueryInterface(
2702: (LPOLEDOC)lpContainerLine->m_lpDoc,
2703: &IID_IOleContainer,
2704: (LPVOID FAR*)lplpContainer
2705: );
2706:
2707: OLEDBG_END2
2708: return hrErr;
2709: }
2710:
2711:
2712: STDMETHODIMP CntrLine_CliSite_ShowObject(LPOLECLIENTSITE lpThis)
2713: {
2714: LPCONTAINERLINE lpContainerLine =
2715: ((struct COleClientSiteImpl FAR*)lpThis)->lpContainerLine;
2716: LPOUTLINEDOC lpOutlineDoc = (LPOUTLINEDOC)lpContainerLine->m_lpDoc;
2717: LPLINELIST lpLL = OutlineDoc_GetLineList(lpOutlineDoc);
2718: int nIndex = LineList_GetLineIndex(lpLL, (LPLINE)lpContainerLine);
2719: HWND hWndFrame = OutlineApp_GetFrameWindow(g_lpApp);
2720:
2721: OLEDBG_BEGIN2("CntrLine_CliSite_ShowObject\r\n")
2722:
2723: /* make sure our doc window is visible and not minimized.
2724: ** the OutlineDoc_ShowWindow function will cause the app window
2725: ** to show itself SW_SHOWNORMAL.
2726: */
2727: if (! IsWindowVisible(hWndFrame) || IsIconic(hWndFrame))
2728: OutlineDoc_ShowWindow(lpOutlineDoc);
2729:
2730: /* make sure that the OLE object is currently in view. if necessary
2731: ** scroll the document in order to bring it into view.
2732: */
2733: LineList_ScrollLineIntoView(lpLL, nIndex);
2734:
2735: #if defined( INPLACE_CNTR )
2736: /* after the in-place object is scrolled into view, we need to ask
2737: ** it to update its rect for the new clip rect coordinates
2738: */
2739: ContainerDoc_UpdateInPlaceObjectRects((LPCONTAINERDOC)lpOutlineDoc, 0);
2740: #endif
2741:
2742: OLEDBG_END2
2743: return NOERROR;
2744: }
2745:
2746:
2747: STDMETHODIMP CntrLine_CliSite_OnShowWindow(LPOLECLIENTSITE lpThis, BOOL fShow)
2748: {
2749: LPCONTAINERLINE lpContainerLine =
2750: ((struct COleClientSiteImpl FAR*)lpThis)->lpContainerLine;
2751: LPOUTLINEDOC lpOutlineDoc = (LPOUTLINEDOC)lpContainerLine->m_lpDoc;
2752: LPLINELIST lpLL = OutlineDoc_GetLineList(lpOutlineDoc);
2753: int nIndex = LineList_GetLineIndex(lpLL, (LPLINE)lpContainerLine);
2754:
2755: if (fShow) {
2756: OLEDBG_BEGIN2("CntrLine_CliSite_OnShowWindow(TRUE)\r\n")
2757:
2758: /* OLE2NOTE: we need to hatch out the OLE object now; it has
2759: ** just been opened in a window elsewhere (open editing as
2760: ** opposed to in-place activation).
2761: ** force the line to re-draw with the hatch.
2762: */
2763: lpContainerLine->m_fObjWinOpen = TRUE;
2764: LineList_ForceLineRedraw(lpLL, nIndex, FALSE);
2765:
2766: } else {
2767: OLEDBG_BEGIN2("CntrLine_CliSite_OnShowWindow(FALSE)\r\n")
2768:
2769: /* OLE2NOTE: the object associated with this container site has
2770: ** just closed its server window. we should now remove the
2771: ** hatching that indicates that the object is open
2772: ** elsewhere. also our window should now come to the top.
2773: ** force the line to re-draw without the hatch.
2774: */
2775: lpContainerLine->m_fObjWinOpen = FALSE;
2776: LineList_ForceLineRedraw(lpLL, nIndex, TRUE);
2777:
2778: BringWindowToTop(lpOutlineDoc->m_hWndDoc);
2779: SetFocus(lpOutlineDoc->m_hWndDoc);
2780: }
2781:
2782: OLEDBG_END2
2783: return NOERROR;
2784: }
2785:
2786:
2787: STDMETHODIMP CntrLine_CliSite_RequestNewObjectLayout(LPOLECLIENTSITE lpThis)
2788: {
2789: OleDbgOut2("CntrLine_CliSite_RequestNewObjectLayout\r\n");
2790:
2791: /* OLE2NOTE: this method is NOT yet used. it is for future layout
2792: ** negotiation support.
2793: */
2794: return ResultFromScode(E_NOTIMPL);
2795: }
2796:
2797:
2798: /*************************************************************************
2799: ** ContainerLine::IAdviseSink interface implementation
2800: *************************************************************************/
2801:
2802: STDMETHODIMP CntrLine_AdvSink_QueryInterface(
2803: LPADVISESINK lpThis,
2804: REFIID riid,
2805: LPVOID FAR* lplpvObj
2806: )
2807: {
2808: LPCONTAINERLINE lpContainerLine =
2809: ((struct COleClientSiteImpl FAR*)lpThis)->lpContainerLine;
2810:
2811: return ContainerLine_QueryInterface(lpContainerLine, riid, lplpvObj);
2812: }
2813:
2814:
2815: STDMETHODIMP_(ULONG) CntrLine_AdvSink_AddRef(LPADVISESINK lpThis)
2816: {
2817: LPCONTAINERLINE lpContainerLine =
2818: ((struct COleClientSiteImpl FAR*)lpThis)->lpContainerLine;
2819:
2820: OleDbgAddRefMethod(lpThis, "IAdviseSink");
2821:
2822: return ContainerLine_AddRef(lpContainerLine);
2823: }
2824:
2825:
2826: STDMETHODIMP_(ULONG) CntrLine_AdvSink_Release (LPADVISESINK lpThis)
2827: {
2828: LPCONTAINERLINE lpContainerLine =
2829: ((struct COleClientSiteImpl FAR*)lpThis)->lpContainerLine;
2830:
2831: OleDbgReleaseMethod(lpThis, "IAdviseSink");
2832:
2833: return ContainerLine_Release(lpContainerLine);
2834: }
2835:
2836:
2837: STDMETHODIMP_(void) CntrLine_AdvSink_OnDataChange(
2838: LPADVISESINK lpThis,
2839: FORMATETC FAR* lpFormatetc,
2840: STGMEDIUM FAR* lpStgmed
2841: )
2842: {
2843: OleDbgOut2("CntrLine_AdvSink_OnDataChange\r\n");
2844:
2845: // We are not interested in data changes (only view changes)
2846: // (ie. nothing to do)
2847: }
2848:
2849:
2850: STDMETHODIMP_(void) CntrLine_AdvSink_OnViewChange(
2851: LPADVISESINK lpThis,
2852: DWORD aspects,
2853: LONG lindex
2854: )
2855: {
2856: LPCONTAINERLINE lpContainerLine;
2857: LPOUTLINEDOC lpOutlineDoc;
2858: HWND hWndDoc;
2859: LPLINELIST lpLL;
2860: MSG msg;
2861: int nIndex;
2862:
2863: OLEDBG_BEGIN2("CntrLine_AdvSink_OnViewChange\r\n")
2864:
2865: lpContainerLine = ((struct CAdviseSinkImpl FAR*)lpThis)->lpContainerLine;
2866: lpOutlineDoc = (LPOUTLINEDOC)lpContainerLine->m_lpDoc;
2867:
2868: /* OLE2NOTE: at this point we simply invalidate the rectangle of
2869: ** the object to force a repaint in the future, we mark
2870: ** that the extents of the object may have changed
2871: ** (m_fDoGetExtent=TRUE), and we post a message
2872: ** (WM_U_UPDATEOBJECTEXTENT) to our document that one or more
2873: ** OLE objects may need to have their extents updated. later
2874: ** when this message is processed, the document loops through
2875: ** all lines to see if any are marked as needing an extent update.
2876: ** if infact the extents did change. this can be done by calling
2877: ** IOleObject::GetExtent to retreive the object's current
2878: ** extents and comparing with the last known extents for the
2879: ** object. if the extents changed, then relayout space for the
2880: ** object before drawing. we postpone the check to get
2881: ** the extents now because OnViewChange is an asyncronis method,
2882: ** and we have to careful not to call any syncronis methods back
2883: ** to the object. it is good practise to not call any object
2884: ** methods from within an asyncronis notification method.
2885: ** if there is already WM_U_UPDATEOBJECTEXTENT message waiting
2886: ** in our message queue, there is no need to post another one.
2887: ** in this way, if the server is updating quicker than we can
2888: ** keep up, we do not make unneccsary GetExtent calls. also if
2889: ** drawing is disabled, we postpone updating the extents of any
2890: ** objects until drawing is re-enabled.
2891: */
2892: lpContainerLine->m_fDoGetExtent = TRUE;
2893: hWndDoc = OutlineDoc_GetWindow((LPOUTLINEDOC)lpContainerLine->m_lpDoc);
2894:
2895: if (lpOutlineDoc->m_nDisableDraw == 0 &&
2896: ! PeekMessage(&msg, hWndDoc,
2897: WM_U_UPDATEOBJECTEXTENT, WM_U_UPDATEOBJECTEXTENT,
2898: PM_NOREMOVE | PM_NOYIELD)) {
2899: PostMessage(
2900: hWndDoc, WM_U_UPDATEOBJECTEXTENT, 0, 0L);
2901: }
2902:
2903: // force the modified line to redraw.
2904: lpLL = OutlineDoc_GetLineList(lpOutlineDoc);
2905: nIndex = LineList_GetLineIndex(lpLL, (LPLINE)lpContainerLine);
2906: LineList_ForceLineRedraw(lpLL, nIndex, TRUE);
2907:
2908: // mark ContainerDoc as now dirty
2909: OutlineDoc_SetModified(lpOutlineDoc, TRUE, TRUE, FALSE);
2910:
2911: OLEDBG_END2
2912: }
2913:
2914:
2915: STDMETHODIMP_(void) CntrLine_AdvSink_OnRename(
2916: LPADVISESINK lpThis,
2917: LPMONIKER lpmk
2918: )
2919: {
2920: OleDbgOut2("CntrLine_AdvSink_OnRename\r\n");
2921:
2922: /* OLE2NOTE: the Embedding Container has nothing to do here. this
2923: ** notification is important for linking situations. it tells
2924: ** the OleLink objects to update their moniker because the
2925: ** source object has been renamed (track the link source).
2926: */
2927: }
2928:
2929:
2930: STDMETHODIMP_(void) CntrLine_AdvSink_OnSave(LPADVISESINK lpThis)
2931: {
2932: OleDbgOut2("CntrLine_AdvSink_OnSave\r\n");
2933:
2934: /* OLE2NOTE: the Embedding Container has nothing to do here. this
2935: ** notification is only useful to clients which have set up a
2936: ** data cache with the ADVFCACHE_ONSAVE flag.
2937: */
2938: }
2939:
2940:
2941: STDMETHODIMP_(void) CntrLine_AdvSink_OnClose(LPADVISESINK lpThis)
2942: {
2943: OleDbgOut2("CntrLine_AdvSink_OnClose\r\n");
2944:
2945: /* OLE2NOTE: the Embedding Container has nothing to do here. this
2946: ** notification is important for the OLE's default object handler
2947: ** and the OleLink object. it tells them the remote object is
2948: ** shutting down.
2949: */
2950: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.