![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to svrbase.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 svrbase.c CVS log | Up to [WindowsNT SDKs] / mstools / ole20 / samples / outline |
1.1 root 1: /*************************************************************************
2: **
3: ** OLE 2 Server Sample Code
4: **
5: ** svrbase.c
6: **
7: ** This file contains all interfaces, methods and related support
8: ** functions for the basic OLE Object (Server) application. The
9: ** basic OLE Object application supports embedding an object and
10: ** linking to a file-based or embedded object as a whole. The basic
11: ** Object application includes the following implementation objects:
12: **
13: ** ClassFactory (aka. ClassObject) Object (see file classfac.c)
14: ** exposed interfaces:
15: ** IClassFactory interface
16: **
17: ** ServerDoc Object
18: ** exposed interfaces:
19: ** IUnknown
20: ** IOleObject interface
21: ** IPersistStorage interface
22: ** IDataObject interface
23: **
24: ** ServerApp Object
25: ** exposed interfaces:
26: ** IUnknown
27: **
28: ** (c) Copyright Microsoft Corp. 1992 - 1993 All Rights Reserved
29: **
30: *************************************************************************/
31:
32:
33: #include "outline.h"
34: #include <regdb.h>
35: #include <enumfetc.h>
36: #include <geticon.h>
37:
38: OLEDBGDATA
39:
40: extern LPOUTLINEAPP g_lpApp;
41: extern IOleObjectVtbl g_SvrDoc_OleObjectVtbl;
42: extern IPersistStorageVtbl g_SvrDoc_PersistStorageVtbl;
43:
44: #if defined( INPLACE_SVR )
45: extern IOleInPlaceObjectVtbl g_SvrDoc_OleInPlaceObjectVtbl;
46: extern IOleInPlaceActiveObjectVtbl g_SvrDoc_OleInPlaceActiveObjectVtbl;
47: #endif // INPLACE_SVR
48:
49: #if defined( SVR_TREATAS )
50: extern IStdMarshalInfoVtbl g_SvrDoc_StdMarshalInfoVtbl;
51: #endif // SVR_TREATAS
52:
53:
54: // REVIEW: should use string resource for messages
55: extern char ErrMsgSaving[];
56: extern char ErrMsgFormatNotSupported[];
57: static char ErrMsgPSSaveFail[] = "PSSave failed";
58: extern char g_szUpdateCntrDoc[] = "&Update %s";
59: extern char g_szExitNReturnToCntrDoc[] = "E&xit && Return to %s";
60:
61:
62: /*************************************************************************
63: ** ServerDoc::IOleObject interface implementation
64: *************************************************************************/
65:
66: // IOleObject::QueryInterface method
67:
68: STDMETHODIMP SvrDoc_OleObj_QueryInterface(
69: LPOLEOBJECT lpThis,
70: REFIID riid,
71: LPVOID FAR* lplpvObj
72: )
73: {
74: LPSERVERDOC lpServerDoc =
75: ((struct CDocOleObjectImpl FAR*)lpThis)->lpServerDoc;
76:
77: return OleDoc_QueryInterface((LPOLEDOC)lpServerDoc, riid, lplpvObj);
78: }
79:
80:
81: // IOleObject::AddRef method
82:
83: STDMETHODIMP_(ULONG) SvrDoc_OleObj_AddRef(LPOLEOBJECT lpThis)
84: {
85: LPSERVERDOC lpServerDoc =
86: ((struct CDocOleObjectImpl FAR*)lpThis)->lpServerDoc;
87:
88: OleDbgAddRefMethod(lpThis, "IOleObject");
89:
90: return OleDoc_AddRef((LPOLEDOC)lpServerDoc);
91: }
92:
93:
94: // IOleObject::Release method
95:
96: STDMETHODIMP_(ULONG) SvrDoc_OleObj_Release(LPOLEOBJECT lpThis)
97: {
98: LPSERVERDOC lpServerDoc =
99: ((struct CDocOleObjectImpl FAR*)lpThis)->lpServerDoc;
100:
101: OleDbgReleaseMethod(lpThis, "IOleObject");
102:
103: return OleDoc_Release((LPOLEDOC)lpServerDoc);
104: }
105:
106:
107: // IOleObject::SetClientSite method
108:
109: STDMETHODIMP SvrDoc_OleObj_SetClientSite(
110: LPOLEOBJECT lpThis,
111: LPOLECLIENTSITE lpclientSite
112: )
113: {
114: LPSERVERDOC lpServerDoc =
115: ((struct CDocOleObjectImpl FAR*)lpThis)->lpServerDoc;
116: LPOUTLINEDOC lpOutlineDoc = (LPOUTLINEDOC)lpServerDoc;
117:
118: OLEDBG_BEGIN2("SvrDoc_OleObj_SetClientSite\r\n")
119:
120: // SetClientSite is only valid to call on an embedded object
121: if (lpOutlineDoc->m_docInitType != DOCTYPE_EMBEDDED) {
122: OleDbgAssert(lpOutlineDoc->m_docInitType == DOCTYPE_EMBEDDED);
123: OLEDBG_END2
124: return ResultFromScode(E_UNEXPECTED);
125: }
126:
127: /* if we currently have a client site ptr, then release it. */
128: if (lpServerDoc->m_lpOleClientSite)
129: OleStdRelease((LPUNKNOWN)lpServerDoc->m_lpOleClientSite);
130:
131: lpServerDoc->m_lpOleClientSite = (LPOLECLIENTSITE) lpclientSite;
132: // OLE2NOTE: to be able to hold onto clientSite pointer, we must AddRef it
133: if (lpclientSite)
134: lpclientSite->lpVtbl->AddRef(lpclientSite);
135:
136: OLEDBG_END2
137: return NOERROR;
138: }
139:
140:
141: // IOleObject::GetClientSite method
142:
143: STDMETHODIMP SvrDoc_OleObj_GetClientSite(
144: LPOLEOBJECT lpThis,
145: LPOLECLIENTSITE FAR* lplpClientSite
146: )
147: {
148: LPSERVERDOC lpServerDoc =
149: ((struct CDocOleObjectImpl FAR*)lpThis)->lpServerDoc;
150:
151: OleDbgOut2("SvrDoc_OleObj_GetClientSite\r\n");
152:
153: /* OLE2NOTE: we MUST AddRef this interface pointer to give the
154: ** caller a personal copy of the pointer
155: */
156: lpServerDoc->m_lpOleClientSite->lpVtbl->AddRef(
157: lpServerDoc->m_lpOleClientSite
158: );
159: *lplpClientSite = lpServerDoc->m_lpOleClientSite;
160:
161: return NOERROR;
162:
163: }
164:
165:
166: // IOleObject::SetHostNames method
167:
168: STDMETHODIMP SvrDoc_OleObj_SetHostNames(
169: LPOLEOBJECT lpThis,
170: LPCSTR szContainerApp,
171: LPCSTR szContainerObj
172: )
173: {
174: LPSERVERDOC lpServerDoc =
175: ((struct CDocOleObjectImpl FAR*)lpThis)->lpServerDoc;
176: LPOUTLINEDOC lpOutlineDoc = (LPOUTLINEDOC)lpServerDoc;
177:
178: OleDbgOut2("SvrDoc_OleObj_SetHostNames\r\n");
179:
180: lstrcpy((LPSTR)lpServerDoc->m_szContainerApp, szContainerApp);
181: lstrcpy((LPSTR)lpServerDoc->m_szContainerObj, szContainerObj);
182:
183: /* The Window title for an embedded object is constructed as
184: ** follows:
185: ** <server app name> - <obj short type> in <cont. doc name>
186: **
187: ** here we construct the current document title portion of the
188: ** name which follows the '-'. OutlineDoc_SetTitle prepends the
189: ** "<server app name> - " to the document title.
190: */
191: // REVIEW: this string should be loaded from string resource
192: wsprintf(lpOutlineDoc->m_szFileName, "%s in %s",
193: (LPSTR)SHORTUSERTYPENAME, (LPSTR)lpServerDoc->m_szContainerObj);
194:
195: lpOutlineDoc->m_lpszDocTitle = lpOutlineDoc->m_szFileName;
196: OutlineDoc_SetTitle(lpOutlineDoc);
197:
198: /* OLE2NOTE: update the application menus correctly for an embedded
199: ** object. the changes include:
200: ** 1 Remove File/New and File/Open (SDI ONLY)
201: ** 2 Change File/Save As.. to File/Save Copy As..
202: ** 3 Change File menu so it contains "Update" instead of "Save"
203: ** 4 Change File/Exit to File/Exit & Return to <client doc>"
204: */
205: ServerDoc_UpdateMenu(lpServerDoc);
206:
207: return NOERROR;
208: }
209:
210:
211: // IOleObject::Close method
212:
213: STDMETHODIMP SvrDoc_OleObj_Close(
214: LPOLEOBJECT lpThis,
215: DWORD dwSaveOption
216: )
217: {
218: LPSERVERDOC lpServerDoc =
219: ((struct CDocOleObjectImpl FAR*)lpThis)->lpServerDoc;
220: BOOL fStatus;
221:
222: OLEDBG_BEGIN2("SvrDoc_OleObj_Close\r\n")
223:
224: // REVIEW: dwSaveOption not yet supported
225:
226: /* OLE2NOTE: the OLE 2.0 user model is that embedded objects should
227: ** always be saved when closed WITHOUT any prompting to the
228: ** user. this is the recommendation irregardless of whether the
229: ** object is activated in-place or open in its own window.
230: ** this is a CHANGE from the OLE 1.0 user model where it
231: ** was the guideline that servers always prompt to save changes.
232: ** thus OLE 2.0 compound document oriented container's should
233: ** always pass dwSaveOption==OLECLOSE_SAVEIFDIRTY. it is
234: ** possible that for programmatic uses a container may want to
235: ** specify a different dwSaveOption. the implementation of
236: ** various save options can be tricky, particularly considering
237: ** cases involving in-place activation. the following would be
238: ** reasonable behavior:
239: **
240: ** (1) OLECLOSE_SAVEIFDIRTY: if dirty, save. close.
241: ** (2) OLECLOSE_NOSAVE: close.
242: ** (3) OLECLOSE_PROMPTSAVE:
243: ** (a) object visible, but not in-place:
244: ** if not dirty, close.
245: ** switch(prompt)
246: ** case IDYES: save. close.
247: ** case IDNO: close.
248: ** case IDCANCEL: return OLE_E_PROMPTSAVECANCELLED
249: ** (b) object invisible (includes UIDeactivated object)
250: ** if dirty, save. close.
251: ** NOTE: NO PROMPT. it is not appropriate to prompt
252: ** if the object is not visible.
253: ** (c) object is in-place active:
254: ** if dirty, save. close.
255: ** NOTE: NO PROMPT. it is not appropriate to prompt
256: ** if the object is active in-place.
257: */
258:
259: fStatus = OutlineDoc_Close((LPOUTLINEDOC)lpServerDoc, dwSaveOption);
260: OleDbgAssertSz(fStatus == TRUE, "SvrDoc_OleObj_Close failed\r\n");
261:
262: OLEDBG_END2
263: return (fStatus ? NOERROR : ResultFromScode(E_FAIL));
264: }
265:
266:
267: // IOleObject::SetMoniker method
268:
269: STDMETHODIMP SvrDoc_OleObj_SetMoniker(
270: LPOLEOBJECT lpThis,
271: DWORD dwWhichMoniker,
272: LPMONIKER lpmk
273: )
274: {
275: LPSERVERDOC lpServerDoc =
276: ((struct CDocOleObjectImpl FAR*)lpThis)->lpServerDoc;
277: LPOLEDOC lpOleDoc = (LPOLEDOC)lpServerDoc;
278: LPMONIKER lpmkFull;
279: HRESULT hrErr;
280: SCODE sc;
281:
282: OLEDBG_BEGIN2("SvrDoc_OleObj_SetMoniker\r\n")
283:
284: /* only our container should call IOleObject::SetMoniker. if we
285: ** don't have a ClientSite assigned then ignore this attempt to
286: ** set our moniker.
287: */
288: if (lpServerDoc->m_lpOleClientSite == NULL) {
289: sc = E_FAIL;
290: goto error;
291: }
292:
293: /* retrieve our full, absolute moniker from our container. the
294: ** moniker passed to the current method is either the relative
295: ** moniker of the object or the moniker of our container. we
296: ** require the full moniker in order to register as running.
297: */
298: hrErr = lpServerDoc->m_lpOleClientSite->lpVtbl->GetMoniker(
299: lpServerDoc->m_lpOleClientSite,
300: OLEGETMONIKER_ONLYIFTHERE,
301: OLEWHICHMK_OBJFULL,
302: &lpmkFull
303: );
304: if (hrErr != NOERROR) {
305: sc = GetScode(hrErr);
306: goto error;
307: }
308:
309: /* Register the document as running with the new moniker and
310: ** notify any clients that our moniker has changed.
311: */
312: OleDoc_DocRenamedUpdate(lpOleDoc, lpmkFull);
313:
314: if (lpmkFull)
315: OleStdRelease((LPUNKNOWN)lpmkFull);
316:
317: OLEDBG_END2
318: return NOERROR;
319:
320: error:
321: OLEDBG_END2
322: return ResultFromScode(sc);
323: }
324:
325:
326: // IOleObject::GetMoniker method
327:
328: STDMETHODIMP SvrDoc_OleObj_GetMoniker(
329: LPOLEOBJECT lpThis,
330: DWORD dwAssign,
331: DWORD dwWhichMoniker,
332: LPMONIKER FAR* lplpmk
333: )
334: {
335: LPSERVERDOC lpServerDoc =
336: ((struct CDocOleObjectImpl FAR*)lpThis)->lpServerDoc;
337: HRESULT hrErr;
338: SCODE sc;
339:
340: OLEDBG_BEGIN2("SvrDoc_OleObj_GetMoniker\r\n")
341:
342: /* OLE2NOTE: we must make sure to set all out parameters to NULL. */
343: *lplpmk = NULL;
344:
345: if (lpServerDoc->m_lpOleClientSite != NULL) {
346: OleDbgAssert(((LPOUTLINEDOC)lpServerDoc)->m_docInitType==DOCTYPE_EMBEDDED);
347:
348: /* document is an embedded object. retrieve our moniker from
349: ** our container.
350: */
351: OLEDBG_BEGIN2("IOleClientSite::GetMoniker called\r\n")
352: hrErr = lpServerDoc->m_lpOleClientSite->lpVtbl->GetMoniker(
353: lpServerDoc->m_lpOleClientSite,
354: dwAssign,
355: dwWhichMoniker,
356: lplpmk
357: );
358: OLEDBG_END2
359:
360: } else if (((LPOUTLINEDOC)lpServerDoc)->m_docInitType == DOCTYPE_FROMFILE) {
361:
362: // document is a file-based document => return a FileMoniker
363: hrErr = CreateFileMoniker(
364: ((LPOUTLINEDOC)lpServerDoc)->m_szFileName,
365: lplpmk
366: );
367:
368: } else {
369: // document is either New or not yet fully initialized => no moniker
370: sc = E_FAIL;
371: goto error;
372: }
373:
374: OLEDBG_END2
375: return hrErr;
376:
377: error:
378: OLEDBG_END2
379: return ResultFromScode(sc);
380: }
381:
382:
383: // IOleObject::InitFromData method
384:
385: STDMETHODIMP SvrDoc_OleObj_InitFromData(
386: LPOLEOBJECT lpThis,
387: LPDATAOBJECT lpDataObject,
388: BOOL fCreation,
389: DWORD reserved
390: )
391: {
392: LPSERVERDOC lpServerDoc =
393: ((struct CDocOleObjectImpl FAR*)lpThis)->lpServerDoc;
394:
395: OLEDBG_BEGIN2("SvrDoc_OleObj_InitFromData\r\n")
396:
397: // REVIEW: NOT YET IMPLEMENTED
398:
399: OLEDBG_END2
400: return ResultFromScode(E_NOTIMPL);
401: }
402:
403:
404: // IOleObject::GetClipboardData method
405:
406: STDMETHODIMP SvrDoc_OleObj_GetClipboardData(
407: LPOLEOBJECT lpThis,
408: DWORD reserved,
409: LPDATAOBJECT FAR* lplpDataObject
410: )
411: {
412: LPSERVERDOC lpServerDoc =
413: ((struct CDocOleObjectImpl FAR*)lpThis)->lpServerDoc;
414:
415: OLEDBG_BEGIN2("SvrDoc_OleObj_GetClipboardData\r\n")
416:
417: // REVIEW: NOT YET IMPLEMENTED
418:
419: OLEDBG_END2
420: return ResultFromScode(E_NOTIMPL);
421: }
422:
423:
424: // IOleObject::DoVerb method
425:
426: STDMETHODIMP SvrDoc_OleObj_DoVerb(
427: LPOLEOBJECT lpThis,
428: LONG lVerb,
429: LPMSG lpmsg,
430: LPOLECLIENTSITE lpActiveSite,
431: LONG lindex,
432: HWND hwndParent,
433: LPCRECT lprcPosRect
434: )
435: {
436: LPSERVERDOC lpServerDoc =
437: ((struct CDocOleObjectImpl FAR*)lpThis)->lpServerDoc;
438: LPOUTLINEDOC lpOutlineDoc = (LPOUTLINEDOC)lpServerDoc;
439: SCODE sc = S_OK;
440:
441: OLEDBG_BEGIN2("SvrDoc_OleObj_DoVerb\r\n")
442:
443: switch (lVerb) {
444:
445: default:
446: /* OLE2NOTE: when an unknown verb number is given, the
447: ** server must take careful action:
448: ** 1. if it is one of the specially defined OLEIVERB
449: ** (negative numbered) verbs, the app should return an
450: ** error (E_NOTIMPL) and perform no action.
451: **
452: ** 2. if the verb is a application specific verb
453: ** (positive numbered verb), then the app should
454: ** return the special scode (OLEOBJ_S_INVALIDVERB). BUT,
455: ** we should still perform our normal primary verb action.
456: */
457: if (lVerb < 0) {
458: OLEDBG_END2
459: return ResultFromScode(E_NOTIMPL);
460: } else {
461: sc = OLEOBJ_S_INVALIDVERB;
462: }
463:
464: // deliberatly fall through to Primary Verb
465:
466: case 0:
467: case OLEIVERB_SHOW:
468:
469: #if defined( INPLACE_SVR )
470: /* OLE2NOTE: if our window is already open (visible) then
471: ** we should simply surface the open window. if not,
472: ** then we can do our primary action of in-place
473: ** activation.
474: */
475: if ( lpServerDoc->m_lpOleClientSite
476: && ! (IsWindowVisible(lpOutlineDoc->m_hWndDoc) &&
477: ! lpServerDoc->m_fInPlaceActive) ) {
478: ServerDoc_DoInPlaceActivate(
479: lpServerDoc, lVerb, lpmsg, lpActiveSite);
480: }
481: #endif // INPLACE_SVR
482:
483: OutlineDoc_ShowWindow(lpOutlineDoc);
484: break;
485:
486: case 1:
487: case OLEIVERB_OPEN:
488: #if defined( INPLACE_SVR )
489: ServerDoc_DoInPlaceDeactivate(lpServerDoc);
490: #endif // INPLACE_SVR
491: OutlineDoc_ShowWindow(lpOutlineDoc);
492: break;
493:
494:
495: case OLEIVERB_HIDE:
496: #if defined( INPLACE_SVR )
497: if (lpServerDoc->m_fInPlaceActive) {
498:
499: SvrDoc_IPObj_UIDeactivate(
500: (LPOLEINPLACEOBJECT)&lpServerDoc->m_OleInPlaceObject);
501:
502: #if defined( SVR_INSIDEOUT )
503: /* OLE2NOTE: an inside-out style in-place server will
504: ** NOT hide its window in UIDeactive (an outside-in
505: ** style object will hide its window in
506: ** UIDeactivate). thus we need to explicitly hide
507: ** our window now.
508: */
509: ServerDoc_DoInPlaceHide(lpServerDoc);
510: #endif // INSIEDOUT
511:
512: } else {
513: OleDoc_HideWindow((LPOLEDOC)lpServerDoc, FALSE /*fShutdown*/);
514: }
515: #endif // INPLACE_SVR
516: break;
517:
518: #if defined( INPLACE_SVR )
519: case OLEIVERB_UIACTIVATE:
520:
521: #if defined( SVR_INSIDEOUT )
522: /* OLE2NOTE: only an inside-out style object supports
523: ** INPLACEACTIVATE verb
524: */
525: case OLEIVERB_INPLACEACTIVATE:
526: #endif // INSIEDOUT
527: /* OLE2NOTE: if our window is already open (visible) then
528: ** we can NOT activate in-place.
529: */
530: if (IsWindowVisible(lpOutlineDoc->m_hWndDoc) &&
531: ! lpServerDoc->m_fInPlaceActive ) {
532: sc = OLE_E_NOT_INPLACEACTIVE;
533: } else {
534: sc = GetScode( ServerDoc_DoInPlaceActivate(
535: lpServerDoc, lVerb, lpmsg, lpActiveSite) );
536: if (SUCCEEDED(sc))
537: OutlineDoc_ShowWindow(lpOutlineDoc);
538: }
539: break;
540: #endif // INPLACE_SVR
541: }
542:
543: OLEDBG_END2
544: return ResultFromScode(sc);
545: }
546:
547:
548: // IOleObject::EnumVerbs method
549:
550: STDMETHODIMP SvrDoc_OleObj_EnumVerbs(
551: LPOLEOBJECT lpThis,
552: LPENUMOLEVERB FAR* lplpenumOleVerb
553: )
554: {
555: OleDbgOut2("SvrDoc_OleObj_EnumVerbs\r\n");
556:
557: /* OLE2NOTE: we must make sure to set all out parameters to NULL. */
558: *lplpenumOleVerb = NULL;
559:
560: // Tell OLE to enumerate our verbs using the REGDB
561: return ResultFromScode(OLE_S_USEREG);
562: }
563:
564:
565: // IOleObject::Update method
566:
567: STDMETHODIMP SvrDoc_OleObj_Update(LPOLEOBJECT lpThis)
568: {
569: OleDbgOut2("SvrDoc_OleObj_Update\r\n");
570:
571: /* OLE2NOTE: a server-only app is always "up-to-date".
572: ** a container-app which contains links where the link source
573: ** has changed since the last update of the link would be
574: ** considered "out-of-date". the "Update" method instructs the
575: ** object to get an update from any out-of-date links.
576: */
577:
578: return NOERROR;
579: }
580:
581:
582: // IOleObject::IsUpToDate method
583:
584: STDMETHODIMP SvrDoc_OleObj_IsUpToDate(LPOLEOBJECT lpThis)
585: {
586: OleDbgOut2("SvrDoc_OleObj_IsUpToDate\r\n");
587:
588: /* OLE2NOTE: a server-only app is always "up-to-date".
589: ** a container-app which contains links where the link source
590: ** has changed since the last update of the link would be
591: ** considered "out-of-date".
592: */
593: return NOERROR;
594: }
595:
596:
597: // IOleObject::GetUserClassID method
598:
599: STDMETHODIMP SvrDoc_OleObj_GetUserClassID(
600: LPOLEOBJECT lpThis,
601: LPCLSID lpClassID
602: )
603: {
604: LPSERVERDOC lpServerDoc =
605: ((struct CDocOleObjectImpl FAR*)lpThis)->lpServerDoc;
606:
607: OleDbgOut2("SvrDoc_OleObj_GetClassID\r\n");
608:
609: /* OLE2NOTE: we must be carefull to return the correct CLSID here.
610: ** if we are currently preforming a "TreatAs (aka. ActivateAs)"
611: ** operation then we need to return the class of the object
612: ** written in the storage of the object. otherwise we would
613: ** return our own class id.
614: */
615: return ServerDoc_GetClassID(lpServerDoc, lpClassID);
616: }
617:
618:
619: // IOleObject::GetUserType method
620:
621: STDMETHODIMP SvrDoc_OleObj_GetUserType(
622: LPOLEOBJECT lpThis,
623: DWORD dwFormOfType,
624: LPSTR FAR* lpszUserType
625: )
626: {
627: OleDbgOut2("SvrDoc_OleObj_GetUserType\r\n");
628:
629: /* OLE2NOTE: we must make sure to set all out parameters to NULL. */
630: *lpszUserType = NULL;
631:
632: // Tell OLE to enumerate our verbs using the REGDB
633: return ResultFromScode(OLE_S_USEREG);
634:
635: #if defined( LATER )
636: LPSERVERDOC lpServerDoc =
637: ((struct CDocOleObjectImpl FAR*)lpThis)->lpServerDoc;
638:
639: /* OLE2NOTE: we must be carefull to return the correct UserType here.
640: ** if we are currently preforming a "TreatAs (aka. ActivateAs)"
641: ** operation then we need to return the UserType of the object
642: ** written in the storage of the object. otherwise we would
643: ** return our own UserType.
644: */
645: return ServerDoc_GetUserType(lpServerDoc, dwFormOfType, lpszUserType);
646: #endif
647: }
648:
649:
650: // IOleObject::SetExtent method
651:
652: STDMETHODIMP SvrDoc_OleObj_SetExtent(
653: LPOLEOBJECT lpThis,
654: DWORD dwDrawAspect,
655: LPSIZEL lplgrc
656: )
657: {
658: OleDbgOut2("SvrDoc_OleObj_SetExtent\r\n");
659:
660: /* SVROUTL does NOT allow the object's size to be set by its
661: ** container. the size of the ServerDoc object is determined by
662: ** the data contained within the document.
663: */
664: return ResultFromScode(S_FALSE);
665: }
666:
667:
668: // IOleObject::GetExtent method
669:
670: STDMETHODIMP SvrDoc_OleObj_GetExtent(
671: LPOLEOBJECT lpThis,
672: DWORD dwDrawAspect,
673: LPSIZEL lpsizel
674: )
675: {
676: LPOLEDOC lpOleDoc =
677: (LPOLEDOC)((struct CDocOleObjectImpl FAR*)lpThis)->lpServerDoc;
678:
679: OleDbgOut2("SvrDoc_OleObj_GetExtent\r\n");
680:
681: if (dwDrawAspect == DVASPECT_CONTENT
682: || dwDrawAspect == DVASPECT_THUMBNAIL
683: || dwDrawAspect == DVASPECT_DOCPRINT)
684: {
685: OleDoc_GetExtent(lpOleDoc, lpsizel);
686: return NOERROR;
687: }
688:
689: #if defined( LATER )
690:
691: else if (dwDrawAspect == DVASPECT_THUMBNAIL)
692: {
693: /* as our thumbnail we will render only the first page of the
694: ** document. calculate extents of our thumbnail rendering.
695: **
696: ** OLE2NOTE: thumbnails are most often used by applications in
697: ** FindFile or FileOpen type dialogs to give the user a
698: ** quick view of the contents of the file or object.
699: */
700: OleDoc_GetThumbnailExtent(lpOleDoc, lpsizel);
701: return NOERROR;
702: }
703: #endif
704:
705: else
706: {
707: return ResultFromScode(E_INVALIDARG);
708: }
709: }
710:
711:
712: // IOleObject::Advise method
713:
714: STDMETHODIMP SvrDoc_OleObj_Advise(
715: LPOLEOBJECT lpThis,
716: LPADVISESINK lpAdvSink,
717: LPDWORD lpdwConnection
718: )
719: {
720: LPSERVERDOC lpServerDoc =
721: ((struct CDocOleObjectImpl FAR*)lpThis)->lpServerDoc;
722: HRESULT hrErr;
723: SCODE sc;
724:
725: OLEDBG_BEGIN2("SvrDoc_OleObj_Advise\r\n");
726:
727: if (lpServerDoc->m_lpOleAdviseHldr == NULL &&
728: CreateOleAdviseHolder(&lpServerDoc->m_lpOleAdviseHldr) != NOERROR) {
729: sc = E_OUTOFMEMORY;
730: goto error;
731: }
732:
733: OLEDBG_BEGIN2("IOleAdviseHolder::Advise called\r\n")
734: hrErr = lpServerDoc->m_lpOleAdviseHldr->lpVtbl->Advise(
735: lpServerDoc->m_lpOleAdviseHldr,
736: lpAdvSink,
737: lpdwConnection
738: );
739: OLEDBG_END2
740:
741: OLEDBG_END2
742: return hrErr;
743:
744: error:
745: OLEDBG_END2
746: return ResultFromScode(sc);
747: }
748:
749:
750: // IOleObject::Unadvise method
751:
752: STDMETHODIMP SvrDoc_OleObj_Unadvise(LPOLEOBJECT lpThis, DWORD dwConnection)
753: {
754: LPSERVERDOC lpServerDoc =
755: ((struct CDocOleObjectImpl FAR*)lpThis)->lpServerDoc;
756: HRESULT hrErr;
757: SCODE sc;
758:
759: OLEDBG_BEGIN2("SvrDoc_OleObj_Unadvise\r\n");
760:
761: if (lpServerDoc->m_lpOleAdviseHldr == NULL) {
762: sc = E_FAIL;
763: goto error;
764: }
765:
766: OLEDBG_BEGIN2("IOleAdviseHolder::Unadvise called\r\n")
767: hrErr = lpServerDoc->m_lpOleAdviseHldr->lpVtbl->Unadvise(
768: lpServerDoc->m_lpOleAdviseHldr,
769: dwConnection
770: );
771: OLEDBG_END2
772:
773: OLEDBG_END2
774: return hrErr;
775:
776: error:
777: OLEDBG_END2
778: return ResultFromScode(sc);
779: }
780:
781:
782: // IOleObject::EnumAdvise method
783:
784: STDMETHODIMP SvrDoc_OleObj_EnumAdvise(
785: LPOLEOBJECT lpThis,
786: LPENUMSTATDATA FAR* lplpenumAdvise
787: )
788: {
789: LPSERVERDOC lpServerDoc =
790: ((struct CDocOleObjectImpl FAR*)lpThis)->lpServerDoc;
791: HRESULT hrErr;
792: SCODE sc;
793:
794: OLEDBG_BEGIN2("SvrDoc_OleObj_EnumAdvise\r\n");
795:
796: /* OLE2NOTE: we must make sure to set all out parameters to NULL. */
797: *lplpenumAdvise = NULL;
798:
799: if (lpServerDoc->m_lpOleAdviseHldr == NULL) {
800: sc = E_FAIL;
801: goto error;
802: }
803:
804: OLEDBG_BEGIN2("IOleAdviseHolder::EnumAdvise called\r\n")
805: hrErr = lpServerDoc->m_lpOleAdviseHldr->lpVtbl->EnumAdvise(
806: lpServerDoc->m_lpOleAdviseHldr,
807: lplpenumAdvise
808: );
809: OLEDBG_END2
810:
811: OLEDBG_END2
812: return hrErr;
813:
814: error:
815: OLEDBG_END2
816: return ResultFromScode(sc);
817: }
818:
819:
820: // IOleObject::GetMiscStatus method
821:
822: STDMETHODIMP SvrDoc_OleObj_GetMiscStatus(
823: LPOLEOBJECT lpThis,
824: DWORD dwAspect,
825: DWORD FAR* lpdwStatus
826: )
827: {
828: LPSERVERDOC lpServerDoc =
829: ((struct CDocOleObjectImpl FAR*)lpThis)->lpServerDoc;
830: LPOUTLINEDOC lpOutlineDoc = (LPOUTLINEDOC)lpServerDoc;
831:
832: OleDbgOut2("SvrDoc_OleObj_GetMiscStatus\r\n");
833:
834: *lpdwStatus = 0;
835:
836: /* OLE2NOTE: check if the data copied is compatible to be
837: ** linked by an OLE 1.0 container. it is compatible if
838: ** either the data is an untitled document, a file, or a
839: ** selection of data within a file. if the data is part of
840: ** an embedded object, then it is NOT compatible to be
841: ** linked by an OLE 1.0 container. if it is compatible then
842: ** we must include OLEMISC_CANLINKBYOLE1 as part of the
843: ** dwStatus flags transfered via CF_OBJECTDESCRIPTOR or
844: ** CF_LINKSRCDESCRIPTOR.
845: */
846: if (lpOutlineDoc->m_docInitType == DOCTYPE_NEW ||
847: lpOutlineDoc->m_docInitType == DOCTYPE_FROMFILE)
848: *lpdwStatus |= OLEMISC_CANLINKBYOLE1;
849:
850: #if defined( INPLACE_SVR )
851: if (dwAspect == DVASPECT_CONTENT)
852: *lpdwStatus |= (OLEMISC_INSIDEOUT | OLEMISC_ACTIVATEWHENVISIBLE);
853: #endif // INPLACE_SVR
854:
855: return NOERROR;
856: }
857:
858:
859: // IOleObject::SetColorScheme method
860:
861: STDMETHODIMP SvrDoc_OleObj_SetColorScheme(
862: LPOLEOBJECT lpThis,
863: LPLOGPALETTE lpLogpal
864: )
865: {
866: OleDbgOut2("SvrDoc_OleObj_SetColorScheme\r\n");
867:
868: // REVIEW: NOT YET IMPLEMENTED
869:
870: return ResultFromScode(E_NOTIMPL);
871: }
872:
873:
874: /*************************************************************************
875: ** ServerDoc::IPersistStorage interface implementation
876: *************************************************************************/
877:
878: // IPersistStorage::QueryInterface method
879:
880: STDMETHODIMP SvrDoc_PStg_QueryInterface(
881: LPPERSISTSTORAGE lpThis,
882: REFIID riid,
883: LPVOID FAR* lplpvObj
884: )
885: {
886: LPSERVERDOC lpServerDoc =
887: ((struct CDocPersistStorageImpl FAR*)lpThis)->lpServerDoc;
888:
889: return OleDoc_QueryInterface((LPOLEDOC)lpServerDoc, riid, lplpvObj);
890: }
891:
892:
893: // IPersistStorage::AddRef method
894:
895: STDMETHODIMP_(ULONG) SvrDoc_PStg_AddRef(LPPERSISTSTORAGE lpThis)
896: {
897: LPSERVERDOC lpServerDoc =
898: ((struct CDocPersistStorageImpl FAR*)lpThis)->lpServerDoc;
899:
900: OleDbgAddRefMethod(lpThis, "IPersistStorage");
901:
902: return OleDoc_AddRef((LPOLEDOC)lpServerDoc);
903: }
904:
905:
906: // IPersistStorage::Release method
907:
908: STDMETHODIMP_(ULONG) SvrDoc_PStg_Release(LPPERSISTSTORAGE lpThis)
909: {
910: LPSERVERDOC lpServerDoc =
911: ((struct CDocPersistStorageImpl FAR*)lpThis)->lpServerDoc;
912:
913: OleDbgReleaseMethod(lpThis, "IPersistStorage");
914:
915: return OleDoc_Release((LPOLEDOC)lpServerDoc);
916: }
917:
918:
919: // IPersistStorage::GetClassID method
920:
921: STDMETHODIMP SvrDoc_PStg_GetClassID(
922: LPPERSISTSTORAGE lpThis,
923: LPCLSID lpClassID
924: )
925: {
926: LPSERVERDOC lpServerDoc =
927: ((struct CDocPersistStorageImpl FAR*)lpThis)->lpServerDoc;
928:
929: OleDbgOut2("SvrDoc_PStg_GetClassID\r\n");
930:
931: /* OLE2NOTE: we must be carefull to return the correct CLSID here.
932: ** if we are currently preforming a "TreatAs (aka. ActivateAs)"
933: ** operation then we need to return the class of the object
934: ** written in the storage of the object. otherwise we would
935: ** return our own class id.
936: */
937: return ServerDoc_GetClassID(lpServerDoc, lpClassID);
938: }
939:
940:
941: // IPersistStorage::IsDirty method
942:
943: STDMETHODIMP SvrDoc_PStg_IsDirty(LPPERSISTSTORAGE lpThis)
944: {
945: LPSERVERDOC lpServerDoc =
946: ((struct CDocPersistStorageImpl FAR*)lpThis)->lpServerDoc;
947:
948: OleDbgOut2("SvrDoc_PStg_IsDirty\r\n");
949:
950: if (OutlineDoc_IsModified((LPOUTLINEDOC)lpServerDoc))
951: return NOERROR;
952: else
953: return ResultFromScode(S_FALSE);
954: }
955:
956:
957:
958: // IPersistStorage::InitNew method
959:
960: STDMETHODIMP SvrDoc_PStg_InitNew(
961: LPPERSISTSTORAGE lpThis,
962: LPSTORAGE lpStg
963: )
964: {
965: LPSERVERDOC lpServerDoc =
966: ((struct CDocPersistStorageImpl FAR*)lpThis)->lpServerDoc;
967: SCODE sc;
968:
969: OLEDBG_BEGIN2("SvrDoc_PStg_InitNew\r\n")
970:
971: #if defined( SVR_TREATAS )
972: {
973: LPOUTLINEAPP lpOutlineApp = (LPOUTLINEAPP)g_lpApp;
974: CLSID clsid;
975: CLIPFORMAT cfFmt;
976: LPSTR lpszType;
977:
978: /* OLE2NOTE: if the Server is capable of supporting "TreatAs"
979: ** (aka. ActivateAs), it must read the class that is written
980: ** into the storage. if this class is NOT the app's own
981: ** class ID, then this is a TreatAs operation. the server
982: ** then must faithfully pretend to be the class that is
983: ** written into the storage. it must also faithfully write
984: ** the data back to the storage in the SAME format as is
985: ** written in the storage.
986: **
987: ** SVROUTL and ISVROTL can emulate each other. they have the
988: ** simplification that they both read/write the identical
989: ** format. thus for these apps no actual conversion of the
990: ** native bits is actually required.
991: */
992: lpServerDoc->m_clsidTreatAs = CLSID_NULL;
993: if (OleStdGetTreatAsFmtUserType(&CLSID_APP, lpStg, &clsid,
994: (CLIPFORMAT FAR*)&cfFmt, (LPSTR FAR*)&lpszType)) {
995:
996: if (cfFmt == lpOutlineApp->m_cfOutline) {
997: // We should perform TreatAs operation
998: if (lpServerDoc->m_lpszTreatAsType)
999: OleStdFreeString(lpServerDoc->m_lpszTreatAsType, NULL);
1000:
1001: lpServerDoc->m_clsidTreatAs = clsid;
1002: ((LPOUTLINEDOC)lpServerDoc)->m_cfSaveFormat = cfFmt;
1003: lpServerDoc->m_lpszTreatAsType = lpszType;
1004:
1005: OleDbgOut3("SvrDoc_PStg_InitNew: TreateAs ==> '");
1006: OleDbgOutNoPrefix3(lpServerDoc->m_lpszTreatAsType);
1007: OleDbgOutNoPrefix3("'\r\n");
1008: } else {
1009: // ERROR: we ONLY support TreatAs for CF_OUTLINE format
1010: OleDbgOut("SvrDoc_PStg_InitNew: INVALID TreatAs Format\r\n");
1011: OleStdFreeString(lpszType, NULL);
1012: }
1013: }
1014: }
1015: #endif // SVR_TREATAS
1016:
1017: // set the doc to a new embedded object.
1018: if (! ServerDoc_InitNewEmbed(lpServerDoc)) {
1019: sc = E_FAIL;
1020: goto error;
1021: }
1022:
1023: lpServerDoc->m_dwStorageMode = STGMODE_NORMAL;
1024:
1025: OLEDBG_END2
1026: return NOERROR;
1027:
1028: error:
1029: OLEDBG_END2
1030: return ResultFromScode(sc);
1031: }
1032:
1033:
1034: // IPersistStorage::Load method
1035:
1036: STDMETHODIMP SvrDoc_PStg_Load(
1037: LPPERSISTSTORAGE lpThis,
1038: LPSTORAGE lpStg
1039: )
1040: {
1041: LPSERVERDOC lpServerDoc =
1042: ((struct CDocPersistStorageImpl FAR*)lpThis)->lpServerDoc;
1043: LPOUTLINEDOC lpOutlineDoc = (LPOUTLINEDOC)lpServerDoc;
1044: SCODE sc;
1045:
1046: OLEDBG_BEGIN2("SvrDoc_PStg_Load\r\n")
1047:
1048: if (OutlineDoc_LoadFromStg((LPOUTLINEDOC)lpServerDoc, lpStg)) {
1049:
1050: ((LPOUTLINEDOC)lpServerDoc)->m_docInitType = DOCTYPE_EMBEDDED;
1051:
1052: lpServerDoc->m_dwStorageMode = STGMODE_NORMAL;
1053:
1054: /* OLE2NOTE: we need to check if the ConvertStg bit is on. if
1055: ** so, we need to clear the ConvertStg bit and mark the
1056: ** document as dirty so as to force a save when the document
1057: ** is closed. the actual conversion of the bits should be
1058: ** performed when the data is loaded from the IStorage*. in
1059: ** our case any conversion of data formats would be done in
1060: ** OutlineDoc_LoadFromStg function. in reality both SVROUTL
1061: ** and ISVROTL read and write the same format so no actual
1062: ** conversion of data bits is necessary.
1063: */
1064: if (GetConvertStg(lpStg) == NOERROR) {
1065: SetConvertStg(lpStg, FALSE);
1066:
1067: OleDbgOut3("SvrDoc_PStg_Load: ConvertStg==TRUE\r\n");
1068: OutlineDoc_SetModified(lpOutlineDoc, TRUE, FALSE, FALSE);
1069: }
1070:
1071: } else {
1072: sc = E_FAIL;
1073: goto error;
1074: }
1075:
1076: OLEDBG_END2
1077: return NOERROR;
1078:
1079: error:
1080: OLEDBG_END2
1081: return ResultFromScode(sc);
1082: }
1083:
1084:
1085: // IPersistStorage::Save method
1086:
1087: STDMETHODIMP SvrDoc_PStg_Save(
1088: LPPERSISTSTORAGE lpThis,
1089: LPSTORAGE lpStg,
1090: BOOL fSameAsLoad
1091: )
1092: {
1093: LPSERVERDOC lpServerDoc =
1094: ((struct CDocPersistStorageImpl FAR*)lpThis)->lpServerDoc;
1095: LPOUTLINEDOC lpOutlineDoc = (LPOUTLINEDOC)lpServerDoc;
1096: BOOL fStatus;
1097: SCODE sc;
1098:
1099: OLEDBG_BEGIN2("SvrDoc_PStg_Save\r\n")
1100:
1101: fStatus = OutlineDoc_SaveSelToStg(
1102: (LPOUTLINEDOC)lpServerDoc,
1103: NULL,
1104: lpOutlineDoc->m_cfSaveFormat,
1105: lpStg,
1106: FALSE
1107: );
1108:
1109: lpServerDoc->m_fSaveWithSameAsLoad = fSameAsLoad;
1110:
1111: if (! fStatus) {
1112: OutlineApp_ErrorMessage(g_lpApp, ErrMsgPSSaveFail);
1113: sc = E_FAIL;
1114: goto error;
1115: }
1116:
1117: lpServerDoc->m_dwStorageMode = STGMODE_NOSCRIBBLE;
1118: OLEDBG_END2
1119: return NOERROR;
1120:
1121: error:
1122: OLEDBG_END2
1123: return ResultFromScode(sc);
1124: }
1125:
1126:
1127:
1128: // IPersistStorage::SaveCompleted method
1129:
1130: STDMETHODIMP SvrDoc_PStg_SaveCompleted(
1131: LPPERSISTSTORAGE lpThis,
1132: LPSTORAGE lpStgNew
1133: )
1134: {
1135: LPSERVERDOC lpServerDoc =
1136: ((struct CDocPersistStorageImpl FAR*)lpThis)->lpServerDoc;
1137: LPOUTLINEDOC lpOutlineDoc = (LPOUTLINEDOC)lpServerDoc;
1138:
1139: OLEDBG_BEGIN2("SvrDoc_PStg_SaveCompleted\r\n")
1140:
1141: /* OLE2NOTE: because we are a pure server that loads all data into
1142: ** memory, we do not hold on to our storage. thus we do not have
1143: ** to remember the storage passed into SaveCompleted.
1144: ** a container/server application must hold on to its storage
1145: ** however. any application that holds onto its storage must now
1146: ** remember the storage if one is passed in. in addition a
1147: ** container/server application would have to call SaveCompleted
1148: ** for each of its contained compound document objects. if a new
1149: ** storage was given, then the container/server would have to
1150: ** open the corresponding new sub-storage for each compound
1151: ** document object and pass as an argument in the SaveCompleted
1152: ** call.
1153: */
1154:
1155: lpServerDoc->m_dwStorageMode = STGMODE_NORMAL;
1156:
1157: /* OLE2NOTE: it is only legal to perform a Save or SaveAs operation
1158: ** on an embedded object. if the document is a file-based document
1159: ** then we can not be changed to a IStorage-base object.
1160: **
1161: ** fSameAsLoad lpStgNew Type of Save Send OnSave
1162: ** ---------------------------------------------------------
1163: ** TRUE NULL SAVE YES
1164: ** TRUE ! NULL SAVE * YES
1165: ** FALSE ! NULL SAVE AS YES
1166: ** FALSE NULL SAVE COPY AS NO
1167: **
1168: ** * this is a strange case that is possible. it is inefficient
1169: ** for the caller; it would be better to pass lpStgNew==NULL for
1170: ** the Save operation.
1171: */
1172: if ( ((lpServerDoc->m_fSaveWithSameAsLoad && lpStgNew==NULL) || lpStgNew)
1173: && (lpOutlineDoc->m_docInitType != DOCTYPE_EMBEDDED) ) {
1174: OLEDBG_END2
1175: return ResultFromScode(E_INVALIDARG);
1176: }
1177:
1178: /* OLE2NOTE: inform any linking clients that the document has been
1179: ** saved. in addition, any currently active pseudo objects
1180: ** should also inform their clients. we should only broadcast an
1181: ** OnSave notification if a Save or SaveAs operation was
1182: ** performed. we do NOT want to send the notification if a
1183: ** SaveCopyAs operation was performed.
1184: */
1185: if ((lpServerDoc->m_fSaveWithSameAsLoad && lpStgNew==NULL) || lpStgNew) {
1186:
1187: // Clear dirty flag upon save or saveAs
1188: OutlineDoc_SetModified(lpOutlineDoc, FALSE, FALSE, FALSE);
1189:
1190: ServerDoc_SendAdvise (
1191: lpServerDoc,
1192: OLE_ONSAVE,
1193: NULL, /* lpmkDoc -- not relevant here */
1194: 0 /* advf -- not relevant here */
1195: );
1196: }
1197: OLEDBG_END2
1198: return NOERROR;
1199: }
1200:
1201:
1202: // IPersistStorage::HandsOffStorage method
1203:
1204: STDMETHODIMP SvrDoc_PStg_HandsOffStorage(LPPERSISTSTORAGE lpThis)
1205: {
1206: LPSERVERDOC lpServerDoc =
1207: ((struct CDocPersistStorageImpl FAR*)lpThis)->lpServerDoc;
1208:
1209: OLEDBG_BEGIN2("SvrDoc_PStg_HandsOffStorage\r\n")
1210:
1211: /* OLE2NOTE: because we are a pure server that loads all data into
1212: ** memory, we do not hold on to our storage. thus we do not have
1213: ** a storage to release (ie. to enter HandsOff Mode).
1214: ** a container/server application must hold on to its storage
1215: ** however. any application that holds onto its storage must now
1216: ** release its storage. when SaveCompleted is called, then a new
1217: ** storage will be given.
1218: */
1219:
1220: lpServerDoc->m_dwStorageMode = STGMODE_HANDSOFF;
1221:
1222: OLEDBG_END2
1223: return NOERROR;
1224: }
1225:
1226:
1227:
1228: #if defined( SVR_TREATAS )
1229:
1230: /*************************************************************************
1231: ** ServerDoc::IStdMarshalInfo interface implementation
1232: *************************************************************************/
1233:
1234: // IStdMarshalInfo::QueryInterface method
1235:
1236: STDMETHODIMP SvrDoc_StdMshl_QueryInterface(
1237: LPSTDMARSHALINFO lpThis,
1238: REFIID riid,
1239: LPVOID FAR* lplpvObj
1240: )
1241: {
1242: LPSERVERDOC lpServerDoc =
1243: ((struct CDocStdMarshalInfoImpl FAR*)lpThis)->lpServerDoc;
1244:
1245: return OleDoc_QueryInterface((LPOLEDOC)lpServerDoc, riid, lplpvObj);
1246: }
1247:
1248:
1249: // IStdMarshalInfo::AddRef method
1250:
1251: STDMETHODIMP_(ULONG) SvrDoc_StdMshl_AddRef(LPSTDMARSHALINFO lpThis)
1252: {
1253: LPSERVERDOC lpServerDoc =
1254: ((struct CDocStdMarshalInfoImpl FAR*)lpThis)->lpServerDoc;
1255:
1256: OleDbgAddRefMethod(lpThis, "IStdMarshalInfo");
1257:
1258: return OleDoc_AddRef((LPOLEDOC)lpServerDoc);
1259: }
1260:
1261:
1262: // IStdMarshalInfo::Release method
1263:
1264: STDMETHODIMP_(ULONG) SvrDoc_StdMshl_Release(LPSTDMARSHALINFO lpThis)
1265: {
1266: LPSERVERDOC lpServerDoc =
1267: ((struct CDocStdMarshalInfoImpl FAR*)lpThis)->lpServerDoc;
1268:
1269: OleDbgReleaseMethod(lpThis, "IStdMarshalInfo");
1270:
1271: return OleDoc_Release((LPOLEDOC)lpServerDoc);
1272: }
1273:
1274:
1275: // IStdMarshalInfo::GetClassForHandler
1276:
1277: STDMETHODIMP SvrDoc_StdMshl_GetClassForHandler(
1278: LPSTDMARSHALINFO lpThis,
1279: DWORD dwDestContext,
1280: LPVOID pvDestContext,
1281: LPCLSID lpClassID
1282: )
1283: {
1284: LPSERVERDOC lpServerDoc =
1285: ((struct CDocStdMarshalInfoImpl FAR*)lpThis)->lpServerDoc;
1286:
1287: OleDbgOut2("SvrDoc_StdMshl_GetClassForHandler\r\n");
1288:
1289: // OLE2NOTE: we only handle LOCAL marshal context.
1290: if (dwDestContext != MSHCTX_LOCAL || pvDestContext != NULL)
1291: return ResultFromScode(E_INVALIDARG);
1292:
1293: /* OLE2NOTE: we must return our REAL clsid, NOT the clsid that we
1294: ** are pretending to be if a "TreatAs" is in effect.
1295: */
1296: *lpClassID = CLSID_APP;
1297: return NOERROR;
1298: }
1299: #endif // SVR_TREATAS
1300:
1301:
1302:
1303: /*************************************************************************
1304: ** ServerDoc Support Functions
1305: *************************************************************************/
1306:
1307:
1308: /* ServerDoc_Init
1309: * --------------
1310: *
1311: * Initialize the fields of a new ServerDoc object. The object is initially
1312: * not associated with a file or an (Untitled) document. This function sets
1313: * the docInitType to DOCTYPE_UNKNOWN. After calling this function the
1314: * caller should call:
1315: * 1.) OutlineDoc_InitNewFile to set the ServerDoc to (Untitled)
1316: * 2.) OutlineDoc_LoadFromFile to associate the ServerDoc with a file.
1317: * This function creates a new window for the document.
1318: *
1319: * NOTE: the window is initially created with a NIL size. it must be
1320: * sized and positioned by the caller. also the document is initially
1321: * created invisible. the caller must call OutlineDoc_ShowWindow
1322: * after sizing it to make the document window visible.
1323: */
1324: BOOL ServerDoc_Init(LPSERVERDOC lpServerDoc, BOOL fDataTransferDoc)
1325: {
1326: lpServerDoc->m_cPseudoObj = 0;
1327: lpServerDoc->m_lpOleClientSite = NULL;
1328: lpServerDoc->m_lpOleAdviseHldr = NULL;
1329: lpServerDoc->m_lpDataAdviseHldr = NULL;
1330:
1331: // initialy doc does not have any storage
1332: lpServerDoc->m_dwStorageMode = STGMODE_HANDSOFF;
1333: lpServerDoc->m_fSaveWithSameAsLoad = FALSE;
1334: lpServerDoc->m_szContainerApp[0] = '\0';
1335: lpServerDoc->m_szContainerObj[0] = '\0';
1336: lpServerDoc->m_nNextRangeNo = 0L;
1337: lpServerDoc->m_lrSrcSelOfCopy.m_nStartLine = -1;
1338: lpServerDoc->m_lrSrcSelOfCopy.m_nEndLine = -1;
1339: lpServerDoc->m_fDataChanged = FALSE;
1340: lpServerDoc->m_fSizeChanged = FALSE;
1341: lpServerDoc->m_fSendDataOnStop = FALSE;
1342:
1343: #if defined( SVR_TREATAS )
1344: lpServerDoc->m_clsidTreatAs = CLSID_NULL;
1345: lpServerDoc->m_lpszTreatAsType = NULL;
1346: #endif // SVR_TREATAS
1347:
1348: #if defined( INPLACE_SVR )
1349: lpServerDoc->m_hWndHatch =
1350: CreateHatchWindow(
1351: OutlineApp_GetWindow(g_lpApp),
1352: OutlineApp_GetInstance(g_lpApp)
1353: );
1354: if (!lpServerDoc->m_hWndHatch)
1355: return FALSE;
1356:
1357: lpServerDoc->m_fInPlaceActive = FALSE;
1358: lpServerDoc->m_fInPlaceVisible = FALSE;
1359: lpServerDoc->m_fUIActive = FALSE;
1360: lpServerDoc->m_lpIPData = NULL;
1361:
1362: INIT_INTERFACEIMPL(
1363: &lpServerDoc->m_OleInPlaceObject,
1364: &g_SvrDoc_OleInPlaceObjectVtbl,
1365: lpServerDoc
1366: );
1367: INIT_INTERFACEIMPL(
1368: &lpServerDoc->m_OleInPlaceActiveObject,
1369: &g_SvrDoc_OleInPlaceActiveObjectVtbl,
1370: lpServerDoc
1371: );
1372: #endif // INPLACE_SVR
1373:
1374: INIT_INTERFACEIMPL(
1375: &lpServerDoc->m_OleObject,
1376: &g_SvrDoc_OleObjectVtbl,
1377: lpServerDoc
1378: );
1379:
1380: INIT_INTERFACEIMPL(
1381: &lpServerDoc->m_PersistStorage,
1382: &g_SvrDoc_PersistStorageVtbl,
1383: lpServerDoc
1384: );
1385:
1386: #if defined( SVR_TREATAS )
1387:
1388: INIT_INTERFACEIMPL(
1389: &lpServerDoc->m_StdMarshalInfo,
1390: &g_SvrDoc_StdMarshalInfoVtbl,
1391: lpServerDoc
1392: );
1393: #endif // SVR_TREATAS
1394: return TRUE;
1395: }
1396:
1397:
1398: /* ServerDoc_InitNewEmbed
1399: * ----------------------
1400: *
1401: * Initialize the ServerDoc object to be a new embedded object document.
1402: * This function sets the docInitType to DOCTYPE_EMBED.
1403: */
1404: BOOL ServerDoc_InitNewEmbed(LPSERVERDOC lpServerDoc)
1405: {
1406: LPOUTLINEDOC lpOutlineDoc = (LPOUTLINEDOC)lpServerDoc;
1407:
1408: OleDbgAssert(lpOutlineDoc->m_docInitType == DOCTYPE_UNKNOWN);
1409:
1410: lpOutlineDoc->m_docInitType = DOCTYPE_EMBEDDED;
1411:
1412: /* The Window title for an embedded object is constructed as
1413: ** follows:
1414: ** <server app name> - <obj short type> in <cont. doc name>
1415: **
1416: ** here we construct the current document title portion of the
1417: ** name which follows the '-'. OutlineDoc_SetTitle prepends the
1418: ** "<server app name> - " to the document title.
1419: */
1420: // REVIEW: this string should be loaded from string resource
1421: wsprintf(lpOutlineDoc->m_szFileName, "%s in %s",
1422: (LPSTR)SHORTUSERTYPENAME,
1423: (LPSTR)DEFCONTAINERNAME);
1424: lpOutlineDoc->m_lpszDocTitle = lpOutlineDoc->m_szFileName;
1425:
1426:
1427: /* OLE2NOTE: an embedding should be marked as initially dirty so
1428: ** that on close we always call IOleClientSite::SaveObject.
1429: */
1430: OutlineDoc_SetModified(lpOutlineDoc, TRUE, FALSE, FALSE);
1431:
1432: OutlineDoc_SetTitle(lpOutlineDoc);
1433:
1434: return TRUE;
1435: }
1436:
1437:
1438: /* ServerDoc_SendAdvise
1439: * --------------------
1440: *
1441: * This function sends an advise notification on behalf of a specific
1442: * doc object to all its clients.
1443: */
1444: void ServerDoc_SendAdvise(
1445: LPSERVERDOC lpServerDoc,
1446: WORD wAdvise,
1447: LPMONIKER lpmkDoc,
1448: DWORD dwAdvf
1449: )
1450: {
1451: LPOUTLINEDOC lpOutlineDoc = (LPOUTLINEDOC)lpServerDoc;
1452: LPOLEDOC lpOleDoc = (LPOLEDOC)lpServerDoc;
1453:
1454: switch (wAdvise) {
1455:
1456: case OLE_ONDATACHANGE:
1457:
1458: // inform clients that the data of the object has changed
1459:
1460: if (lpOutlineDoc->m_nDisableDraw == 0) {
1461: /* drawing is currently enabled. inform clients that
1462: ** the data of the object has changed
1463: */
1464:
1465: lpServerDoc->m_fDataChanged = FALSE;
1466:
1467: if (lpServerDoc->m_lpDataAdviseHldr) {
1468: OLEDBG_BEGIN2(
1469: "IDataAdviseHolder::SendOnDataChange called\r\n"
1470: );
1471: lpServerDoc->m_lpDataAdviseHldr->lpVtbl->SendOnDataChange(
1472: lpServerDoc->m_lpDataAdviseHldr,
1473: (LPDATAOBJECT)&lpOleDoc->m_DataObject,
1474: 0,
1475: dwAdvf
1476: );
1477: OLEDBG_END2
1478:
1479: /* OLE2NOTE: we must note the time of last change
1480: ** for our object in the RunningObjectTable.
1481: ** this is used as the basis to answer
1482: ** IOleObject::IsUpToDate.
1483: */
1484: OleStdNoteObjectChangeTime(lpOleDoc->m_dwRegROT);
1485: }
1486:
1487: #if defined( INPLACE_SVR )
1488: /* OLE2NOTE: if the ServerDoc is currently in-place UI active,
1489: ** then is it important to renegotiate the size for the
1490: ** in-place document window BEFORE sending OnDataChange
1491: ** (which will cause the window to repaint).
1492: */
1493: if (lpServerDoc->m_fSizeChanged) {
1494: lpServerDoc->m_fSizeChanged = FALSE;
1495: if (lpServerDoc->m_fInPlaceActive)
1496: ServerDoc_UpdateInPlaceWindowOnExtentChange(lpServerDoc);
1497: }
1498: #endif
1499:
1500: /* OLE2NOTE: we do NOT need to tell our pseudo objects to
1501: ** broadcast OnDataChange notification because
1502: ** they will do it automatically when an editing
1503: ** change in the document affects a PseudoObj.
1504: ** (see OutlineNameTable_AddLineUpdate,
1505: ** OutlineNameTable_DeleteLineUpdate,
1506: ** and ServerNameTable_EditLineUpdate)
1507: */
1508:
1509: } else {
1510: /* drawing is currently disabled. do not send
1511: ** notifications or call
1512: ** IOleInPlaceObject::OnPosRectChange until drawing
1513: ** is re-enabled.
1514: */
1515: }
1516: break;
1517:
1518: case OLE_ONCLOSE:
1519:
1520: // inform clients that the document is shutting down
1521:
1522: if (lpServerDoc->m_lpOleAdviseHldr) {
1523: OLEDBG_BEGIN2("IOleAdviseHolder::SendOnClose called\r\n");
1524: lpServerDoc->m_lpOleAdviseHldr->lpVtbl->SendOnClose(
1525: lpServerDoc->m_lpOleAdviseHldr
1526: );
1527: OLEDBG_END2
1528: }
1529:
1530: /* OLE2NOTE: we do NOT need to tell our pseudo objects to
1531: ** broadcast OnClose notification because they will do
1532: ** it automatically when the pseudo object is closed.
1533: ** (see PseudoObj_Close)
1534: */
1535:
1536: break;
1537:
1538: case OLE_ONSAVE:
1539:
1540: // inform clients that the object has been saved
1541:
1542: OLEDBG_BEGIN3("ServerDoc_SendAdvise ONSAVE\r\n");
1543:
1544: if (lpServerDoc->m_lpOleAdviseHldr) {
1545: OLEDBG_BEGIN2("IOleAdviseHolder::SendOnSave called\r\n");
1546: lpServerDoc->m_lpOleAdviseHldr->lpVtbl->SendOnSave(
1547: lpServerDoc->m_lpOleAdviseHldr
1548: );
1549: OLEDBG_END2
1550: }
1551:
1552: /* OLE2NOTE: inform any clients of pseudo objects
1553: ** within our document, that our document has been
1554: ** saved.
1555: */
1556: ServerNameTable_InformAllPseudoObjectsDocSaved(
1557: (LPSERVERNAMETABLE)lpOutlineDoc->m_lpNameTable,
1558: lpmkDoc
1559: );
1560:
1561:
1562: if (lpOutlineDoc->m_docInitType == DOCTYPE_FROMFILE) {
1563: /* OLE2NOTE: we must note the time this File-Based
1564: ** object has been saved in the RunningObjectTable.
1565: ** These change times are used as the basis for
1566: ** IOleObject::IsUpToDate. It is important to set
1567: ** the time of the file-based object following a
1568: ** save operation to exactly the time of the saved
1569: ** file. this helps IOleObject::IsUpToDate to give
1570: ** the correct answer after a file has been saved.
1571: */
1572: OleStdNoteFileChangeTime(
1573: lpOutlineDoc->m_szFileName, lpOleDoc->m_dwRegROT);
1574: }
1575: OLEDBG_END3
1576: break;
1577:
1578: case OLE_ONRENAME:
1579:
1580: // inform clients that the object's name has changed
1581:
1582: OLEDBG_BEGIN3("ServerDoc_SendAdvise ONRENAME\r\n");
1583:
1584: if (lpmkDoc && lpServerDoc->m_lpOleAdviseHldr) {
1585: OLEDBG_BEGIN2("IOleAdviseHolder::SendOnRename called\r\n");
1586: lpServerDoc->m_lpOleAdviseHldr->lpVtbl->SendOnRename(
1587: lpServerDoc->m_lpOleAdviseHldr,
1588: lpmkDoc
1589: );
1590: OLEDBG_END2
1591: }
1592:
1593: /* OLE2NOTE: inform any clients of pseudo objects
1594: ** within our document, that our document's
1595: ** Moniker has changed.
1596: */
1597: ServerNameTable_InformAllPseudoObjectsDocRenamed(
1598: (LPSERVERNAMETABLE)lpOutlineDoc->m_lpNameTable, lpmkDoc);
1599:
1600: OLEDBG_END3
1601: break;
1602: }
1603: }
1604:
1605:
1606: /* ServerDoc_GetClassID
1607: ** --------------------
1608: ** Return the class ID corresponding to the bits in the storage.
1609: ** normally this will be our application's given CLSID. but if a
1610: ** "TreateAs (aka. ActivateAs)" operation is taking place, then our
1611: ** application needs to pretend to be the class of the object that
1612: ** we are emulating. this is also the class that will be written
1613: ** into the storage.
1614: */
1615: HRESULT ServerDoc_GetClassID(LPSERVERDOC lpServerDoc, LPCLSID lpclsid)
1616: {
1617: #if defined( SVR_TREATAS )
1618: if (! IsEqualCLSID(&lpServerDoc->m_clsidTreatAs, &CLSID_NULL))
1619: *lpclsid = lpServerDoc->m_clsidTreatAs;
1620: else
1621: #endif // SVR_TREATAS
1622: *lpclsid = CLSID_APP;
1623:
1624: return NOERROR;
1625: }
1626:
1627:
1628: #if defined( LATER )
1629:
1630: /* ServerDoc_GetUserType
1631: ** ---------------------
1632: ** Return the UserType corresponding to the bits in the storage.
1633: ** normally this will be our application's given UserType. but if a
1634: ** "TreateAs (aka. ActivateAs)" operation is taking place, then our
1635: ** application needs to pretend to be the UserType of the object that
1636: ** we are emulating. this is also the class that will be written
1637: ** into the storage.
1638: */
1639: HRESULT ServerDoc_GetUserType(LPSERVERDOC lpServerDoc, LPCLSID lpclsid)
1640: {
1641: /* OLE2NOTE: we must make sure to set all out parameters to NULL. */
1642: *lpszUserType = NULL;
1643:
1644: #if defined( SVR_TREATAS )
1645: if (lpServerDoc->m_clsidTreatAs != CLSID_NULL)
1646: return OleStdGetUserType(&lpServerDoc->m_clsidTreatAs);
1647: else
1648: #endif // SVR_TREATAS
1649: return OleStdGetUserType(&CLSID_APP);
1650: }
1651:
1652: #endif // LATER
1653:
1654:
1655: /* ServerDoc_UpdateMenu
1656: * --------------------
1657: *
1658: * Update menu for embedding mode. the changes include:
1659: * 1 Remove File/New and File/Open (SDI ONLY)
1660: * 2 Change File/Save As.. to File/Save Copy As..
1661: * 3 Change File menu so it contains "Update" instead of "Save"
1662: * 4 Change File/Exit to File/Exit & Return to <client doc>"
1663: */
1664: void ServerDoc_UpdateMenu(LPSERVERDOC lpServerDoc)
1665: {
1666: char str[256];
1667: HWND hWndMain;
1668: HMENU hMenu;
1669:
1670: OleDbgOut2("ServerDoc_UpdateMenu\r\n");
1671:
1672: hWndMain=g_lpApp->m_hWndApp;
1673: hMenu=GetMenu(hWndMain);
1674:
1675: #if defined( SDI_VERSION )
1676: /* SDI ONLY: Remove File/New and File/Open */
1677: DeleteMenu(hMenu, IDM_F_NEW, MF_BYCOMMAND);
1678: DeleteMenu(hMenu, IDM_F_OPEN, MF_BYCOMMAND);
1679: #endif
1680:
1681: // Change File.Save As.. to File.Save Copy As.. */
1682: ModifyMenu(hMenu,IDM_F_SAVEAS, MF_STRING, IDM_F_SAVEAS, "Save Copy As..");
1683:
1684: // Change File.Save to "&Update <container doc>"
1685: wsprintf(str, g_szUpdateCntrDoc, lpServerDoc->m_szContainerObj);
1686: ModifyMenu(hMenu, IDM_F_SAVE, MF_STRING, IDM_F_SAVE, str);
1687:
1688: // Change File/Exit to File/Exit & Return to <container doc>" */
1689: wsprintf(str, g_szExitNReturnToCntrDoc, lpServerDoc->m_szContainerObj);
1690: ModifyMenu(hMenu, IDM_F_EXIT, MF_STRING, IDM_F_EXIT, str);
1691:
1692: DrawMenuBar(hWndMain);
1693: }
1694:
1695: #if defined( MDI_VERSION )
1696:
1697: // NOTE: ServerDoc_RestoreMenu is actually redundant because the
1698: // app is dying when the function is called. (In SDI, the
1699: // app will terminate when the ref counter of the server doc
1700: // is zero). However, it is important for MDI.
1701:
1702: /* ServerDoc_RestoreMenu
1703: * ---------------------
1704: *
1705: * Reset the menu to non-embedding mode
1706: */
1707: void ServerDoc_RestoreMenu(LPSERVERDOC lpServerDoc)
1708: {
1709: LPOUTLINEAPP lpOutlineApp = (LPOUTLINEAPP)g_lpApp;
1710: HWND hWndMain;
1711: HMENU hMenu;
1712:
1713: OleDbgOut2("ServerDoc_RestoreMenu\r\n");
1714:
1715: hWndMain = lpOutlineApp->m_hWndApp;
1716: hMenu = GetMenu(hWndMain);
1717:
1718: /* Add back File/New, File/Open.. and File/Save */
1719: InsertMenu(hMenu, IDM_F_SAVEAS, MF_BYCOMMAND | MF_ENABLED | MF_STRING,
1720: IDM_F_NEW, "&New");
1721: InsertMenu(hMenu, IDM_F_SAVEAS, MF_BYCOMMAND | MF_ENABLED | MF_STRING,
1722: IDM_F_OPEN, "&Open...");
1723:
1724: /* Change File menu so it contains "Save As..." instead of */
1725: /* "Save Copy As..." */
1726: ModifyMenu(hMenu, IDM_F_SAVEAS, MF_STRING, IDM_F_SAVEAS, "Save &As..");
1727:
1728: /* Change File menu so it contains "Save" instead of "Update" */
1729: ModifyMenu(hMenu, IDM_F_SAVE, MF_STRING, IDM_F_SAVE, "&Save");
1730:
1731: /* Change File menu so it contains "Exit" */
1732: /* instead of just "Exit & Return to <client doc>" */
1733: ModifyMenu(hMenu, IDM_F_EXIT, MF_STRING, IDM_F_EXIT, "E&xit");
1734:
1735: DrawMenuBar (hWndMain);
1736: }
1737:
1738: #endif // MDI_VERSION
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.