![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to svrinpl.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 svrinpl.c CVS log | Up to [WindowsNT SDKs] / mstools / ole20 / samples / outline |
1.1 root 1: /*************************************************************************
2: **
3: ** OLE 2 Server Sample Code
4: **
5: ** svrinpl.c
6: **
7: ** This file contains all interfaces, methods and related support
8: ** functions for an In-Place Object (Server) application (aka. Visual
9: ** Editing). The in-place Object application includes the following
10: ** implementation objects:
11: **
12: ** ServerDoc Object
13: ** exposed interfaces:
14: ** IOleInPlaceObject
15: ** IOleInPlaceActiveObject
16: **
17: ** ServerApp Object
18: ** exposed interfaces:
19: ** IUnknown
20: **
21: ** (c) Copyright Microsoft Corp. 1992 - 1993 All Rights Reserved
22: **
23: *************************************************************************/
24:
25:
26: #include "outline.h"
27:
28: OLEDBGDATA
29:
30: extern LPOUTLINEAPP g_lpApp;
31:
32:
33: #if defined( INPLACE_SVR )
34:
35: /* OLE2NOTE: the object should compose a string that is used by
36: ** in-place containers to be used for the window titles. this string
37: ** is passed to the container application via
38: ** IOleInPlaceUIWindow::SetActiveObject. the string should have the
39: ** following form:
40: ** <application name> - <object short type name>
41: ** SDI containers can use the string directly to display in the
42: ** frame window title. the container would concatenate the string
43: ** " in <container doc name>".
44: ** an MDI container with the MDI child window maximized can do the
45: ** same as the SDI container. an MDI container with the MDI child
46: ** windows NOT maximized can look for the " - " in the string from
47: ** the object. the first part of the string (app name) would be put
48: ** as the frame window title; the second part would be composed with
49: ** " in <container doc name>" and used as the MDI child window
50: ** title.
51: */
52:
53: // REVIEW: should use string resource for messages
54: char g_szIPObjectTitle[] = APPNAME " - " SHORTUSERTYPENAME;
55:
56: extern RECT g_rectNull;
57:
58:
59:
60: /*************************************************************************
61: ** ServerDoc::IOleInPlaceObject interface implementation
62: *************************************************************************/
63:
64: // IOleInPlaceObject::QueryInterface method
65:
66: STDMETHODIMP SvrDoc_IPObj_QueryInterface(
67: LPOLEINPLACEOBJECT lpThis,
68: REFIID riid,
69: LPVOID FAR * lplpvObj
70: )
71: {
72: LPSERVERDOC lpServerDoc =
73: ((struct CDocOleObjectImpl FAR*)lpThis)->lpServerDoc;
74:
75: return OleDoc_QueryInterface((LPOLEDOC)lpServerDoc, riid, lplpvObj);
76: }
77:
78:
79: // IOleInPlaceObject::AddRef method
80:
81: STDMETHODIMP_(ULONG) SvrDoc_IPObj_AddRef(LPOLEINPLACEOBJECT lpThis)
82: {
83: LPSERVERDOC lpServerDoc =
84: ((struct CDocOleObjectImpl FAR*)lpThis)->lpServerDoc;
85:
86: OleDbgAddRefMethod(lpThis, "IOleInPlaceObject");
87:
88: return OleDoc_AddRef((LPOLEDOC)lpServerDoc);
89: }
90:
91:
92: // IOleInPlaceObject::Release method
93:
94: STDMETHODIMP_(ULONG) SvrDoc_IPObj_Release(LPOLEINPLACEOBJECT lpThis)
95: {
96: LPSERVERDOC lpServerDoc =
97: ((struct CDocOleObjectImpl FAR*)lpThis)->lpServerDoc;
98:
99: OleDbgReleaseMethod(lpThis, "IOleInPlaceObject");
100:
101: return OleDoc_Release((LPOLEDOC)lpServerDoc);
102: }
103:
104:
105: // IOleInPlaceObject::GetWindow method
106:
107: STDMETHODIMP SvrDoc_IPObj_GetWindow(
108: LPOLEINPLACEOBJECT lpThis,
109: HWND FAR* lphwnd
110: )
111: {
112: LPSERVERDOC lpServerDoc =
113: ((struct CDocOleObjectImpl FAR*)lpThis)->lpServerDoc;
114:
115: OLEDBG_BEGIN2("SvrDoc_IPObj_GetWindow\r\n")
116:
117: *lphwnd = ((LPOUTLINEDOC)lpServerDoc)->m_hWndDoc;
118:
119: OLEDBG_END2
120: return S_OK;
121: }
122:
123:
124: // IOleInPlaceObject::ContextSensitiveHelp method
125:
126: STDMETHODIMP SvrDoc_IPObj_ContextSensitiveHelp(
127: LPOLEINPLACEOBJECT lpThis,
128: BOOL fEnable
129: )
130: {
131: LPSERVERDOC lpServerDoc =
132: ((struct CDocOleObjectImpl FAR*)lpThis)->lpServerDoc;
133:
134: OLEDBG_BEGIN2("SvrDoc_IPObj_ContextSensitiveHelp\r\n")
135:
136: lpServerDoc->m_lpIPData->fInCSHelpMode = fEnable;
137:
138: OLEDBG_END2
139: return S_OK;
140: }
141:
142:
143: // IOleInPlaceObject::InPlaceDeactivate method
144:
145: STDMETHODIMP SvrDoc_IPObj_InPlaceDeactivate(LPOLEINPLACEOBJECT lpThis)
146: {
147: LPSERVERDOC lpServerDoc =
148: ((struct CDocOleObjectImpl FAR*)lpThis)->lpServerDoc;
149: HRESULT hrErr;
150:
151: OLEDBG_BEGIN2("SvrDoc_IPObj_InPlaceDeactivate\r\n")
152:
153: hrErr = ServerDoc_DoInPlaceDeactivate(lpServerDoc);
154:
155: OLEDBG_END2
156: return hrErr;
157: }
158:
159:
160: // IOleInPlaceObject::UIDeactivate method
161:
162: STDMETHODIMP SvrDoc_IPObj_UIDeactivate(LPOLEINPLACEOBJECT lpThis)
163: {
164: LPSERVERDOC lpServerDoc =
165: ((struct CDocOleObjectImpl FAR*)lpThis)->lpServerDoc;
166: LPSERVERAPP lpServerApp = (LPSERVERAPP)g_lpApp;
167: LPOUTLINEDOC lpOutlineDoc = (LPOUTLINEDOC)lpServerDoc;
168: LPINPLACEDATA lpIPData = lpServerDoc->m_lpIPData;
169: LPLINELIST lpLL = (LPLINELIST)&((LPOUTLINEDOC)lpServerDoc)->m_LineList;
170: HWND hWndApp = OutlineApp_GetWindow(g_lpApp);
171:
172: OLEDBG_BEGIN2("SvrDoc_IPObj_UIDeactivate\r\n");
173:
174: if (!lpServerDoc->m_fUIActive) {
175: OLEDBG_END2
176: return NOERROR;
177: }
178:
179: lpServerDoc->m_fUIActive = FALSE;
180:
181: // Clip the hatch window to the size of pos rect so, that the object
182: // adornments and hatch border will not be visible.
183: ServerDoc_ResizeInPlaceWindow(lpServerDoc,
184: (LPRECT)&(lpServerDoc->m_lpIPData->rcPosRect),
185: (LPRECT)&(lpServerDoc->m_lpIPData->rcPosRect)
186: );
187:
188: if (lpIPData->lpDoc)
189: lpIPData->lpDoc->lpVtbl->SetActiveObject(lpIPData->lpDoc, NULL, NULL);
190:
191: if (lpIPData->lpFrame) {
192: lpIPData->lpFrame->lpVtbl->SetActiveObject(
193: lpIPData->lpFrame,
194: NULL,
195: NULL
196: );
197: }
198:
199: #if defined( USE_FRAMETOOLS )
200: /* OLE2NOTE: we must hide our frame tools here but NOT call
201: ** IOleInPlaceFrame::SetBorderSpace(NULL) or SetMenu(NULL).
202: ** we must hide our tools BEFORE calling
203: ** IOleInPlaceSite::OnUIDeactivate. the container will put
204: ** his menus and tools back when OnUIDeactivate is called.
205: */
206: ServerDoc_RemoveFrameLevelTools(lpServerDoc);
207: #endif
208:
209: OLEDBG_BEGIN2("IOleInPlaceSite::OnUIDeactivate called\r\n");
210: lpIPData->lpSite->lpVtbl->OnUIDeactivate(lpIPData->lpSite, FALSE);
211: OLEDBG_END2
212:
213: /* Reset to use our normal app's accelerator table */
214: g_lpApp->m_hAccel = g_lpApp->m_hAccelApp;
215: g_lpApp->m_hWndAccelTarget = hWndApp;
216:
217: OLEDBG_END2
218:
219: #if !defined( SVR_INSIDEOUT )
220: /* OLE2NOTE: an "outside-in" style in-place server would hide its
221: ** window here. an "inside-out" style server leaves its window
222: ** visible when it is UIDeactivated. it would only hide its
223: ** window when InPlaceDeactivated. this app is an "inside-out"
224: ** style server. it is recommended for most server to support
225: ** inside-out behavior if possible.
226: */
227: ServerDoc_DoInPlaceHide(lpServerDoc);
228: #endif // INSIEDOUT
229:
230: return NOERROR;
231: }
232:
233:
234: // IOleInPlaceObject::SetObjectRects method
235:
236: STDMETHODIMP SvrDoc_IPObj_SetObjectRects(
237: LPOLEINPLACEOBJECT lpThis,
238: LPCRECT lprcPosRect,
239: LPCRECT lprcClipRect
240: )
241: {
242: LPSERVERDOC lpServerDoc =
243: ((struct CDocOleObjectImpl FAR*)lpThis)->lpServerDoc;
244: LPINPLACEDATA lpIPData = lpServerDoc->m_lpIPData;
245: LPLINELIST lpLL = OutlineDoc_GetLineList((LPOUTLINEDOC)lpServerDoc);
246:
247: OLEDBG_BEGIN2("SvrDoc_IPObj_SetObjectRects\r\n")
248:
249: OleDbgOutRect3("SvrDoc_IPObj_SetObjectRects (PosRect)",
250: (LPRECT)lprcPosRect);
251: OleDbgOutRect3("SvrDoc_IPObj_SetObjectRects (ClipRect)",
252: (LPRECT)lprcClipRect);
253:
254: // save the current PosRect and ClipRect
255: lpIPData->rcPosRect = *lprcPosRect;
256: lpIPData->rcClipRect = *lprcClipRect;
257:
258: if (! lpServerDoc->m_fUIActive) // hatch and adornaments must not be drawn
259: lprcClipRect = lprcPosRect;
260:
261: ServerDoc_ResizeInPlaceWindow(
262: lpServerDoc, (LPRECT)lprcPosRect, (LPRECT)lprcClipRect);
263:
264:
265: /* reset the horizontal extent of the listbox. this makes
266: ** the listbox realize that a scroll bar is not needed.
267: */
268: SendMessage(
269: lpLL->m_hWndListBox,
270: LB_SETHORIZONTALEXTENT,
271: (int) 0,
272: 0L
273: );
274: SendMessage(
275: lpLL->m_hWndListBox,
276: LB_SETHORIZONTALEXTENT,
277: (int) (lpIPData->rcPosRect.right - lpIPData->rcPosRect.left),
278: 0L
279: );
280:
281: OLEDBG_END2
282: return NOERROR;
283: }
284:
285:
286: // IOleInPlaceObject::ReactivateAndUndo method
287:
288: STDMETHODIMP SvrDoc_IPObj_ReactivateAndUndo(LPOLEINPLACEOBJECT lpThis)
289: {
290: OLEDBG_BEGIN2("SvrDoc_IPObj_ReactivateAndUndo\r\n")
291:
292: // We do not support support UNDO.
293:
294: /* REVIEW: for debugging purposes it would be useful to give a
295: ** message box indicating that this method has been called.
296: */
297:
298: OLEDBG_END2
299: return NOERROR;
300: }
301:
302:
303: /*************************************************************************
304: ** ServerDoc::IOleInPlaceActiveObject interface implementation
305: *************************************************************************/
306:
307: // IOleInPlaceActiveObject::QueryInterface method
308:
309: STDMETHODIMP SvrDoc_IPActiveObj_QueryInterface(
310: LPOLEINPLACEACTIVEOBJECT lpThis,
311: REFIID riid,
312: LPVOID FAR * lplpvObj
313: )
314: {
315: SCODE sc = E_NOINTERFACE;
316: LPSERVERDOC lpServerDoc =
317: ((struct CDocOleObjectImpl FAR*)lpThis)->lpServerDoc;
318:
319: /* The container should not be able to access the other interfaces
320: ** of our object by doing QI on this interface.
321: */
322:
323: *lplpvObj = NULL;
324: if (IsEqualIID(riid, &IID_IUnknown) ||
325: IsEqualIID(riid, &IID_IOleWindow) ||
326: IsEqualIID(riid, &IID_IOleInPlaceActiveObject)) {
327: OleDbgOut4("OleDoc_QueryInterface: IOleInPlaceActiveObject* RETURNED\r\n");
328:
329: *lplpvObj = lpThis;
330: OleDoc_AddRef((LPOLEDOC)lpServerDoc);
331: sc = NOERROR;
332: }
333:
334: OleDbgQueryInterfaceMethod(*lplpvObj);
335:
336: return ResultFromScode(sc);
337: }
338:
339:
340: // IOleInPlaceActiveObject::AddRef method
341:
342: STDMETHODIMP_(ULONG) SvrDoc_IPActiveObj_AddRef(
343: LPOLEINPLACEACTIVEOBJECT lpThis
344: )
345: {
346: LPSERVERDOC lpServerDoc =
347: ((struct CDocOleObjectImpl FAR*)lpThis)->lpServerDoc;
348:
349: OleDbgAddRefMethod(lpThis, "IOleInPlaceActiveObject");
350:
351: return OleDoc_AddRef((LPOLEDOC)lpServerDoc);
352: }
353:
354:
355: // IOleInPlaceActiveObject::Release method
356:
357: STDMETHODIMP_(ULONG) SvrDoc_IPActiveObj_Release(
358: LPOLEINPLACEACTIVEOBJECT lpThis
359: )
360: {
361: LPSERVERDOC lpServerDoc =
362: ((struct CDocOleObjectImpl FAR*)lpThis)->lpServerDoc;
363:
364: OleDbgReleaseMethod(lpThis, "IOleInPlaceActiveObject");
365:
366: return OleDoc_Release((LPOLEDOC)lpServerDoc);
367: }
368:
369:
370: // IOleInPlaceActiveObject::GetWindow method
371:
372: STDMETHODIMP SvrDoc_IPActiveObj_GetWindow(
373: LPOLEINPLACEACTIVEOBJECT lpThis,
374: HWND FAR* lphwnd
375: )
376: {
377: LPSERVERDOC lpServerDoc =
378: ((struct CDocOleObjectImpl FAR*)lpThis)->lpServerDoc;
379:
380: OLEDBG_BEGIN2("SvrDoc_IPActiveObj_GetWindow\r\n")
381:
382: *lphwnd = ((LPOUTLINEDOC)lpServerDoc)->m_hWndDoc;
383:
384: OLEDBG_END2
385: return NOERROR;
386: }
387:
388:
389: // IOleInPlaceActiveObject::ContextSensitiveHelp method
390:
391: STDMETHODIMP SvrDoc_IPActiveObj_ContextSensitiveHelp(
392: LPOLEINPLACEACTIVEOBJECT lpThis,
393: BOOL fEnable
394: )
395: {
396: LPSERVERDOC lpServerDoc =
397: ((struct CDocOleObjectImpl FAR*)lpThis)->lpServerDoc;
398:
399: OLEDBG_BEGIN2("SvrDoc_IPActiveObj_ContextSensitiveHelp\r\n")
400:
401: lpServerDoc->m_lpIPData->fInCSHelpMode = fEnable;
402:
403: OLEDBG_END2
404: return NOERROR;
405: }
406:
407:
408: // IOleInPlaceActiveObject::TranslateAccelerator method
409:
410: STDMETHODIMP SvrDoc_IPActiveObj_TranslateAccelerator(
411: LPOLEINPLACEACTIVEOBJECT lpThis,
412: LPMSG lpmsg
413: )
414: {
415: // This will never be called because this server is implemented as an EXE
416: return NOERROR;
417: }
418:
419:
420: // IOleInPlaceActiveObject::OnFrameWindowActivate method
421:
422: STDMETHODIMP SvrDoc_IPActiveObj_OnFrameWindowActivate(
423: LPOLEINPLACEACTIVEOBJECT lpThis,
424: BOOL fActivate
425: )
426: {
427: LPOUTLINEDOC lpOutlineDoc = (LPOUTLINEDOC)
428: ((struct CDocOleObjectImpl FAR*)lpThis)->lpServerDoc;
429: HWND hWndDoc = OutlineDoc_GetWindow(lpOutlineDoc);
430:
431: OleDbgOut2("SvrDoc_IPActiveObj_OnFrameWindowActivate\r\n");
432:
433: /* OLE2NOTE: this is a notification of the container application's
434: ** WM_ACTIVATEAPP status. some applications may find this
435: ** important. we need to update the enable/disable status of our
436: ** tool bar buttons.
437: */
438:
439: // OLE2NOTE: We can't call OutlineDoc_UpdateFrameToolButtons
440: // right away which
441: // would generate some OLE calls and eventually
442: // WM_ACTIVATEAPP and a loop was formed. Therefore, we
443: // should delay the frame tool initialization until
444: // WM_ACTIVATEAPP is finished by posting a message
445: // to ourselves.
446:
447: /* Update enable/disable state of buttons in toolbar */
448: if (fActivate)
449: PostMessage(hWndDoc, WM_U_INITFRAMETOOLS, 0, 0L);
450:
451: return NOERROR;
452: }
453:
454:
455: // IOleInPlaceActiveObject::OnDocWindowActivate method
456:
457: STDMETHODIMP SvrDoc_IPActiveObj_OnDocWindowActivate(
458: LPOLEINPLACEACTIVEOBJECT lpThis,
459: BOOL fActivate
460: )
461: {
462: LPSERVERDOC lpServerDoc =
463: ((struct CDocOleObjectImpl FAR*)lpThis)->lpServerDoc;
464: LPINPLACEDATA lpIPData = lpServerDoc->m_lpIPData;
465:
466: OLEDBG_BEGIN2("SvrDoc_IPActiveObj_OnDocWindowActivate\r\n")
467:
468: if (fActivate) {
469: ServerDoc_AddFrameLevelUI(lpServerDoc);
470: }
471: else {
472: #if defined( USE_FRAMETOOLS )
473: /* OLE2NOTE: we must NOT call IOleInPlaceFrame::SetBorderSpace(NULL)
474: ** or SetMenu(NULL) here. we should simply hide our tools.
475: */
476: ServerDoc_RemoveFrameLevelTools(lpServerDoc);
477: #endif
478: }
479:
480: OLEDBG_END2
481: return NOERROR;
482: }
483:
484:
485: // IOleInPlaceActiveObject::ResizeBorder method
486:
487: STDMETHODIMP SvrDoc_IPActiveObj_ResizeBorder(
488: LPOLEINPLACEACTIVEOBJECT lpThis,
489: LPCRECT lprectBorder,
490: LPOLEINPLACEUIWINDOW lpIPUiWnd,
491: BOOL fFrameWindow
492: )
493: {
494: LPSERVERDOC lpServerDoc =
495: ((struct CDocOleObjectImpl FAR*)lpThis)->lpServerDoc;
496: LPOUTLINEDOC lpOutlineDoc = (LPOUTLINEDOC)lpServerDoc;
497:
498: OLEDBG_BEGIN2("SvrDoc_IPActiveObj_ResizeBorder\r\n")
499:
500:
501: #if defined( USE_FRAMETOOLS )
502:
503: if (fFrameWindow) {
504: FrameTools_NegotiateForSpaceAndShow(
505: lpOutlineDoc->m_lpFrameTools,
506: (LPRECT)lprectBorder,
507: (LPOLEINPLACEFRAME)lpIPUiWnd
508: );
509: }
510:
511: #endif
512:
513: OLEDBG_END2
514: return NOERROR;
515: }
516:
517:
518: // IOleInPlaceActiveObject::EnableModeless method
519:
520: STDMETHODIMP SvrDoc_IPActiveObj_EnableModeless(
521: LPOLEINPLACEACTIVEOBJECT lpThis,
522: BOOL fEnable
523: )
524: {
525: LPSERVERDOC lpServerDoc =
526: ((struct CDocOleObjectImpl FAR*)lpThis)->lpServerDoc;
527:
528: OleDbgOut2("SvrDoc_IPActiveObj_EnableModeless\r\n");
529:
530: return NOERROR;
531: }
532:
533:
534: /*************************************************************************
535: ** Support Functions
536: *************************************************************************/
537:
538:
539: HRESULT ServerDoc_DoInPlaceActivate(
540: LPSERVERDOC lpServerDoc,
541: LONG lVerb,
542: LPMSG lpmsg,
543: LPOLECLIENTSITE lpActiveSite
544: )
545: {
546: LPOUTLINEAPP lpOutlineApp = (LPOUTLINEAPP)g_lpApp;
547: LPSERVERAPP lpServerApp = (LPSERVERAPP)g_lpApp;
548: LPOLEAPP lpOleApp = (LPOLEAPP)g_lpApp;
549: SCODE sc = E_FAIL;
550: RECT rcPos;
551: RECT rcClip;
552: LPINPLACEDATA lpIPData = lpServerDoc->m_lpIPData;
553: LPOUTLINEDOC lpOutlineDoc=(LPOUTLINEDOC)lpServerDoc;
554: HWND hWndDoc = lpOutlineDoc->m_hWndDoc;
555: HWND hWndHatch = lpServerDoc->m_hWndHatch;
556: HRESULT hrErr;
557: LPLINELIST lpLL=(LPLINELIST)&lpOutlineDoc->m_LineList;
558: LPOLEINPLACESITE lpIPSite = NULL;
559:
560: /* OLE2NOTE: lpActiveSite should be used only for InPlace PLAYing.
561: ** This app does not do inplace PLAYing, so it never uses
562: ** lpActiveSite.
563: */
564:
565: /* InPlace activation can only be done if the ClientSite is non-NULL. */
566: if (! lpServerDoc->m_lpOleClientSite)
567: return NOERROR;
568:
569: if (! lpServerDoc->m_fInPlaceActive) {
570:
571: // if the object is in open mode then we do not want to do inplace
572: // activation.
573: if (IsWindowVisible(lpOutlineDoc->m_hWndDoc))
574: return NOERROR;
575:
576: lpIPSite = (LPOLEINPLACESITE)OleStdQueryInterface(
577: (LPUNKNOWN)lpServerDoc->m_lpOleClientSite,
578: &IID_IOleInPlaceSite
579: );
580:
581: if (! lpIPSite)
582: goto errActivate;
583:
584: if (lpIPSite->lpVtbl->CanInPlaceActivate(lpIPSite) != NOERROR)
585: goto errActivate;
586:
587: lpServerDoc->m_fInPlaceActive = TRUE;
588: if (lpIPSite->lpVtbl->OnInPlaceActivate(lpIPSite) != NOERROR)
589: goto errActivate;
590:
591: if (! ServerDoc_AllocInPlaceData(lpServerDoc)) {
592: sc = E_OUTOFMEMORY;
593: lpIPSite->lpVtbl->OnInPlaceDeactivate(lpIPSite);
594: goto errActivate;
595: }
596:
597: (lpIPData = lpServerDoc->m_lpIPData)->lpSite = lpIPSite;
598: goto InPlaceActive;
599:
600: errActivate:
601: lpServerDoc->m_fInPlaceActive = FALSE;
602: if (lpIPSite)
603: OleStdRelease((LPUNKNOWN)lpIPSite);
604: return ResultFromScode(sc);
605: }
606:
607:
608: InPlaceActive:
609:
610: if (! lpServerDoc->m_fInPlaceVisible) {
611: lpServerDoc->m_fInPlaceVisible = TRUE;
612:
613: OLEDBG_BEGIN2("IOleInPlaceSite::GetWindow called\r\n");
614: hrErr = lpIPData->lpSite->lpVtbl->GetWindow(
615: lpIPData->lpSite,
616: &lpServerDoc->m_hWndParent
617: );
618: OLEDBG_END2
619: if (hrErr != NOERROR) {
620: sc = GetScode(hrErr);
621: goto errRtn;
622: }
623:
624: if (! lpServerDoc->m_hWndParent)
625: goto errRtn;
626:
627: /* OLE2NOTE: The server should fill in the "cb" field so that the
628: ** container can tell what size structure the server is
629: ** expecting. this enables this structure to be easily extended
630: ** in future releases of OLE. the container should check this
631: ** field so that it doesn't try to use fields that do not exist
632: ** since the server may be using an old structure definition.
633: */
634: _fmemset(
635: (LPOLEINPLACEFRAMEINFO)&lpIPData->frameInfo,
636: 0,
637: sizeof(OLEINPLACEFRAMEINFO)
638: );
639: lpIPData->frameInfo.cb = sizeof(OLEINPLACEFRAMEINFO);
640:
641: OLEDBG_BEGIN2("IOleInPlaceSite::GetWindowContext called\r\n");
642: hrErr = lpIPData->lpSite->lpVtbl->GetWindowContext(lpIPData->lpSite,
643: (LPOLEINPLACEFRAME FAR*) &lpIPData->lpFrame,
644: (LPOLEINPLACEUIWINDOW FAR*)&lpIPData->lpDoc,
645: (LPRECT)&rcPos,
646: (LPRECT)&rcClip,
647: (LPOLEINPLACEFRAMEINFO)&lpIPData->frameInfo);
648: OLEDBG_END2
649:
650: if (hrErr != NOERROR) {
651: sc = GetScode(hrErr);
652: goto errRtn;
653: }
654:
655: lpServerApp->m_lpIPData = lpIPData;
656: ShowWindow(hWndDoc, SW_HIDE); // make sure we are hidden
657:
658: /* OLE2NOTE: reparent in-place server document's window to the
659: ** special in-place hatch border window. set the in-place site's
660: ** window as the parent of the hatch window. position the
661: ** in-place and hatch border windows using the PosRect and
662: ** ClipRect.
663: ** it is important to properly parent and position the in-place
664: ** server window BEFORE calling IOleInPlaceFrame::SetMenu and
665: ** SetBorderSpace.
666: */
667: ShowWindow(lpServerDoc->m_hWndHatch, SW_SHOW);
668: // make sure App busy/blocked dialogs are parented to our
669: // new hWndFrame
670: OleStdMsgFilter_SetParentWindow(
671: lpOleApp->m_lpMsgFilter,lpIPData->frameInfo.hwndFrame);
672: SetParent(lpServerDoc->m_hWndHatch, lpServerDoc->m_hWndParent);
673: SetParent(hWndDoc, lpServerDoc->m_hWndHatch);
674:
675: OleDbgOutRect3("IOleInPlaceSite::GetWindowContext (PosRect)",
676: (LPRECT)&rcPos);
677: OleDbgOutRect3("IOleInPlaceSite::GetWindowContext (ClipRect)",
678: (LPRECT)&rcClip);
679:
680: // save the current PosRect and ClipRect
681: lpIPData->rcPosRect = rcPos;
682: lpIPData->rcClipRect = rcClip;
683:
684: /* OLE2NOTE: build the shared menu for the in-place container and
685: ** the server.
686: */
687: if (ServerDoc_AssembleMenus (lpServerDoc) != NOERROR)
688: goto errRtn;
689:
690: #if defined( SVR_INSIDEOUT )
691: if (lVerb == OLEIVERB_INPLACEACTIVATE) {
692: // Clip the hatch window to the size of pos rect so, that
693: // hatch and object adornments will not be visible.
694: ServerDoc_ResizeInPlaceWindow(lpServerDoc,
695: (LPRECT)&(lpServerDoc->m_lpIPData->rcPosRect),
696: (LPRECT)&(lpServerDoc->m_lpIPData->rcPosRect)
697: );
698: }
699: #endif // SVR_INSIDEOUT
700: }
701:
702: #if defined( SVR_INSIDEOUT )
703: // OLE2NOTE: if verb is OLEIVERB_INPLACEACTIVATE we do NOT want to
704: // show our UI
705: if (lVerb == OLEIVERB_INPLACEACTIVATE) {
706: return NOERROR;
707: }
708: #endif // SVR_INSIDEOUT
709:
710: if (! lpServerDoc->m_fUIActive) {
711: lpServerDoc->m_fUIActive = TRUE;
712: OLEDBG_BEGIN2("IOleInPlaceSite::OnUIActivate called\r\n");
713: hrErr = lpIPData->lpSite->lpVtbl->OnUIActivate(lpIPData->lpSite);
714: OLEDBG_END2
715: if (hrErr != NOERROR) {
716: lpServerDoc->m_fUIActive = FALSE;
717: goto errRtn;
718: }
719:
720: SetFocus(hWndDoc);
721:
722: // Show the object adornments and hacth border around them.
723: ServerDoc_ResizeInPlaceWindow(lpServerDoc,
724: (LPRECT)&lpIPData->rcPosRect,
725: (LPRECT)&lpIPData->rcClipRect
726: );
727:
728: /* OLE2NOTE: IOleInPlaceFrame::SetActiveObject must be called BEFORE
729: ** IOleInPlaceFrame::SetMenu.
730: */
731: lpIPData->lpFrame->lpVtbl->SetActiveObject(
732: lpIPData->lpFrame,
733: (LPOLEINPLACEACTIVEOBJECT) &lpServerDoc->m_OleInPlaceActiveObject,
734: (LPSTR)g_szIPObjectTitle
735: );
736:
737: if (lpIPData->lpDoc) {
738: lpIPData->lpDoc->lpVtbl->SetActiveObject(
739: lpIPData->lpDoc,
740: (LPOLEINPLACEACTIVEOBJECT)&lpServerDoc->m_OleInPlaceActiveObject,
741: (LPSTR)g_szIPObjectTitle
742: );
743: }
744:
745: /* OLE2NOTE: install the menu and frame-level tools on the in-place
746: ** frame.
747: */
748: ServerDoc_AddFrameLevelUI(lpServerDoc);
749: }
750:
751: return NOERROR;
752:
753: errRtn:
754: ServerDoc_DoInPlaceDeactivate(lpServerDoc);
755: return ResultFromScode(sc);
756: }
757:
758:
759:
760: HRESULT ServerDoc_DoInPlaceDeactivate(LPSERVERDOC lpServerDoc)
761: {
762: LPINPLACEDATA lpIPData = lpServerDoc->m_lpIPData;
763: LPOUTLINEDOC lpOutlineDoc = (LPOUTLINEDOC)lpServerDoc;
764:
765: if (!lpServerDoc->m_fInPlaceActive)
766: return S_OK;
767:
768: lpServerDoc->m_fInPlaceActive = FALSE;
769:
770: SvrDoc_IPObj_UIDeactivate(
771: (LPOLEINPLACEOBJECT)&lpServerDoc->m_OleInPlaceObject);
772:
773: #if defined( SVR_INSIDEOUT )
774: /* OLE2NOTE: an inside-out style in-place server will
775: ** NOT hide its window in UIDeactive (an outside-in
776: ** style object will hide its window in
777: ** UIDeactivate). thus we need to explicitly hide
778: ** our window now.
779: */
780: ServerDoc_DoInPlaceHide(lpServerDoc);
781: #endif // INSIEDOUT
782:
783: OLEDBG_BEGIN2("IOleInPlaceSite::OnInPlaceDeactivate called\r\n");
784: lpIPData->lpSite->lpVtbl->OnInPlaceDeactivate(lpIPData->lpSite);
785: OLEDBG_END2
786:
787: OleStdRelease((LPUNKNOWN)lpIPData->lpSite);
788: lpIPData->lpSite = NULL;
789:
790: ServerDoc_FreeInPlaceData(lpServerDoc);
791:
792: return NOERROR;
793: }
794:
795:
796: HRESULT ServerDoc_DoInPlaceHide(LPSERVERDOC lpServerDoc)
797: {
798: LPINPLACEDATA lpIPData = lpServerDoc->m_lpIPData;
799: LPOUTLINEDOC lpOutlineDoc = (LPOUTLINEDOC)lpServerDoc;
800: LPOLEAPP lpOleApp = (LPOLEAPP)g_lpApp;
801: HWND hWndApp = OutlineApp_GetWindow(g_lpApp);
802:
803: if (! lpServerDoc->m_fInPlaceVisible)
804: return NOERROR;
805:
806: // Set the parent back to server app's window
807: OleDoc_HideWindow((LPOLEDOC)lpServerDoc, FALSE /* fShutdown */);
808:
809: lpServerDoc->m_fInPlaceVisible = FALSE;
810:
811: lpServerDoc->m_hWndParent = hWndApp;
812: SetParent(
813: lpOutlineDoc->m_hWndDoc,
814: lpServerDoc->m_hWndParent
815: );
816:
817: // make sure App busy/blocked dialogs are parented to our own hWndApp
818: OleStdMsgFilter_SetParentWindow(lpOleApp->m_lpMsgFilter, hWndApp);
819:
820: // Hide the in-place hatch border window.
821: ShowWindow(lpServerDoc->m_hWndHatch, SW_HIDE);
822:
823: ServerDoc_DisassembleMenus(lpServerDoc);
824:
825: /* we no longer need the IOleInPlaceFrame* or the doc's
826: ** IOleInPlaceWindow* interface pointers.
827: */
828: if (lpIPData->lpDoc) {
829: OleStdRelease((LPUNKNOWN)lpIPData->lpDoc);
830: lpIPData->lpDoc = NULL;
831: }
832:
833: if (lpIPData->lpFrame) {
834: OleStdRelease((LPUNKNOWN)lpIPData->lpFrame);
835: lpIPData->lpFrame = NULL;
836: }
837:
838: ((LPSERVERAPP)g_lpApp)->m_lpIPData = NULL;
839:
840: return NOERROR;
841: }
842:
843:
844: BOOL ServerDoc_AllocInPlaceData(LPSERVERDOC lpServerDoc)
845: {
846: LPINPLACEDATA lpIPData;
847:
848: if (!(lpIPData = (LPINPLACEDATA) New(sizeof(INPLACEDATA))))
849: return FALSE;
850:
851: lpIPData->lpFrame = NULL;
852: lpIPData->lpDoc = NULL;
853: lpIPData->lpSite = NULL;
854: lpIPData->fInCSHelpMode = FALSE;
855: lpIPData->hOlemenu = NULL;
856: lpIPData->hMenuShared = NULL;
857:
858: lpServerDoc->m_lpIPData = lpIPData;
859: return TRUE;
860: }
861:
862:
863: void ServerDoc_FreeInPlaceData(LPSERVERDOC lpServerDoc)
864: {
865: Delete(lpServerDoc->m_lpIPData);
866: lpServerDoc->m_lpIPData = NULL;
867: }
868:
869:
870: HRESULT ServerDoc_AssembleMenus(LPSERVERDOC lpServerDoc)
871: {
872: HMENU hMenuShared;
873: LONG FAR* lpWidths;
874: UINT uPosition;
875: UINT uPositionStart;
876: LPSERVERAPP lpServerApp = (LPSERVERAPP) g_lpApp;
877: LPINPLACEDATA lpIPData = lpServerDoc->m_lpIPData;
878: HRESULT hresult;
879: BOOL fNoError = TRUE;
880:
881: lpWidths = lpIPData->menuGroupWidths.width;
882: hMenuShared = CreateMenu();
883:
884: if (hMenuShared &&
885: (hresult = lpIPData->lpFrame->lpVtbl->InsertMenus(
886: lpIPData->lpFrame, hMenuShared,
887: &lpIPData->menuGroupWidths)) == NOERROR) {
888:
889: /* Insert EDIT group menus */
890:
891: uPosition = (UINT)lpWidths[0]; /* # of menus in the FILE group */
892: uPositionStart = uPosition;
893:
894: fNoError &= InsertMenu(
895: hMenuShared,
896: (UINT)uPosition,
897: (UINT)(MF_BYPOSITION | MF_POPUP),
898: (UINT)lpServerApp->m_hMenuEdit,
899: (LPCSTR)"&Edit"
900: );
901: uPosition++;
902:
903: lpWidths[1] = uPosition - uPositionStart;
904:
905: /* Insert OBJECT group menus */
906:
907: uPosition += (UINT)lpWidths[2];
908: uPositionStart = uPosition;
909:
910: fNoError &= InsertMenu(
911: hMenuShared,
912: (UINT)uPosition,
913: (UINT)(MF_BYPOSITION | MF_POPUP),
914: (UINT)lpServerApp->m_hMenuLine,
915: (LPCSTR)"&Line"
916: );
917: uPosition++;
918:
919: fNoError &= InsertMenu(
920: hMenuShared,
921: (UINT)uPosition,
922: (UINT)(MF_BYPOSITION | MF_POPUP),
923: (UINT)lpServerApp->m_hMenuName,
924: (LPCSTR)"&Name"
925: );
926: uPosition++;
927:
928: fNoError &= InsertMenu(
929: hMenuShared,
930: (UINT)uPosition,
931: (UINT)(MF_BYPOSITION | MF_POPUP),
932: (UINT)lpServerApp->m_hMenuOptions,
933: (LPCSTR)"&Options"
934: );
935: uPosition++;
936:
937: fNoError &= InsertMenu(
938: hMenuShared,
939: (UINT)uPosition,
940: (UINT)(MF_BYPOSITION | MF_POPUP),
941: (UINT)lpServerApp->m_hMenuDebug,
942: (LPCSTR)"DbgI&Svr"
943: );
944: uPosition++;
945:
946: lpWidths[3] = uPosition - uPositionStart;
947:
948: /* Insert HELP group menus */
949:
950: uPosition += (UINT) lpWidths[4]; /* # of menus in WINDOW group */
951: uPositionStart = uPosition;
952:
953: fNoError &= InsertMenu(
954: hMenuShared,
955: (UINT)uPosition,
956: (UINT)(MF_BYPOSITION | MF_POPUP),
957: (UINT)lpServerApp->m_hMenuHelp,
958: (LPCSTR)"&Help"
959: );
960: uPosition++;
961:
962: lpWidths[5] = uPosition - uPositionStart;
963:
964: OleDbgAssert(fNoError == TRUE);
965:
966: } else {
967: /* In-place container does not allow us to add menus to the
968: ** frame.
969: ** OLE2NOTE: even when the in-place container does NOT allow
970: ** the building of a merged menu bar, it is CRITICAL that
971: ** the in-place server still call OleCreateMenuDescriptor
972: ** passing NULL for hMenuShared.
973: */
974: if (hMenuShared) {
975: DestroyMenu(hMenuShared);
976: hMenuShared = NULL;
977: }
978: }
979:
980: lpIPData->hMenuShared = hMenuShared;
981:
982: if (!(lpIPData->hOlemenu = OleCreateMenuDescriptor(hMenuShared,
983: &lpIPData->menuGroupWidths)))
984: return ResultFromScode(E_OUTOFMEMORY);
985:
986: return NOERROR;
987: }
988:
989:
990: void ServerDoc_DisassembleMenus(LPSERVERDOC lpServerDoc)
991: {
992: UINT uCount;
993: UINT uGroup;
994: UINT uDeleteAt;
995: LPINPLACEDATA lpIPData = lpServerDoc->m_lpIPData;
996: LONG FAR* lpWidths = lpIPData->menuGroupWidths.width;
997: BOOL fNoError = TRUE;
998:
999: /* OLE2NOTE: even when hMenuShared is NULL (ie. the server has no
1000: ** Menu), there is still an hOleMenu created that must be destroyed.
1001: */
1002: if (lpIPData->hOlemenu) {
1003: OleDestroyMenuDescriptor (lpIPData->hOlemenu);
1004: lpIPData->hOlemenu = NULL;
1005: }
1006:
1007: if (! lpIPData->hMenuShared)
1008: return; // no menus to be destroyed
1009:
1010: /* Remove server group menus. */
1011: uDeleteAt = 0;
1012: for (uGroup = 0; uGroup < 6; uGroup++) {
1013: uDeleteAt += (UINT)lpWidths[uGroup++];
1014: for (uCount = 0; uCount < (UINT)lpWidths[uGroup]; uCount++)
1015: fNoError &= RemoveMenu(lpIPData->hMenuShared, uDeleteAt,
1016: MF_BYPOSITION);
1017: }
1018:
1019: /* Remove container group menus */
1020: fNoError &= (lpIPData->lpFrame->lpVtbl->RemoveMenus(
1021: lpIPData->lpFrame,
1022: lpIPData->hMenuShared) == NOERROR);
1023:
1024: OleDbgAssert(fNoError == TRUE);
1025:
1026: DestroyMenu(lpIPData->hMenuShared);
1027: lpIPData->hMenuShared = NULL;
1028: }
1029:
1030:
1031: /* ServerDoc_UpdateInPlaceWindowOnExtentChange
1032: ** -------------------------------------------
1033: ** The size of the in-place window needs to be changed.
1034: ** calculate the size required in Client coordinates (taking into
1035: ** account the current scale factor imposed by the in-place
1036: ** container) and ask our in-place container to allow us to resize.
1037: ** our container must call us back via
1038: ** IOleInPlaceObject::SetObjectRects for the actual sizing to take
1039: ** place.
1040: **
1041: ** OLE2NOTE: the rectangle that we ask for from our in-place
1042: ** container is always the rectangle required for the object display
1043: ** itself (in our case the size of the LineList contents). it does
1044: ** NOT include the space we require for object frame adornments.
1045: */
1046: void ServerDoc_UpdateInPlaceWindowOnExtentChange(LPSERVERDOC lpServerDoc)
1047: {
1048: SIZEL sizelHim;
1049: SIZEL sizelPix;
1050: RECT rcPosRect;
1051: LPOUTLINEDOC lpOutlineDoc = (LPOUTLINEDOC)lpServerDoc;
1052: LPLINELIST lpLL=(LPLINELIST)&lpOutlineDoc->m_LineList;
1053: HWND hWndLL = lpLL->m_hWndListBox;
1054: LPSCALEFACTOR lpscale = (LPSCALEFACTOR)&lpOutlineDoc->m_scale;
1055:
1056: if (!lpServerDoc->m_fInPlaceActive)
1057: return;
1058:
1059: OleDoc_GetExtent((LPOLEDOC)lpServerDoc, (LPSIZEL)&sizelHim);
1060:
1061: // apply current scale factor
1062: sizelHim.cx = sizelHim.cx * lpscale->dwSxN / lpscale->dwSxD;
1063: sizelHim.cy = sizelHim.cy * lpscale->dwSxN / lpscale->dwSxD;
1064: XformSizeInHimetricToPixels(NULL, (LPSIZEL)&sizelHim, (LPSIZEL)&sizelPix);
1065:
1066: GetWindowRect(hWndLL, (LPRECT)&rcPosRect);
1067: ScreenToClient(lpServerDoc->m_hWndParent, (POINT FAR *)&rcPosRect);
1068:
1069: rcPosRect.right = rcPosRect.left + (int) sizelPix.cx;
1070: rcPosRect.bottom = rcPosRect.top + (int) sizelPix.cy;
1071:
1072: OleDbgOutRect3("ServerDoc_UpdateInPlaceWindowOnExtentChange: (PosRect)",
1073: (LPRECT)&rcPosRect);
1074:
1075: OLEDBG_BEGIN2("IOleInPlaceSite::OnPosRectChange called\r\n");
1076: lpServerDoc->m_lpIPData->lpSite->lpVtbl->OnPosRectChange(
1077: lpServerDoc->m_lpIPData->lpSite,
1078: (LPRECT) &rcPosRect
1079: );
1080: OLEDBG_END2
1081: }
1082:
1083:
1084: /* ServerDoc_CalcInPlaceWindowPos
1085: * ------------------------------
1086: *
1087: * Move (and re-scale) the ServerDoc to the specified rectangle.
1088: *
1089: * Parameters:
1090: * lprcListBox - rect in client coordinate in which the listbox will fit
1091: * lprcDoc - corresponding size of the Doc in client coordinate
1092: *
1093: */
1094: void ServerDoc_CalcInPlaceWindowPos(
1095: LPSERVERDOC lpServerDoc,
1096: LPRECT lprcListBox,
1097: LPRECT lprcDoc,
1098: LPSCALEFACTOR lpscale
1099: )
1100: {
1101: SIZEL sizelHim;
1102: SIZEL sizelPix;
1103: LPLINELIST lpLL;
1104: LPOUTLINEDOC lpOutlineDoc = (LPOUTLINEDOC)lpServerDoc;
1105: LPHEADING lphead;
1106:
1107: if (!lpServerDoc || !lprcListBox || !lprcDoc)
1108: return;
1109:
1110: lphead = (LPHEADING)&lpOutlineDoc->m_heading;
1111:
1112: lpLL = OutlineDoc_GetLineList(lpOutlineDoc);
1113: OleDoc_GetExtent((LPOLEDOC)lpServerDoc, (LPSIZEL)&sizelHim);
1114: XformSizeInHimetricToPixels(NULL, &sizelHim, &sizelPix);
1115:
1116: if (sizelHim.cx == 0) {
1117: lpscale->dwSxN = 1;
1118: lpscale->dwSxD = 1;
1119: } else {
1120: lpscale->dwSxN = lprcListBox->right - lprcListBox->left;
1121: lpscale->dwSxD = sizelPix.cx;
1122: }
1123:
1124: if (sizelHim.cy == 0) {
1125: lpscale->dwSyN = 1;
1126: lpscale->dwSyD = 1;
1127: } else {
1128: lpscale->dwSyN = lprcListBox->bottom - lprcListBox->top;
1129: lpscale->dwSyD = sizelPix.cy;
1130: }
1131:
1132: lprcDoc->left = lprcListBox->left - Heading_RH_GetWidth(lphead,lpscale);
1133: lprcDoc->right = lprcListBox->right;
1134: lprcDoc->top = lprcListBox->top - Heading_CH_GetHeight(lphead,lpscale);
1135: lprcDoc->bottom = lprcListBox->bottom;
1136: }
1137:
1138:
1139: /* ServerDoc_ResizeInPlaceWindow
1140: ** -----------------------------
1141: ** Actually resize the in-place ServerDoc windows according to the
1142: ** PosRect and ClipRect allowed by our in-place container.
1143: **
1144: ** OLE2NOTE: the PosRect rectangle that our in-place container tells
1145: ** us is always the rectangle required for the object display
1146: ** itself (in our case the size of the LineList contents). it does
1147: ** NOT include the space we require for object frame adornments.
1148: */
1149: void ServerDoc_ResizeInPlaceWindow(
1150: LPSERVERDOC lpServerDoc,
1151: LPCRECT lprcPosRect,
1152: LPCRECT lprcClipRect
1153: )
1154: {
1155: LPOUTLINEDOC lpOutlineDoc = (LPOUTLINEDOC)lpServerDoc;
1156: LPLINELIST lpLL = (LPLINELIST)&lpOutlineDoc->m_LineList;
1157: SCALEFACTOR scale;
1158: RECT rcDoc;
1159: POINT ptOffset;
1160:
1161: /* OLE2NOTE: calculate the space needed for our object frame
1162: ** adornments. our in-place container tells us the size that our
1163: ** object should take in window client coordinates
1164: ** (lprcPosRect). the rectangle cooresponds to the size that our
1165: ** LineList ListBox should be. our Doc window must the correct
1166: ** amount larger to accomodate our row/column headings.
1167: ** then move all windows into position.
1168: */
1169: ServerDoc_CalcInPlaceWindowPos(
1170: lpServerDoc,
1171: (LPRECT)lprcPosRect,
1172: (LPRECT)&rcDoc,
1173: (LPSCALEFACTOR)&scale
1174: );
1175:
1176: /* OLE2NOTE: we need to honor the lprcClipRect specified by our
1177: ** in-place container. we must NOT draw outside of the ClipRect.
1178: ** in order to achieve this, we will size the hatch window to be
1179: ** exactly the size that should be visible (rcVisRect). the
1180: ** rcVisRect is defined as the intersection of the full size of
1181: ** the in-place server window and the lprcClipRect.
1182: ** the ClipRect could infact clip the HatchRect on the
1183: ** right/bottom and/or on the top/left. if it is clipped on the
1184: ** right/bottom then it is sufficient to simply resize the hatch
1185: ** window. but if the HatchRect is clipped on the top/left then
1186: ** we must "move" the ServerDoc window (child of HatchWindow) by
1187: ** the delta that was clipped. the window origin of the
1188: ** ServerDoc window will then have negative coordinates relative
1189: ** to its parent HatchWindow.
1190: */
1191: SetHatchWindowSize(
1192: lpServerDoc->m_hWndHatch,
1193: (LPRECT)&rcDoc,
1194: (LPRECT)lprcClipRect,
1195: (LPPOINT)&ptOffset
1196: );
1197:
1198: // shift Doc window to account for hatch frame being drawn
1199: OffsetRect((LPRECT)&rcDoc, ptOffset.x, ptOffset.y);
1200:
1201: // move/size/set scale factor of ServerDoc window.
1202: OutlineDoc_SetScaleFactor(
1203: lpOutlineDoc, (LPSCALEFACTOR)&scale, (LPRECT)&rcDoc);
1204: }
1205:
1206:
1207:
1208: /* ServerDoc_GetTopInPlaceFrame
1209: ** ----------------------------
1210: ** returns NON-AddRef'ed pointer to Top In-Place Frame interface
1211: */
1212: LPOLEINPLACEFRAME ServerDoc_GetTopInPlaceFrame(LPSERVERDOC lpServerDoc)
1213: {
1214: if (lpServerDoc->m_lpIPData)
1215: return lpServerDoc->m_lpIPData->lpFrame;
1216: else
1217: return NULL;
1218: }
1219:
1220: void ServerDoc_GetSharedMenuHandles(
1221: LPSERVERDOC lpServerDoc,
1222: HMENU FAR* lphSharedMenu,
1223: HOLEMENU FAR* lphOleMenu
1224: )
1225: {
1226: if (lpServerDoc->m_lpIPData) {
1227: *lphSharedMenu = lpServerDoc->m_lpIPData->hMenuShared;
1228: *lphOleMenu = lpServerDoc->m_lpIPData->hOlemenu;
1229: } else {
1230: *lphSharedMenu = NULL;
1231: *lphOleMenu = NULL;
1232: }
1233: }
1234:
1235:
1236: void ServerDoc_AddFrameLevelUI(LPSERVERDOC lpServerDoc)
1237: {
1238: LPOUTLINEAPP lpOutlineApp = (LPOUTLINEAPP)g_lpApp;
1239: LPSERVERAPP lpServerApp = (LPSERVERAPP)g_lpApp;
1240: LPOUTLINEDOC lpOutlineDoc = (LPOUTLINEDOC)lpServerDoc;
1241: LPOLEINPLACEFRAME lpTopIPFrame=ServerDoc_GetTopInPlaceFrame(lpServerDoc);
1242: HMENU hSharedMenu; // combined obj/cntr menu
1243: HOLEMENU hOleMenu; // returned by OleCreateMenuDesc.
1244:
1245: ServerDoc_GetSharedMenuHandles(
1246: lpServerDoc,
1247: &hSharedMenu,
1248: &hOleMenu
1249: );
1250:
1251: lpTopIPFrame->lpVtbl->SetMenu(
1252: lpTopIPFrame,
1253: hSharedMenu,
1254: hOleMenu,
1255: lpOutlineDoc->m_hWndDoc
1256: );
1257:
1258: lpOutlineApp->m_hAccel = lpServerApp->m_hAccelIPSvr;
1259: lpOutlineApp->m_hWndAccelTarget = lpOutlineDoc->m_hWndDoc;
1260:
1261: #if defined( USE_FRAMETOOLS )
1262: ServerDoc_AddFrameLevelTools(lpServerDoc);
1263:
1264: // update toolbar button enable states
1265: OutlineDoc_UpdateFrameToolButtons(lpOutlineDoc);
1266: #endif
1267: }
1268:
1269:
1270: void ServerDoc_AddFrameLevelTools(LPSERVERDOC lpServerDoc)
1271: {
1272: LPOUTLINEAPP lpOutlineApp = (LPOUTLINEAPP)g_lpApp;
1273: LPSERVERAPP lpServerApp = (LPSERVERAPP)g_lpApp;
1274: LPOUTLINEDOC lpOutlineDoc = (LPOUTLINEDOC)lpServerDoc;
1275: LPOLEINPLACEFRAME lpTopIPFrame=ServerDoc_GetTopInPlaceFrame(lpServerDoc);
1276:
1277: #if defined( USE_FRAMETOOLS )
1278: HWND hWndFrame;
1279:
1280: FrameTools_Enable(lpOutlineDoc->m_lpFrameTools, TRUE);
1281:
1282: // if not in-place UI active, add our tools to our own frame.
1283: if (! lpServerDoc->m_fUIActive) {
1284: OutlineDoc_AddFrameLevelTools(lpOutlineDoc);
1285: return;
1286: }
1287:
1288: if ((hWndFrame = OutlineApp_GetFrameWindow(lpOutlineApp)) == NULL) {
1289: /* we could NOT get a valid frame window, so POP our tools up. */
1290:
1291: /* OLE2NOTE: since we are poping up our tools, we MUST inform
1292: ** the top in-place frame window that we need NO tool space
1293: ** BUT that it should NOT put its own tools up. if we were
1294: ** to pass NULL instead of (0,0,0,0), then the container
1295: ** would have the option to leave its own tools up.
1296: */
1297: lpTopIPFrame->lpVtbl->SetBorderSpace(
1298: lpTopIPFrame,
1299: (LPCBORDERWIDTHS)&g_rectNull
1300: );
1301: FrameTools_PopupTools(lpOutlineDoc->m_lpFrameTools);
1302: } else {
1303:
1304: /* OLE2NOTE: we need to negotiate for space and attach our frame
1305: ** level tools to the top-level in-place container's frame window.
1306: */
1307: FrameTools_AttachToFrame(lpOutlineDoc->m_lpFrameTools, hWndFrame);
1308:
1309: FrameTools_NegotiateForSpaceAndShow(
1310: lpOutlineDoc->m_lpFrameTools,
1311: NULL,
1312: lpTopIPFrame
1313: );
1314: }
1315:
1316: #else // ! USE_FRAMETOOLS
1317: /* OLE2NOTE: if you do NOT use frame tools, you MUST inform the top
1318: ** in-place frame window so that it can put back its own tools.
1319: */
1320: lpTopIPFrame->lpVtbl->SetBorderSpace(lpIPData->lpFrame, NULL);
1321: #endif // ! USE_FRAMETOOLS
1322: }
1323:
1324:
1325: #if defined( USE_FRAMETOOLS )
1326:
1327: void ServerDoc_RemoveFrameLevelTools(LPSERVERDOC lpServerDoc)
1328: {
1329: LPOUTLINEDOC lpOutlineDoc = (LPOUTLINEDOC)lpServerDoc;
1330: OleDbgAssert(lpOutlineDoc->m_lpFrameTools != NULL);
1331:
1332: FrameTools_Enable(lpOutlineDoc->m_lpFrameTools, FALSE);
1333: }
1334: #endif // USE_FRAMETOOLS
1335:
1336:
1337:
1338: void ServerDoc_UIActivate (LPSERVERDOC lpServerDoc)
1339: {
1340: if (lpServerDoc->m_fInPlaceActive && !lpServerDoc->m_fUIActive) {
1341: ServerDoc_DoInPlaceActivate(lpServerDoc,
1342: OLEIVERB_UIACTIVATE,
1343: NULL /*lpmsg*/,
1344: lpServerDoc->m_lpOleClientSite
1345: );
1346: OutlineDoc_ShowWindow((LPOUTLINEDOC)lpServerDoc);
1347: }
1348: }
1349:
1350:
1351:
1352: #endif // INPLACE_SVR
1353:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.