![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cntrinpl.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 cntrinpl.c CVS log | Up to [WindowsNT SDKs] / mstools / ole20 / samples / outline |
1.1 root 1: /*************************************************************************
2: **
3: ** OLE 2 Container Sample Code
4: **
5: ** cntrinpl.c
6: **
7: ** This file contains all interfaces, methods and related support
8: ** functions for an In-Place Container application (aka. Visual
9: ** Editing). The in-place Container application includes the following
10: ** implementation objects:
11: **
12: ** ContainerApp Object
13: ** exposed interfaces:
14: ** IOleInPlaceFrame
15: **
16: ** ContainerDoc Object
17: ** support functions only
18: ** (ICntrOtl is an SDI app; it doesn't support a Doc level IOleUIWindow)
19: **
20: ** ContainerLin Object
21: ** exposed interfaces:
22: ** IOleInPlaceSite
23: **
24: ** (c) Copyright Microsoft Corp. 1992 - 1993 All Rights Reserved
25: **
26: *************************************************************************/
27:
28: #include "outline.h"
29:
30: OLEDBGDATA
31:
32: #if defined( INPLACE_CNTR )
33:
34: extern LPOUTLINEAPP g_lpApp;
35: extern BOOL g_fInsideOutContainer;
36: extern RECT g_rectNull;
37:
38: #define NUM_INPLACE_ACCELS 4
39:
40:
41: /*************************************************************************
42: ** ContainerApp::IOleInPlaceFrame interface implementation
43: *************************************************************************/
44:
45: STDMETHODIMP CntrApp_IPFrame_QueryInterface(
46: LPOLEINPLACEFRAME lpThis,
47: REFIID riid,
48: LPVOID FAR* lplpvObj
49: )
50: {
51: SCODE sc = E_NOINTERFACE;
52: LPCONTAINERAPP lpContainerApp =
53: ((struct COleInPlaceFrameImpl FAR*)lpThis)->lpContainerApp;
54:
55: /* The object should not be able to access the other interfaces
56: ** of our App object by doing QI on this interface.
57: */
58: *lplpvObj = NULL;
59: if (IsEqualIID(riid, &IID_IUnknown) ||
60: IsEqualIID(riid, &IID_IOleWindow) ||
61: IsEqualIID(riid, &IID_IOleInPlaceUIWindow) ||
62: IsEqualIID(riid, &IID_IOleInPlaceFrame)) {
63: OleDbgOut4("CntrApp_IPFrame_QueryInterface: IOleInPlaceFrame* RETURNED\r\n");
64: *lplpvObj = (LPVOID) &lpContainerApp->m_OleInPlaceFrame;
65: OleApp_AddRef((LPOLEAPP)lpContainerApp);
66: sc = S_OK;
67: }
68:
69: OleDbgQueryInterfaceMethod(*lplpvObj);
70:
71: return ResultFromScode(sc);
72: }
73:
74:
75: STDMETHODIMP_(ULONG) CntrApp_IPFrame_AddRef(LPOLEINPLACEFRAME lpThis)
76: {
77: OleDbgAddRefMethod(lpThis, "IOleInPlaceFrame");
78:
79: return OleApp_AddRef((LPOLEAPP)g_lpApp);
80: }
81:
82:
83: STDMETHODIMP_(ULONG) CntrApp_IPFrame_Release(LPOLEINPLACEFRAME lpThis)
84: {
85: OleDbgReleaseMethod(lpThis, "IOleInPlaceFrame");
86:
87: return OleApp_Release((LPOLEAPP)g_lpApp);
88: }
89:
90:
91: STDMETHODIMP CntrApp_IPFrame_GetWindow(
92: LPOLEINPLACEFRAME lpThis,
93: HWND FAR* lphwnd
94: )
95: {
96: LPOUTLINEAPP lpOutlineApp = (LPOUTLINEAPP)g_lpApp;
97:
98: OLEDBG_BEGIN2("CntrApp_IPFrame_GetWindow\r\n")
99: *lphwnd = lpOutlineApp->m_hWndApp;
100: OLEDBG_END2
101: return NOERROR;
102: }
103:
104: STDMETHODIMP CntrApp_IPFrame_ContextSensitiveHelp(
105: LPOLEINPLACEFRAME lpThis,
106: BOOL fEnterMode
107: )
108: {
109: OLEDBG_BEGIN2("CntrApp_IPFrame_ContextSensitiveHelp\r\n")
110:
111: #if defined( LATER )
112: LPOLEINPLACEFRAME lpFrame = m_pEItem->m_pAC->GetInPlaceFrame();
113: HRESULT hresult = lpFrame->ContextSensitiveHelp(fEnterMode);
114: lpFrame->Release();
115: #endif // LATER
116:
117: OLEDBG_END2
118: return NOERROR;
119: }
120:
121:
122: STDMETHODIMP CntrApp_IPFrame_GetBorder(
123: LPOLEINPLACEFRAME lpThis,
124: LPRECT lprectBorder
125: )
126: {
127: LPOUTLINEAPP lpOutlineApp = (LPOUTLINEAPP)g_lpApp;
128:
129: OLEDBG_BEGIN2("CntrApp_IPFrame_GetBorder\r\n")
130:
131: OutlineApp_GetFrameRect(lpOutlineApp, lprectBorder);
132:
133: OLEDBG_END2
134: return NOERROR;
135: }
136:
137:
138: STDMETHODIMP CntrApp_IPFrame_RequestBorderSpace(
139: LPOLEINPLACEFRAME lpThis,
140: LPCBORDERWIDTHS lpWidths
141: )
142: {
143: OleDbgOut2("CntrApp_IPFrame_RequestBorderSpace\r\n");
144:
145: #if defined( _DEBUG )
146: {
147: /* FOR DEBUGING PURPOSES ONLY -- we will fail to allow to an
148: ** object to get any frame border space for frame tools if
149: ** our own frame tools are poped up in the tool pallet. this
150: ** is NOT recommended UI behavior but it allows us to test
151: ** in the condition when the frame does not give border
152: ** space for the object. an object in this situation must
153: ** then either popup its tools in a floating pallet, do
154: ** without the tools, or fail to in-place activate.
155: */
156: LPCONTAINERAPP lpContainerApp =
157: ((struct COleInPlaceFrameImpl FAR*)lpThis)->lpContainerApp;
158: LPFRAMETOOLS lpft = OutlineApp_GetFrameTools(
159: (LPOUTLINEAPP)lpContainerApp);
160:
161: if (lpft->m_ButtonBar.m_nState == BARSTATE_POPUP &&
162: lpft->m_FormulaBar.m_nState == BARSTATE_POPUP) {
163: OleDbgOut3(
164: "CntrApp_IPFrame_RequestBorderSpace: allow NO SPACE\r\n");
165: return ResultFromScode(E_FAIL);
166: }
167: }
168: #endif // _DEBUG
169:
170: return NOERROR;
171: }
172:
173:
174: STDMETHODIMP CntrApp_IPFrame_SetBorderSpace(
175: LPOLEINPLACEFRAME lpThis,
176: LPCBORDERWIDTHS lpWidths
177: )
178: {
179: LPCONTAINERAPP lpContainerApp =
180: ((struct COleInPlaceFrameImpl FAR*)lpThis)->lpContainerApp;
181:
182: OLEDBG_BEGIN2("CntrApp_IPFrame_SetBorderSpace\r\n")
183:
184: if (lpWidths == NULL) {
185:
186: /* OLE2NOTE: IOleInPlaceSite::SetBorderSpace(NULL) is called
187: ** when the in-place active object does NOT want any tool
188: ** space. in this situation the in-place container should
189: ** put up its tools.
190: */
191: LPOUTLINEAPP lpOutlineApp = (LPOUTLINEAPP)lpContainerApp;
192: LPCONTAINERDOC lpContainerDoc;
193:
194: lpContainerDoc =(LPCONTAINERDOC)OutlineApp_GetActiveDoc(lpOutlineApp);
195: ContainerDoc_AddFrameLevelTools(lpContainerDoc);
196: } else {
197:
198: // OLE2NOTE: you could do validation of borderwidths here
199:
200: #if defined( _DEBUG )
201: /* FOR DEBUGING PURPOSES ONLY -- we will fail to allow to an
202: ** object to get any frame border space for frame tools if
203: ** our own frame tools are poped up in the tool pallet. this
204: ** is NOT recommended UI behavior but it allows us to test
205: ** in the condition when the frame does not give border
206: ** space for the object. an object in this situation must
207: ** then either popup its tools in a floating pallet, do
208: ** without the tools, or fail to in-place activate.
209: */
210: LPFRAMETOOLS lpft = OutlineApp_GetFrameTools(
211: (LPOUTLINEAPP)lpContainerApp);
212:
213: if ((lpft->m_ButtonBar.m_nState == BARSTATE_POPUP &&
214: lpft->m_FormulaBar.m_nState == BARSTATE_POPUP) &&
215: (lpWidths->top || lpWidths->bottom ||
216: lpWidths->left || lpWidths->right) ) {
217: OleDbgOut3("CntrApp_IPFrame_SetBorderSpace: allow NO SPACE\r\n");
218: OLEDBG_END2
219:
220: OutlineApp_SetBorderSpace(
221: (LPOUTLINEAPP) lpContainerApp,
222: (LPBORDERWIDTHS)&g_rectNull
223: );
224: OLEDBG_END2
225: return ResultFromScode(E_FAIL);
226: }
227: #endif // _DEBUG
228:
229: OutlineApp_SetBorderSpace(
230: (LPOUTLINEAPP) lpContainerApp,
231: (LPBORDERWIDTHS)lpWidths
232: );
233: }
234: OLEDBG_END2
235: return NOERROR;
236: }
237:
238:
239: STDMETHODIMP CntrApp_IPFrame_SetActiveObject(
240: LPOLEINPLACEFRAME lpThis,
241: LPOLEINPLACEACTIVEOBJECT lpActiveObject,
242: LPCSTR lpszObjName
243: )
244: {
245: char szTitle[256];
246: LPCONTAINERAPP lpContainerApp =
247: ((struct COleInPlaceFrameImpl FAR*)lpThis)->lpContainerApp;
248:
249: OLEDBG_BEGIN2("CntrApp_IPFrame_SetActiveObject\r\n")
250:
251: if (lpContainerApp->m_lpIPActiveObj)
252: lpContainerApp->m_lpIPActiveObj->lpVtbl->Release(lpContainerApp->m_lpIPActiveObj);
253:
254: if (lpContainerApp->m_lpIPActiveObj = lpActiveObject)
255: lpContainerApp->m_lpIPActiveObj->lpVtbl->AddRef(lpContainerApp->m_lpIPActiveObj);
256:
257: #if !defined (MDI_VERSION)
258: // MDI apps will change the document window title..
259:
260: if (lpActiveObject) {
261: lstrcpy (szTitle, lpszObjName);
262: lstrcat (szTitle, " in ");
263: lstrcat (szTitle, g_lpApp->m_lpDoc->m_lpszDocTitle);
264: SetWindowText (g_lpApp->m_hWndApp, szTitle);
265:
266: } else {
267: OutlineDoc_SetTitle(g_lpApp->m_lpDoc);
268: }
269:
270: #endif // !defined (MDI_VERSION)
271:
272: OLEDBG_END2
273: return NOERROR;
274: }
275:
276:
277: STDMETHODIMP CntrApp_IPFrame_InsertMenus(
278: LPOLEINPLACEFRAME lpThis,
279: HMENU hMenu,
280: LPOLEMENUGROUPWIDTHS lpMenuWidths
281: )
282: {
283: LPCONTAINERAPP lpContainerApp = (LPCONTAINERAPP)g_lpApp;
284: BOOL fNoError = TRUE;
285:
286: OLEDBG_BEGIN2("CntrApp_IPFrame_InsertMenus\r\n")
287:
288: fNoError &= AppendMenu(hMenu, MF_POPUP, (UINT)lpContainerApp->m_hMenuFile,
289: "&File");
290: fNoError &= AppendMenu(hMenu, MF_POPUP, (UINT)lpContainerApp->m_hMenuView,
291: "O&utline");
292: fNoError &= AppendMenu(hMenu, MF_POPUP,(UINT)lpContainerApp->m_hMenuDebug,
293: "DbgI&Cntr");
294: lpMenuWidths->width[0] = 1;
295: lpMenuWidths->width[2] = 1;
296: lpMenuWidths->width[4] = 1;
297:
298: OLEDBG_END2
299:
300: return (fNoError ? NOERROR : ResultFromScode(E_FAIL));
301: }
302:
303:
304: STDMETHODIMP CntrApp_IPFrame_SetMenu(
305: LPOLEINPLACEFRAME lpThis,
306: HMENU hMenuShared,
307: HOLEMENU hOleMenu,
308: HWND hwndActiveObject
309: )
310: {
311: LPOUTLINEAPP lpOutlineApp = (LPOUTLINEAPP)g_lpApp;
312: HMENU hMenu;
313: HRESULT hrErr;
314:
315: OLEDBG_BEGIN2("CntrApp_IPFrame_InsertMenus\r\n")
316:
317:
318: /* OLE2NOTE: either put up the shared menu (combined menu from
319: ** in-place server and in-place container) or our container's
320: ** normal menu as directed.
321: */
322: if (hOleMenu && hMenuShared)
323: hMenu = hMenuShared;
324: else
325: hMenu = lpOutlineApp->m_hMenuApp;
326:
327: /* OLE2NOTE: SDI apps put menu on frame by calling SetMenu.
328: ** MDI apps would send WM_MDISETMENU message instead.
329: */
330: SetMenu (lpOutlineApp->m_hWndApp, hMenu);
331: OLEDBG_BEGIN2("OleSetMenuDescriptor called\r\n")
332: hrErr = OleSetMenuDescriptor (hOleMenu, lpOutlineApp->m_hWndApp,
333: hwndActiveObject, NULL, NULL);
334: OLEDBG_END2
335:
336: OLEDBG_END2
337: return hrErr;
338: }
339:
340:
341: STDMETHODIMP CntrApp_IPFrame_RemoveMenus(
342: LPOLEINPLACEFRAME lpThis,
343: HMENU hMenu
344: )
345: {
346: LPCONTAINERAPP lpContainerApp = (LPCONTAINERAPP)g_lpApp;
347: BOOL fNoError = TRUE;
348:
349: OLEDBG_BEGIN2("CntrApp_IPFrame_RemoveMenus\r\n")
350:
351: /* Remove container group menus */
352: while (GetMenuItemCount(hMenu))
353: fNoError &= RemoveMenu(hMenu, 0, MF_BYPOSITION);
354:
355: OleDbgAssert(fNoError == TRUE);
356:
357: OLEDBG_END2
358:
359: return (fNoError ? NOERROR : ResultFromScode(E_FAIL));
360: }
361:
362:
363: STDMETHODIMP CntrApp_IPFrame_SetStatusText(
364: LPOLEINPLACEFRAME lpThis,
365: LPCSTR lpszStatusText
366: )
367: {
368: OleDbgOut2("CntrApp_IPFrame_SetStatusText\r\n");
369:
370: // REVIEW: NOT YET IMPLEMENTED
371:
372: return ResultFromScode(E_NOTIMPL);
373: }
374:
375:
376: STDMETHODIMP CntrApp_IPFrame_EnableModeless(
377: LPOLEINPLACEFRAME lpThis,
378: BOOL fEnable
379: )
380: {
381: return NOERROR;
382: }
383:
384:
385: STDMETHODIMP CntrApp_IPFrame_TranslateAccelerator(
386: LPOLEINPLACEFRAME lpThis,
387: LPMSG lpmsg,
388: WORD wID
389: )
390: {
391: LPOUTLINEAPP lpOutlineApp = (LPOUTLINEAPP)g_lpApp;
392: LPCONTAINERAPP lpContainerApp = (LPCONTAINERAPP)g_lpApp;
393: SCODE sc;
394:
395: if (TranslateAccelerator (lpOutlineApp->m_hWndApp,
396: lpContainerApp->m_hAccelIPCntr, lpmsg))
397: sc = S_OK;
398:
399: #if defined (MDI_VERSION)
400: else if (TranslateMDISysAccel(lpOutlineApp->m_hWndMDIClient, lpmsg))
401: sc = S_OK;
402: #endif // MDI_VERSION
403:
404: else
405: sc = S_FALSE;
406:
407: return ResultFromScode(sc);
408: }
409:
410:
411:
412: /*************************************************************************
413: ** ContainerDoc Support Functions
414: *************************************************************************/
415:
416:
417: /* ContainerDoc_UpdateInPlaceObjectRects
418: ** -------------------------------------
419: ** Update the PosRect and ClipRect of the currently in-place active
420: ** object. if there is no object active in-place, then do nothing.
421: **
422: ** OLE2NOTE: this function should be called when an action occurs
423: ** that changes either the position of the object in the document
424: ** (eg. changing document margins changes PosRect) or the clipRect
425: ** changes (eg. resizing the document window changes the ClipRect).
426: */
427: void ContainerDoc_UpdateInPlaceObjectRects(LPCONTAINERDOC lpContainerDoc, int nIndex)
428: {
429: LPLINELIST lpLL = &((LPOUTLINEDOC)lpContainerDoc)->m_LineList;
430: int i;
431: LPLINE lpLine;
432: RECT rcClipRect;
433:
434: if (g_fInsideOutContainer) {
435:
436: if (lpContainerDoc->m_cIPActiveObjects) {
437:
438: /* OLE2NOTE: (INSIDE-OUT CONTAINER) we must update the
439: ** PosRect/ClipRect for all in-place active objects
440: ** starting from line "nIndex".
441: */
442:
443: ContainerDoc_GetClipRect(lpContainerDoc, (LPRECT)&rcClipRect);
444:
445: OleDbgOutRect3(
446: "OutlineDoc_Resize (ClipRect)", (LPRECT)&rcClipRect);
447:
448: for (i = nIndex; i < lpLL->m_nNumLines; i++) {
449: lpLine=LineList_GetLine(lpLL, i);
450:
451: if (lpLine && (Line_GetLineType(lpLine)==CONTAINERLINETYPE)) {
452: LPCONTAINERLINE lpContainerLine = (LPCONTAINERLINE)lpLine;
453: ContainerLine_UpdateInPlaceObjectRects(
454: lpContainerLine, &rcClipRect);
455: }
456: }
457: }
458: }
459: else {
460: /* OLE2NOTE: (OUTSIDE-IN CONTAINER) if there is a currently
461: ** UIActive object, we must inform it that the
462: ** PosRect/ClipRect has now changed.
463: */
464: LPCONTAINERLINE lpLastUIActiveLine =
465: lpContainerDoc->m_lpLastUIActiveLine;
466: if (lpLastUIActiveLine && lpLastUIActiveLine->m_fUIActive) {
467: ContainerDoc_GetClipRect(lpContainerDoc, (LPRECT)&rcClipRect);
468:
469: OleDbgOutRect3(
470: "OutlineDoc_Resize (ClipRect)", (LPRECT)&rcClipRect);
471: ContainerLine_UpdateInPlaceObjectRects(
472: lpLastUIActiveLine, &rcClipRect);
473: }
474: }
475: }
476:
477: /* ContainerDoc_IsUIDeactivateNeeded
478: ** ---------------------------------
479: ** Check if it is necessary to UIDeactivate an in-place active
480: ** object upon a mouse LBUTTONDOWN event. The position of the button
481: ** down click is given by "pt".
482: ** If there is not currently an in-place active line, then
483: ** UIDeactivate is NOT needed.
484: ** If there is a current in-place active line, then check if the
485: ** point position is outside of the object extents on the screen. If
486: ** so, then the object should be UIDeactivated, otherwise not.
487: */
488: BOOL ContainerDoc_IsUIDeactivateNeeded(
489: LPCONTAINERDOC lpContainerDoc,
490: POINT pt
491: )
492: {
493: LPCONTAINERLINE lpUIActiveLine=lpContainerDoc->m_lpLastUIActiveLine;
494: RECT rect;
495:
496: if (! lpUIActiveLine || ! lpUIActiveLine->m_fUIActive)
497: return FALSE;
498:
499: ContainerLine_GetOleObjectRectInPixels(
500: lpUIActiveLine,
501: (LPRECT) &rect
502: );
503:
504: if (! PtInRect((LPRECT) &rect, pt))
505: return TRUE;
506:
507: return FALSE;
508: }
509:
510:
511: /* ContainerDoc_ShutDownLastInPlaceServerIfNotNeeded
512: ** -------------------------------------------------
513: ** OLE2NOTE: this function ONLY applies for OUTSIDE-IN containers
514: **
515: ** If there is a previous in-place active server still running and
516: ** this server will not be needed to support the next OLE object
517: ** about to be activated, then shut it down.
518: ** in this way we manage a policy of having at most one in-place
519: ** server running at a time. we do not imediately shut down the
520: ** in-place server when the object is UIDeactivated because we want
521: ** it to be fast if the server decides to re-activate the object
522: ** in-place.
523: **
524: ** shutting down the server is achieved by forcing the object to
525: ** transition from running to loaded by calling IOleObject::Close.
526: */
527: void ContainerDoc_ShutDownLastInPlaceServerIfNotNeeded(
528: LPCONTAINERDOC lpContainerDoc,
529: LPCONTAINERLINE lpNextActiveLine
530: )
531: {
532: LPCONTAINERLINE lpLastIpActiveLine = lpContainerDoc->m_lpLastIpActiveLine;
533: BOOL fEnableServerShutDown = TRUE;
534: LPMONIKER lpmkLinkSrc;
535: LPMONIKER lpmkLastActiveObj;
536: LPMONIKER lpmkCommonPrefix;
537: LPOLELINK lpOleLink;
538: HRESULT hrErr;
539:
540: /* OLE2NOTE: an inside-out style container can NOT use this scheme
541: ** to shut down in-place servers. it would have to have a more
542: ** sophistocated mechanism by which it keeps track of which
543: ** objects are on screen and which were the last recently used.
544: */
545: if (g_fInsideOutContainer)
546: return;
547:
548: if (lpLastIpActiveLine != lpNextActiveLine) {
549: if (lpLastIpActiveLine) {
550:
551: /* OLE2NOTE: if the object which is about to be activated is
552: ** actually a link to the OLE object in last activated line,
553: ** then we do NOT want to shut down the last activated
554: ** server because it is about to be used. when activating a
555: ** linked object, the source of the link gets activated.
556: */
557: lpOleLink = (LPOLELINK)ContainerLine_GetOleObject(
558: lpNextActiveLine,
559: &IID_IOleLink
560: );
561: if (lpOleLink) {
562: OLEDBG_BEGIN2("IOleObject::GetSourceMoniker called\r\n")
563: lpOleLink->lpVtbl->GetSourceMoniker(
564: lpOleLink,
565: (LPMONIKER FAR*)&lpmkLinkSrc
566: );
567: OLEDBG_END2
568:
569: if (lpmkLinkSrc) {
570: lpmkLastActiveObj = ContainerLine_GetFullMoniker(
571: lpLastIpActiveLine,
572: GETMONIKER_ONLYIFTHERE
573: );
574: if (lpmkLastActiveObj) {
575: hrErr = lpmkLinkSrc->lpVtbl->CommonPrefixWith(
576: lpmkLinkSrc,
577: lpmkLastActiveObj,
578: &lpmkCommonPrefix
579:
580: );
581: if (GetScode(hrErr) == MK_S_HIM ||
582: GetScode(hrErr) == MK_S_US) {
583: /* the link source IS to the object
584: ** contained in the last activated
585: ** line of the document; disable the
586: ** attempt to shut down the last
587: ** running in-place server.
588: */
589: fEnableServerShutDown = FALSE;
590: }
591: if (lpmkCommonPrefix)
592: OleStdRelease((LPUNKNOWN)lpmkCommonPrefix);
593: OleStdRelease((LPUNKNOWN)lpmkLastActiveObj);
594: }
595: OleStdRelease((LPUNKNOWN)lpmkLinkSrc);
596: }
597: OleStdRelease((LPUNKNOWN)lpOleLink);
598: }
599:
600: /* if it is OK to shut down the previous in-place server
601: ** and one is still running, then shut it down. shutting
602: ** down the server is accomplished by forcing the OLE
603: ** object to close. this forces the object to transition
604: ** from running to loaded. if the object is actually
605: ** only loaded then this is a NOP.
606: */
607: if (fEnableServerShutDown &&
608: lpLastIpActiveLine->m_fIpServerRunning) {
609:
610: OleDbgOut1("@@@ previous in-place server SHUT DOWN\r\n");
611: ContainerLine_CloseOleObject(lpLastIpActiveLine);
612:
613: // we can now forget this last in-place active line.
614: lpContainerDoc->m_lpLastIpActiveLine = NULL;
615: }
616: }
617: }
618: }
619:
620:
621: /* ContainerDoc_GetUIActiveWindow
622: ** ------------------------------
623: ** If there is an UIActive object, then return its HWND.
624: */
625: HWND ContainerDoc_GetUIActiveWindow(LPCONTAINERDOC lpContainerDoc)
626: {
627: return lpContainerDoc->m_hwndUIActiveObj;
628: }
629:
630:
631: /* ContainerDoc_GetClipRect
632: ** ------------------------
633: ** Get the ClipRect in client coordinates.
634: **
635: ** OLE2NOTE: the ClipRect is defined as the maximum window rectangle
636: ** that the in-place active object must be clipped to. this
637: ** rectangle MUST be described in Client Coordinates of the window
638: ** that is used as the Parent of the in-place active object's
639: ** window. in our case, the LineList ListBox window is both the
640: ** parent of the in-place active object AND defines precisely the
641: ** clipping rectangle.
642: */
643: void ContainerDoc_GetClipRect(
644: LPCONTAINERDOC lpContainerDoc,
645: LPRECT lprcClipRect
646: )
647: {
648: LPLINELIST lpLL = &((LPOUTLINEDOC)lpContainerDoc)->m_LineList;
649:
650: /* OLE2NOTE: the ClipRect can be used to ensure that the in-place
651: ** server does not overwrite areas of the window that the
652: ** container paints into but which should never be overwritten
653: ** (eg. if an app were to paint row and col headings directly in
654: ** the same window that is the parent of the in-place window.
655: ** whenever the window size changes or gets scrolled, in-place
656: ** active object must be informed of the new clip rect.
657: **
658: ** normally an app would pass the rect returned from GetClientRect.
659: ** but because CntrOutl uses separate windows for row/column
660: ** headings, status line, formula/tool bars, etc. it is NOT
661: ** necessary to pass a constrained clip rect. Windows standard
662: ** window clipping will automatically take care of all clipping
663: ** that is necessary. thus we can take a short cut of passing an
664: ** "infinite" clip rect, and then we do NOT need to call
665: ** IOleInPlaceObject::SetObjectRects when our document is scrolled.
666: */
667:
668: lprcClipRect->top = 0;
669: lprcClipRect->left = 0;
670: lprcClipRect->right = 32767;
671: lprcClipRect->bottom = 32767;
672: }
673:
674:
675: /* ContainerDoc_GetTopInPlaceFrame
676: ** -------------------------------
677: ** returns NON-AddRef'ed pointer to Top In-Place Frame interface
678: */
679: LPOLEINPLACEFRAME ContainerDoc_GetTopInPlaceFrame(
680: LPCONTAINERDOC lpContainerDoc
681: )
682: {
683: #if defined( INPLACE_CNTRSVR )
684: return lpContainerDoc->m_lpTopIPFrame;
685: #else
686: return (LPOLEINPLACEFRAME)&((LPCONTAINERAPP)g_lpApp)->m_OleInPlaceFrame;
687: #endif
688: }
689:
690: void ContainerDoc_GetSharedMenuHandles(
691: LPCONTAINERDOC lpContainerDoc,
692: HMENU FAR* lphSharedMenu,
693: HOLEMENU FAR* lphOleMenu
694: )
695: {
696: #if defined( INPLACE_CNTRSVR )
697: if (lpContainerDoc->m_DocType == DOCTYPE_EMEBEDDEDOBJECT) {
698: *lphSharedMenu = lpContainerDoc->m_hSharedMenu;
699: *lphOleMenu = lpContainerDoc->m_hOleMenu;
700: return;
701: }
702: #endif
703:
704: *lphSharedMenu = NULL;
705: *lphOleMenu = NULL;
706: }
707:
708:
709: #if defined( USE_FRAMETOOLS )
710: void ContainerDoc_RemoveFrameLevelTools(LPCONTAINERDOC lpContainerDoc)
711: {
712: LPOUTLINEDOC lpOutlineDoc = (LPOUTLINEDOC)lpContainerDoc;
713: OleDbgAssert(lpOutlineDoc->m_lpFrameTools != NULL);
714:
715: FrameTools_Enable(lpOutlineDoc->m_lpFrameTools, FALSE);
716: }
717: #endif
718:
719:
720: void ContainerDoc_AddFrameLevelUI(LPCONTAINERDOC lpContainerDoc)
721: {
722: LPOUTLINEDOC lpOutlineDoc = (LPOUTLINEDOC)lpContainerDoc;
723: LPOLEINPLACEFRAME lpTopIPFrame = ContainerDoc_GetTopInPlaceFrame(
724: lpContainerDoc);
725: HMENU hSharedMenu; // combined obj/cntr menu
726: HOLEMENU hOleMenu; // returned by OleCreateMenuDesc.
727:
728: ContainerDoc_GetSharedMenuHandles(
729: lpContainerDoc,
730: &hSharedMenu,
731: &hOleMenu
732: );
733:
734: lpTopIPFrame->lpVtbl->SetMenu(
735: lpTopIPFrame,
736: hSharedMenu,
737: hOleMenu,
738: lpOutlineDoc->m_hWndDoc
739: );
740:
741: /* OLE2NOTE: even if our app does NOT use FrameTools, we must still
742: ** call IOleInPlaceFrame::SetBorderSpace.
743: */
744: ContainerDoc_AddFrameLevelTools(lpContainerDoc);
745: }
746:
747:
748: void ContainerDoc_AddFrameLevelTools(LPCONTAINERDOC lpContainerDoc)
749: {
750: LPOLEINPLACEFRAME lpTopIPFrame = ContainerDoc_GetTopInPlaceFrame(
751: lpContainerDoc);
752: LPCONTAINERAPP lpContainerApp = (LPCONTAINERAPP)g_lpApp;
753: LPOUTLINEDOC lpOutlineDoc = (LPOUTLINEDOC)lpContainerDoc;
754:
755: OleDbgAssert(lpTopIPFrame != NULL);
756:
757: #if defined( USE_FRAMETOOLS )
758:
759: FrameTools_Enable(lpOutlineDoc->m_lpFrameTools, TRUE);
760:
761: FrameTools_NegotiateForSpaceAndShow(
762: lpOutlineDoc->m_lpFrameTools,
763: NULL,
764: lpTopIPFrame
765: );
766:
767: #else // ! USE_FRAMETOOLS
768:
769: #if defined( INPLACE_CNTRSVR )
770: if (lpContainerDoc->m_DocType == DOCTYPE_EMBEDDEDOBJECT) {
771: /* this says i do not need space, so the top Frame should
772: ** leave its tools behind
773: */
774: OLEDBG_BEGIN2("IOleInPlaceFrame::SetBorderSpace(NULL) called\r\n")
775: lpTopIPFrame->lpVtbl->SetBorderSpace(lpTopIPFrame, NULL);
776: OLEDBG_END2
777: return;
778: }
779: #else // INPLACE_CNTR && ! USE_FRAMETOOLS
780:
781: OLEDBG_BEGIN2("IOleInPlaceFrame::SetBorderSpace(0,0,0,0) called\r\n")
782: lpTopIPFrame->lpVtbl->SetBorderSpace(
783: lpTopIPFrame,
784: (LPCBORDERWIDTHS)&g_rectNull
785: );
786: OLEDBG_END2
787:
788: #endif // INPLACE_CNTR && ! USE_FRAMETOOLS
789: #endif // ! USE_FRAMETOOLS
790:
791: }
792:
793:
794: void ContainerDoc_FrameWindowResized(LPCONTAINERDOC lpContainerDoc)
795: {
796: LPCONTAINERAPP lpContainerApp = (LPCONTAINERAPP)g_lpApp;
797:
798: if (lpContainerApp->m_lpIPActiveObj) {
799: RECT rcFrameRect;
800:
801: OutlineApp_GetFrameRect(g_lpApp, (LPRECT)&rcFrameRect);
802:
803: OLEDBG_BEGIN2("IOleInPlaceActiveObject::ResizeBorder called\r\n")
804: lpContainerApp->m_lpIPActiveObj->lpVtbl->ResizeBorder(
805: lpContainerApp->m_lpIPActiveObj,
806: (LPCRECT)&rcFrameRect,
807: (LPOLEINPLACEUIWINDOW)&lpContainerApp->m_OleInPlaceFrame,
808: TRUE /* fFrameWindow */
809: );
810: OLEDBG_END2
811: }
812:
813: #if defined( USE_FRAMETOOLS )
814: else {
815: ContainerDoc_AddFrameLevelTools(lpContainerDoc);
816: }
817: #endif
818: }
819:
820:
821: #if defined( INPLACE_CNTRSVR ) || defined( INPLACE_MDICNTR )
822:
823: /* ContainerDoc_GetTopInPlaceDoc
824: ** returns NON-AddRef'ed pointer to Top In-Place Doc interface
825: */
826: LPOLEINPLACEUIWINDOW ContainerDoc_GetTopInPlaceDoc(
827: LPCONTAINERDOC lpContainerDoc
828: )
829: {
830: #if defined( INPLACE_CNTRSVR )
831: return lpContainerDoc->m_lpTopIPDoc;
832: #else
833: return (LPOLEINPLACEUIWINDOW)&lpContainerDoc->m_OleInPlaceDoc;
834: #endif
835: }
836:
837:
838: void ContainerDoc_RemoveDocLevelTools(LPCONTAINERDOC lpContainerDoc);
839: {
840: LPOLEINPLACEUIWINDOW lpTopIPDoc = ContainerDoc_GetTopInPlaceDoc(
841: lpContainerDoc);
842:
843: if (lpTopIPDoc && lpContainerDoc->m_fMyToolsOnDoc) {
844: lpContainerDoc->m_fMyToolsOnDoc = FALSE;
845:
846: // if we had doc tools we would HIDE them here;
847: // but NOT call SetBorderSpace(NULL)
848:
849: }
850: }
851:
852: void ContainerDoc_AddDocLevelTools(LPCONTAINERDOC lpContainerDoc)
853: {
854: LPOLEINPLACEUIWINDOW lpTopIPDoc = ContainerDoc_GetTopInPlaceDoc(
855: lpContainerDoc);
856:
857: if (! lpTopIPDoc)
858: return;
859:
860: #if defined( USE_DOCTOOLS )
861: if (lpTopIPDoc && ! lpContainerDoc->m_fMyToolsOnDoc) {
862:
863: /* if we had doc tools we would negotiate for toolbar space at
864: ** doc level and SHOW them.
865: */
866:
867: /* we do NOT have doc level tools, so we just call
868: ** SetBorderSpace() to indicate to the top doc that
869: ** our object does not need tool space.
870: */
871:
872: lpContainerDoc->m_fMyToolsOnDoc = TRUE;
873: return;
874: }
875: #else // ! USE_DOCTOOLS
876:
877: #if defined( INPLACE_CNTRSVR )
878: if (lpContainerDoc->m_DocType == DOCTYPE_EMBEDDEDOBJECT) {
879: /* this says i do not need space, so the top doc should
880: ** leave its tools behind
881: */
882: lpTopIPDoc->lpVtbl->SetBorderSpace(lpTopIPDoc, NULL);
883: return;
884: }
885: #else
886: lpTopIPDoc->lpVtbl->SetBorderSpace(
887: lpTopIPDoc,
888: (LPCBORDERWIDTHS)&g_rectNull
889: );
890:
891: #endif
892: #endif // ! USE_DOCTOOLS
893: }
894:
895: #endif // INPLACE_CNTRSVR || INPLACE_MDICNTR
896:
897:
898:
899: /*************************************************************************
900: ** ContainerLine Support Functions and Interfaces
901: *************************************************************************/
902:
903:
904: /* ContainerLine_UIDeactivate
905: ** --------------------------
906: ** tell the OLE object associated with the ContainerLine to
907: ** UIDeactivate. this informs the in-place server to tear down
908: ** the UI and window that it put up for the object. it will remove
909: ** its active editor menus and any frame and object adornments
910: ** (eg. toolbars, rulers, etc.).
911: */
912: void ContainerLine_UIDeactivate(LPCONTAINERLINE lpContainerLine)
913: {
914: HRESULT hrErr;
915:
916: if (!lpContainerLine || !lpContainerLine->m_fUIActive)
917: return;
918:
919: OLEDBG_BEGIN2("IOleInPlaceObject::UIDeactivate called\r\n")
920: hrErr = lpContainerLine->m_lpOleIPObj->lpVtbl->UIDeactivate(
921: lpContainerLine->m_lpOleIPObj);
922: OLEDBG_END2
923:
924: if (hrErr != NOERROR) {
925: OleDbgOutHResult("IOleInPlaceObject::UIDeactivate returned", hrErr);
926: return;
927: }
928: #if defined( UNDOSUPPORTED )
929:
930: /* OLE2NOTE: an outside-in style container that supports UNDO would
931: ** call IOleObject::DoVerb(OLEIVERB_HIDE) to make the in-place
932: ** object go invisible. when it wants the in-place active object
933: ** to discard its undo state, it would call
934: ** IOleInPlaceObject::InPlaceDeactivate when it wants the object
935: ** to discard its undo state. there is no need for an outside-in
936: ** style container to call
937: ** IOleObject::DoVerb(OLEIVERB_DISCARDUNDOSTATE). if either the
938: ** container or the object do not support UNDO, then the
939: ** container might as well immediately call InPlaceDeactivate
940: ** instead of calling DoVerb(HIDE).
941: **
942: ** an inside-out style container that supports UNDO would simply
943: ** UIDeactivate the object. it would call
944: ** IOleObject::DoVerb(OLEIVERB_DISCARDUNDOSTATE) when it wants
945: ** the object discard its undo state. it would call
946: ** IOleInPlaceObject::InPlaceDeactivate if it wants the object
947: ** to take down its window.
948: */
949: if (! g_fInsideOutContainer) {
950: if (lpContainerLine->m_fIpChangesUndoable) {
951: ContainerLine_DoVerb(lpContainerLine,OLEIVERB_HIDE,FALSE,FALSE);
952: } else {
953: lpContainerLine->m_lpOleIPObj->lpVtbl->InPlaceDeactivate(
954: lpContainerLine->m_lpOleIPObj);
955: }
956: lpContainerLine->m_fIpVisible = FALSE;
957: }
958: #else
959:
960:
961: /* OLE2NOTE: an outside-in style container that does NOT support
962: ** UNDO would immediately tell the UIDeactivated server (UI
963: ** removed) to IOleInPlaceObject::InPlaceDeactivate.
964: **
965: ** an inside-out style container that does NOT support UNDO
966: ** would call IOleObject::DoVerb(OLEIVERB_DISCARDUNDOSTATE) to
967: ** tell the object to discard its undo state. it would call
968: ** IOleInPlaceObject::InPlaceDeactivate if it wants the object
969: ** to take down its window.
970: */
971:
972: if (g_fInsideOutContainer) {
973:
974: if (lpContainerLine->m_fInsideOutObj) {
975:
976: if (lpContainerLine->m_fIpChangesUndoable) {
977: OLEDBG_BEGIN3("ContainerLine_DoVerb(OLEIVERB_DISCARDUNDOSTATE) called!\r\n")
978: ContainerLine_DoVerb(
979: lpContainerLine,OLEIVERB_DISCARDUNDOSTATE,FALSE,FALSE);
980: OLEDBG_END3
981: }
982:
983: } else { // !fInsideOutObj
984:
985: /* OLE2NOTE: (INSIDEOUT CONTAINER) if the object is not
986: ** registered OLEMISC_ACTIVATEWHENVISIBLE, then we will
987: ** make the object behave in an outside-in manner. since
988: ** we do NOT deal with UNDO we can simply
989: ** InPlaceDeactivate the object. it should NOT be
990: ** allowed to leave its window visible when
991: ** UIDeactivated.
992: */
993: OLEDBG_BEGIN2("IOleInPlaceObject::InPlaceDeactivate called\r\n")
994: hrErr = lpContainerLine->m_lpOleIPObj->lpVtbl->InPlaceDeactivate(
995: lpContainerLine->m_lpOleIPObj);
996: OLEDBG_END2
997: if (hrErr != NOERROR) {
998: OleDbgOutHResult("IOleInPlaceObject::InPlaceDeactivate returned", hrErr);
999: }
1000: }
1001:
1002: } else {
1003:
1004: /* OLE2NOTE: (OUTSIDE-IN CONTAINER) since we do NOT deal with
1005: ** UNDO we can simply InPlaceDeactivate the object. it
1006: ** should NOT be allowed to leave its window visible when
1007: ** UIDeactivated.
1008: */
1009: OLEDBG_BEGIN2("IOleInPlaceObject::InPlaceDeactivate called\r\n")
1010: hrErr = lpContainerLine->m_lpOleIPObj->lpVtbl->InPlaceDeactivate(
1011: lpContainerLine->m_lpOleIPObj);
1012: OLEDBG_END2
1013: if (hrErr != NOERROR) {
1014: OleDbgOutHResult("IOleInPlaceObject::InPlaceDeactivate returned", hrErr);
1015: }
1016: }
1017:
1018: #endif // ! UNDOSUPPORTED
1019: }
1020:
1021:
1022:
1023: /* ContainerLine_UpdateInPlaceObjectRects
1024: ** -------------------------------------
1025: ** Update the PosRect and ClipRect of the given line
1026: ** currently in-place active
1027: ** object. if there is no object active in-place, then do nothing.
1028: **
1029: ** OLE2NOTE: this function should be called when an action occurs
1030: ** that changes either the position of the object in the document
1031: ** (eg. changing document margins changes PosRect) or the clipRect
1032: ** changes (eg. resizing the document window changes the ClipRect).
1033: */
1034: void ContainerLine_UpdateInPlaceObjectRects(
1035: LPCONTAINERLINE lpContainerLine,
1036: LPRECT lprcClipRect
1037: )
1038: {
1039: LPCONTAINERDOC lpContainerDoc = lpContainerLine->m_lpDoc;
1040: RECT rcClipRect;
1041: RECT rcPosRect;
1042:
1043:
1044: if (! lpContainerLine->m_fIpActive)
1045: return;
1046:
1047: if (! lprcClipRect) {
1048: ContainerDoc_GetClipRect(lpContainerDoc, (LPRECT)&rcClipRect);
1049: lprcClipRect = (LPRECT)&rcClipRect;
1050: }
1051:
1052: OleDbgOutRect3("OutlineDoc_Resize (ClipRect)", (LPRECT)&rcClipRect);
1053:
1054:
1055: ContainerLine_GetOleObjectRectInPixels(
1056: lpContainerLine,(LPRECT)&rcPosRect);
1057:
1058: OleDbgOutRect3(
1059: "ContainerLine_UpdateInPlaceObjectRects (PosRect)", (LPRECT)&rcPosRect);
1060:
1061: OLEDBG_BEGIN2("IOleInPlaceObject::SetObjectRects called\r\n")
1062: lpContainerLine->m_lpOleIPObj->lpVtbl->SetObjectRects(
1063: lpContainerLine->m_lpOleIPObj,
1064: (LPRECT)&rcPosRect,
1065: lprcClipRect
1066: );
1067: OLEDBG_END2
1068: }
1069:
1070:
1071:
1072: /*************************************************************************
1073: ** ContainerLine::IOleInPlaceSite interface implementation
1074: *************************************************************************/
1075:
1076: STDMETHODIMP CntrLine_IPSite_QueryInterface(
1077: LPOLEINPLACESITE lpThis,
1078: REFIID riid,
1079: LPVOID FAR* lplpvObj
1080: )
1081: {
1082: LPCONTAINERLINE lpContainerLine =
1083: ((struct COleInPlaceSiteImpl FAR*)lpThis)->lpContainerLine;
1084:
1085: return ContainerLine_QueryInterface(lpContainerLine, riid, lplpvObj);
1086: }
1087:
1088:
1089: STDMETHODIMP_(ULONG) CntrLine_IPSite_AddRef(LPOLEINPLACESITE lpThis)
1090: {
1091: LPCONTAINERLINE lpContainerLine =
1092: ((struct COleInPlaceSiteImpl FAR*)lpThis)->lpContainerLine;
1093:
1094: OleDbgAddRefMethod(lpThis, "IOleInPlaceSite");
1095:
1096: return ContainerLine_AddRef(lpContainerLine);
1097: }
1098:
1099:
1100: STDMETHODIMP_(ULONG) CntrLine_IPSite_Release(LPOLEINPLACESITE lpThis)
1101: {
1102: LPCONTAINERLINE lpContainerLine =
1103: ((struct COleInPlaceSiteImpl FAR*)lpThis)->lpContainerLine;
1104:
1105: OleDbgReleaseMethod(lpThis, "IOleInPlaceSite");
1106:
1107: return ContainerLine_Release(lpContainerLine);
1108: }
1109:
1110:
1111: STDMETHODIMP CntrLine_IPSite_GetWindow(
1112: LPOLEINPLACESITE lpThis,
1113: HWND FAR* lphwnd
1114: )
1115: {
1116: LPCONTAINERLINE lpContainerLine =
1117: ((struct COleInPlaceSiteImpl FAR*)lpThis)->lpContainerLine;
1118:
1119: OleDbgOut2("CntrLine_IPSite_GetWindow\r\n");
1120:
1121: *lphwnd = LineList_GetWindow(&((LPOUTLINEDOC)lpContainerLine->m_lpDoc)->m_LineList);
1122: return NOERROR;
1123: }
1124:
1125: STDMETHODIMP CntrLine_IPSite_ContextSensitiveHelp(
1126: LPOLEINPLACESITE lpThis,
1127: BOOL fEnterMode
1128: )
1129: {
1130: OleDbgOut2("CntrLine_IPSite_ContextSensitiveHelp\r\n");
1131:
1132: #if defined( LATER )
1133: LPOLEINPLACEFRAME lpFrame = m_pEItem->m_pAC->GetInPlaceFrame();
1134: HRESULT hrErr = lpFrame->ContextSensitiveHelp(fEnterMode);
1135: lpFrame->Release();
1136: #endif // LATER
1137: return NOERROR;
1138: }
1139:
1140: STDMETHODIMP CntrLine_IPSite_CanInPlaceActivate(LPOLEINPLACESITE lpThis)
1141: {
1142: LPCONTAINERLINE lpContainerLine =
1143: ((struct COleInPlaceSiteImpl FAR*)lpThis)->lpContainerLine;
1144:
1145: OleDbgOut2("CntrLine_IPSite_CanInPlaceActivate\r\n");
1146:
1147: /* OLE2NOTE: the container can NOT allow in-place activation if it
1148: ** is currently displaying the object as an ICON
1149: ** (DVASPECT_ICON). it can ONLY do in-place activation if it is
1150: ** displaying the DVASPECT_CONTENT of the OLE object.
1151: */
1152: if (lpContainerLine->m_dwDrawAspect == DVASPECT_CONTENT)
1153: return NOERROR;
1154: else
1155: return ResultFromScode(S_FALSE);
1156: }
1157:
1158: STDMETHODIMP CntrLine_IPSite_OnInPlaceActivate(LPOLEINPLACESITE lpThis)
1159: {
1160: LPCONTAINERLINE lpContainerLine =
1161: ((struct COleInPlaceSiteImpl FAR*)lpThis)->lpContainerLine;
1162: LPCONTAINERDOC lpContainerDoc = lpContainerLine->m_lpDoc;
1163: SCODE sc = S_OK;
1164:
1165: OLEDBG_BEGIN2("CntrLine_IPSite_OnInPlaceActivate\r\n");
1166:
1167: /* OLE2NOTE: (OUTSIDE-IN CONTAINER) as a policy for managing
1168: ** running in-place servers, we will keep only 1 inplace server
1169: ** active at any given time. so when we start to inp-place activate
1170: ** another line, then we want to shut down the previously
1171: ** activated server. in this way we keep at most one inplace
1172: ** server active at a time. this is NOT a required policy. apps
1173: ** may choose to have a more sophisticated strategy. inside-out
1174: ** containers will HAVE to have a more sophisticated strategy,
1175: ** because they need (at a minimum) to keep all visible object
1176: ** servers running.
1177: **
1178: ** if the in-place activation is the result of activating a
1179: ** linked object in another container, then we may arrive at
1180: ** this method while another object is currently active.
1181: ** normally, if the object is in-place activated by
1182: ** double-clicking or Edit.<verb> from our own container, then
1183: ** the previous in-place object would have been de-activated in
1184: ** ContainerLine_DoVerb method.
1185: */
1186: if (!g_fInsideOutContainer) {
1187: if (lpContainerDoc->m_lpLastIpActiveLine) {
1188: ContainerDoc_ShutDownLastInPlaceServerIfNotNeeded(
1189: lpContainerDoc, lpContainerLine);
1190: }
1191: lpContainerDoc->m_lpLastIpActiveLine = lpContainerLine;
1192: }
1193:
1194: lpContainerLine->m_fIpActive = TRUE;
1195: lpContainerLine->m_fIpVisible = TRUE;
1196: lpContainerLine->m_fIpServerRunning = TRUE;
1197:
1198: /* OLE2NOTE: to avoid LRPC problems it is important to cache the
1199: ** IOleInPlaceObject* pointer and NOT to call QueryInterface
1200: ** each time it is needed.
1201: */
1202: lpContainerLine->m_lpOleIPObj =
1203: (LPOLEINPLACEOBJECT) ContainerLine_GetOleObject (
1204: lpContainerLine,
1205: &IID_IOleInPlaceObject
1206: );
1207:
1208: OleDbgAssertSz(
1209: lpContainerLine->m_lpOleIPObj!=NULL,
1210: "OLE object must support IOleInPlaceObject"
1211: );
1212: if (! lpContainerLine->m_lpOleIPObj)
1213: return ResultFromScode(E_FAIL); // ERROR: refuse to in-place activate
1214:
1215: OLEDBG_END2
1216:
1217: lpContainerLine->m_lpDoc->m_cIPActiveObjects++;
1218: return NOERROR;
1219: }
1220:
1221:
1222: STDMETHODIMP CntrLine_IPSite_OnUIActivate (LPOLEINPLACESITE lpThis)
1223: {
1224: LPCONTAINERLINE lpContainerLine =
1225: ((struct COleInPlaceSiteImpl FAR*)lpThis)->lpContainerLine;
1226: LPCONTAINERDOC lpContainerDoc = lpContainerLine->m_lpDoc;
1227: LPOUTLINEDOC lpOutlineDoc = (LPOUTLINEDOC)lpContainerLine->m_lpDoc;
1228: LPCONTAINERLINE lpLastUIActiveLine = lpContainerDoc->m_lpLastUIActiveLine;
1229: HWND hWndNewUIActiveObj;
1230:
1231: OLEDBG_BEGIN2("CntrLine_IPSite_OnUIActivate\r\n");
1232:
1233: lpContainerLine->m_fUIActive = TRUE;
1234: lpContainerDoc->m_fAddMyUI = FALSE;
1235: lpContainerDoc->m_lpLastUIActiveLine = lpContainerLine;
1236:
1237: OLEDBG_BEGIN2("IOleInPlaceObject::GetWindow called\r\n")
1238: lpContainerLine->m_lpOleIPObj->lpVtbl->GetWindow(
1239: lpContainerLine->m_lpOleIPObj,
1240: (HWND FAR*)&hWndNewUIActiveObj
1241: );
1242: OLEDBG_END2
1243:
1244: if (g_fInsideOutContainer) {
1245: /* OLE2NOTE: (INSIDE-OUT CONTAINER) an inside-out style
1246: ** container must UIDeactivate the previous UIActive object
1247: ** when a new object is going UIActive. since the inside-out
1248: ** objects have their own windows visible, it is possible
1249: ** that a click directly in an another server window will
1250: ** cause it to UIActivate. OnUIActivate is the containers
1251: ** notification that such has occured. it must then
1252: ** UIDeactivate the other because at most one object can be
1253: ** UIActive at a time.
1254: */
1255: if (lpLastUIActiveLine && (lpLastUIActiveLine!=lpContainerLine)) {
1256: ContainerLine_UIDeactivate(lpLastUIActiveLine);
1257:
1258: // Make sure new UIActive window is on top of all others
1259: SetWindowPos(
1260: hWndNewUIActiveObj,
1261: HWND_TOPMOST,
1262: 0,0,0,0,
1263: SWP_NOMOVE | SWP_NOSIZE
1264: );
1265:
1266: OLEDBG_END2
1267: return NOERROR;
1268: }
1269: }
1270:
1271: lpContainerDoc->m_hwndUIActiveObj = hWndNewUIActiveObj;
1272:
1273: #if defined( USE_FRAMETOOLS )
1274: ContainerDoc_RemoveFrameLevelTools(lpContainerDoc);
1275: #endif
1276:
1277: #if defined( USE_DOCTOOLS )
1278: ContainerDoc_RemoveDocLevelTools(lpContainerDoc);
1279: #endif
1280:
1281: OLEDBG_END2
1282: return NOERROR;
1283: }
1284:
1285:
1286: STDMETHODIMP CntrLine_IPSite_GetWindowContext(
1287: LPOLEINPLACESITE lpThis,
1288: LPOLEINPLACEFRAME FAR* lplpFrame,
1289: LPOLEINPLACEUIWINDOW FAR* lplpDoc,
1290: LPRECT lprcPosRect,
1291: LPRECT lprcClipRect,
1292: LPOLEINPLACEFRAMEINFO lpFrameInfo
1293: )
1294: {
1295: LPOUTLINEAPP lpOutlineApp = (LPOUTLINEAPP)g_lpApp;
1296: LPCONTAINERAPP lpContainerApp = (LPCONTAINERAPP)g_lpApp;
1297: LPCONTAINERLINE lpContainerLine =
1298: ((struct COleInPlaceSiteImpl FAR*)lpThis)->lpContainerLine;
1299:
1300: OLEDBG_BEGIN2("CntrLine_IPSite_GetWindowContext\r\n")
1301:
1302: /* OLE2NOTE: The server should fill in the "cb" field so that the
1303: ** container can tell what size structure the server is
1304: ** expecting. this enables this structure to be easily extended
1305: ** in future releases of OLE. the container should check this
1306: ** field so that it doesn't try to use fields that do not exist
1307: ** since the server may be using an old structure definition.
1308: ** Since this is the first release of OLE2.0, the structure is
1309: ** guaranteed to be at least large enough for the current
1310: ** definition of OLEINPLACEFRAMEINFO struct. thus we do NOT need
1311: ** to consider this an error if the server did not fill in this
1312: ** field correctly. this server may have trouble in the future,
1313: ** however, when the structure is extended.
1314: */
1315: // OleDbgAssert(lpFrameInfo->cb >= sizeof(OLEINPLACEFRAMEINFO));
1316:
1317: *lplpFrame = (LPOLEINPLACEFRAME)&lpContainerApp->m_OleInPlaceFrame;
1318: (*lplpFrame)->lpVtbl->AddRef(*lplpFrame); // must return AddRef'ed ptr
1319:
1320: // OLE2NOTE: an MDI app would have to provide *lplpDoc
1321: *lplpDoc = NULL;
1322:
1323: ContainerLine_GetOleObjectRectInPixels(lpContainerLine, lprcPosRect);
1324: ContainerDoc_GetClipRect(lpContainerLine->m_lpDoc, lprcClipRect);
1325:
1326: OleDbgOutRect3("CntrLine_IPSite_GetWindowContext (PosRect)", lprcPosRect);
1327: OleDbgOutRect3("CntrLine_IPSite_GetWindowContext (ClipRect)",lprcClipRect);
1328:
1329: lpFrameInfo->hwndFrame = lpOutlineApp->m_hWndApp;
1330:
1331: #if defined( MDI_VERSION )
1332: lpFrameInfo->fMDIApp = TRUE;
1333: #else
1334: lpFrameInfo->fMDIApp = FALSE;
1335: #endif
1336:
1337: lpFrameInfo->haccel = lpContainerApp->m_hAccelIPCntr;
1338: lpFrameInfo->cAccelEntries = NUM_INPLACE_ACCELS;
1339:
1340: OLEDBG_END2
1341: return NOERROR;
1342: }
1343:
1344:
1345: STDMETHODIMP CntrLine_IPSite_Scroll(
1346: LPOLEINPLACESITE lpThis,
1347: SIZE scrollExtent
1348: )
1349: {
1350: OleDbgOut2("CntrLine_IPSite_Scroll\r\n");
1351:
1352: return ResultFromScode(E_FAIL);
1353: }
1354:
1355:
1356: STDMETHODIMP CntrLine_IPSite_OnUIDeactivate(
1357: LPOLEINPLACESITE lpThis,
1358: BOOL fUndoable
1359: )
1360: {
1361: LPCONTAINERLINE lpContainerLine =
1362: ((struct COleInPlaceSiteImpl FAR*)lpThis)->lpContainerLine;
1363: LPOUTLINEDOC lpOutlineDoc = (LPOUTLINEDOC)lpContainerLine->m_lpDoc;
1364: LPCONTAINERAPP lpContainerApp = (LPCONTAINERAPP) g_lpApp;
1365: LPLINELIST lpLL;
1366: int nIndex;
1367: MSG msg;
1368:
1369: OLEDBG_BEGIN2("CntrLine_IPSite_OnUIDeactivate\r\n")
1370:
1371: lpContainerLine->m_fUIActive = FALSE;
1372: lpContainerLine->m_fIpChangesUndoable = fUndoable;
1373: lpContainerLine->m_lpDoc->m_hwndUIActiveObj = NULL;
1374:
1375: if (lpContainerLine == lpContainerLine->m_lpDoc->m_lpLastUIActiveLine) {
1376:
1377: lpContainerLine->m_lpDoc->m_lpLastUIActiveLine = NULL;
1378:
1379: /* OLE2NOTE: here we look ahead if there is a DBLCLK sitting in our
1380: ** message queue. if so, it could result in in-place activating
1381: ** another object. we want to avoid placing our tools and
1382: ** repainting if immediately another object is going to do the
1383: ** same. SO, if there is a DBLCLK in the queue for this document
1384: ** we will only set the fAddMyUI flag to indicate that this work
1385: ** is still to be done. if another object actually in-place
1386: ** activates then this flag will be cleared in
1387: ** IOleInPlaceSite::OnUIActivate. if it does NOT get cleared,
1388: ** then at the end of processing the DBLCLK message in our
1389: ** OutlineDocWndProc we will put our tools back.
1390: */
1391: if (! PeekMessage(&msg, lpOutlineDoc->m_hWndDoc,
1392: WM_LBUTTONDBLCLK, WM_LBUTTONDBLCLK,
1393: PM_NOREMOVE | PM_NOYIELD)) {
1394:
1395: #if defined( USE_DOCTOOLS )
1396: ContainerDoc_AddDocLevelTools(lpContainerLine->m_lpDoc);
1397: #endif
1398:
1399: #if defined( USE_FRAMETOOLS )
1400: ContainerDoc_AddFrameLevelUI(lpContainerLine->m_lpDoc);
1401: #endif
1402: } else {
1403: lpContainerLine->m_lpDoc->m_fAddMyUI = TRUE;
1404: }
1405:
1406: /* OLE2NOTE: we should re-take focus. the in-place server window
1407: ** previously had the focus; this window has just been removed.
1408: */
1409: SetFocus(OutlineDoc_GetWindow((LPOUTLINEDOC)lpContainerLine->m_lpDoc));
1410:
1411: // force the line to redraw to remove in-place active hatch
1412: lpLL = OutlineDoc_GetLineList(lpOutlineDoc);
1413: nIndex = LineList_GetLineIndex(lpLL, (LPLINE)lpContainerLine);
1414: LineList_ForceLineRedraw(lpLL, nIndex, TRUE);
1415: }
1416:
1417: OLEDBG_END2
1418: return NOERROR;
1419: }
1420:
1421:
1422: STDMETHODIMP CntrLine_IPSite_OnInPlaceDeactivate(LPOLEINPLACESITE lpThis)
1423: {
1424: LPCONTAINERLINE lpContainerLine =
1425: ((struct COleInPlaceSiteImpl FAR*)lpThis)->lpContainerLine;
1426:
1427: OLEDBG_BEGIN2("CntrLine_IPSite_OnInPlaceDeactivate\r\n");
1428:
1429: lpContainerLine->m_fIpActive = FALSE;
1430: lpContainerLine->m_fIpVisible = FALSE;
1431: lpContainerLine->m_fIpChangesUndoable = FALSE;
1432:
1433: OleStdRelease((LPUNKNOWN) lpContainerLine->m_lpOleIPObj);
1434: lpContainerLine->m_lpOleIPObj = NULL;
1435: lpContainerLine->m_lpDoc->m_cIPActiveObjects--;
1436:
1437: OLEDBG_END2
1438: return NOERROR;
1439: }
1440:
1441:
1442: STDMETHODIMP CntrLine_IPSite_DiscardUndoState(LPOLEINPLACESITE lpThis)
1443: {
1444: OleDbgOut2("CntrLine_IPSite_DiscardUndoState\r\n");
1445:
1446: return NOERROR;
1447: }
1448:
1449:
1450: STDMETHODIMP CntrLine_IPSite_DeactivateAndUndo(LPOLEINPLACESITE lpThis)
1451: {
1452: OleDbgOut2("CntrLine_IPSite_DeactivateAndUndo\r\n");
1453:
1454: return NOERROR;
1455: }
1456:
1457:
1458: STDMETHODIMP CntrLine_IPSite_OnPosRectChange(
1459: LPOLEINPLACESITE lpThis,
1460: LPCRECT lprcPosRect
1461: )
1462: {
1463: LPCONTAINERLINE lpContainerLine =
1464: ((struct COleInPlaceSiteImpl FAR*)lpThis)->lpContainerLine;
1465: LPOUTLINEDOC lpOutlineDoc = (LPOUTLINEDOC)lpContainerLine->m_lpDoc;
1466: LPSCALEFACTOR lpscale = OutlineDoc_GetScaleFactor(lpOutlineDoc);
1467: LPLINE lpLine = (LPLINE)lpContainerLine;
1468: LPLINELIST lpLL;
1469: int nIndex;
1470: RECT rcClipRect;
1471: RECT rcNewPosRect;
1472: SIZEL sizelPix;
1473: SIZEL sizelHim;
1474: int nIPObjHeight = lprcPosRect->bottom - lprcPosRect->top;
1475: int nIPObjWidth = lprcPosRect->right - lprcPosRect->left;
1476:
1477: OLEDBG_BEGIN2("CntrLine_IPSite_OnPosRectChange\r\n")
1478:
1479: OleDbgOutRect3("CntrLine_IPSite_OnPosRectChange (PosRect --IN)",
1480: (LPRECT)lprcPosRect);
1481:
1482: /* OLE2NOTE: if the in-place container does NOT impose any
1483: ** size contraints on its in-place active objects, then it may
1484: ** simply grant the size requested by the object by immediately
1485: ** calling IOleInPlaceObject::SetObjectRects with the
1486: ** lprcPosRect passed by the in-place object.
1487: **
1488: ** Container Outline, however, imposes a size constraint on its
1489: ** embedded objects (see comment in ContainerLine_UpdateExtent),
1490: ** thus it is necessary to calculate the size that the in-place
1491: ** active object is allowed to be.
1492: */
1493:
1494: /* calculate the new object extents. we can NOT directly ask the
1495: ** object via IOleObject::GetExtent because this method will
1496: ** retreive the extents of the last cached metafile. the cache
1497: ** has not yet been updated by this point. the best we can do is
1498: ** determine the scale factor that the object is operating at
1499: ** and scale the lprcPosRect back to HIMETRIC units.
1500: */
1501: if (lpContainerLine->m_sizeInHimetric.cx > 0 &&
1502: lpContainerLine->m_sizeInHimetric.cy > 0) {
1503: sizelHim.cx = lpLine->m_nWidthInHimetric;
1504: sizelHim.cy = lpLine->m_nHeightInHimetric;
1505: XformSizeInHimetricToPixels(NULL, &sizelHim, &sizelPix);
1506: sizelPix.cx -= 2* LINE_BOUNDARY_WIDTH;
1507: sizelPix.cy -= 2* LINE_BOUNDARY_WIDTH;
1508: sizelHim.cx = lpContainerLine->m_sizeInHimetric.cx * nIPObjWidth /
1509: sizelPix.cx;
1510: sizelHim.cy = lpContainerLine->m_sizeInHimetric.cy * nIPObjHeight /
1511: sizelPix.cy;
1512:
1513: // Convert size back to 100% zoom
1514: sizelHim.cx = sizelHim.cx * lpscale->dwSxD / lpscale->dwSxN;
1515: sizelHim.cy = sizelHim.cy * lpscale->dwSyD / lpscale->dwSyN;
1516:
1517: } else {
1518: sizelHim.cx = (long)DEFOBJWIDTH;
1519: sizelHim.cy = (long)DEFOBJHEIGHT;
1520: XformSizeInHimetricToPixels(NULL, &sizelHim, &sizelPix);
1521: sizelHim.cx = sizelHim.cx * nIPObjWidth / sizelPix.cx;
1522: sizelHim.cy = sizelHim.cy * nIPObjHeight / sizelPix.cy;
1523: }
1524: ContainerLine_UpdateExtent(lpContainerLine, &sizelHim);
1525: ContainerLine_GetOleObjectRectInPixels(
1526: lpContainerLine, (LPRECT)&rcNewPosRect);
1527:
1528: ContainerDoc_GetClipRect(lpContainerLine->m_lpDoc, (LPRECT)&rcClipRect);
1529:
1530: OleDbgOutRect3("CntrLine_IPSite_OnPosRectChange (PosRect --OUT)",
1531: (LPRECT)&rcNewPosRect);
1532: OleDbgOutRect3("CntrLine_IPSite_OnPosRectChange (ClipRect--OUT)",
1533: (LPRECT)&rcClipRect);
1534:
1535: OLEDBG_BEGIN2("IOleInPlaceObject::SetObjectRects called\r\n")
1536: lpContainerLine->m_lpOleIPObj->lpVtbl->SetObjectRects(
1537: lpContainerLine->m_lpOleIPObj,
1538: (LPRECT)&rcNewPosRect,
1539: (LPRECT)&rcClipRect
1540: );
1541: OLEDBG_END2
1542:
1543: lpLL = OutlineDoc_GetLineList(lpOutlineDoc);
1544: nIndex = LineList_GetLineIndex(lpLL, (LPLINE)lpContainerLine);
1545: ContainerDoc_UpdateInPlaceObjectRects(lpContainerLine->m_lpDoc, nIndex);
1546:
1547: OLEDBG_END2
1548: return NOERROR;
1549: }
1550:
1551:
1552: #endif // INPLACE_CNTR
1553:
1554:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.