/*************************************************************************
**
** OLE 2.0 Container Sample Code
**
** cntroutl.h
**
** This file contains file contains data structure defintions,
** function prototypes, constants, etc. used by the OLE 2.0 container
** app version of the Outline series of sample applications:
** Outline -- base version of the app (without OLE functionality)
** SvrOutl -- OLE 2.0 Server sample app
** CntrOutl -- OLE 2.0 Containter (Container) sample app
**
** (c) Copyright Microsoft Corp. 1992 - 1993 All Rights Reserved
**
*************************************************************************/
#if !defined( _CNTROUTL_H_ )
#define _CNTROUTL_H_
#ifndef RC_INVOKED
#pragma message ("INCLUDING CNTROUTL.H from " __FILE__)
#endif /* RC_INVOKED */
#include "oleoutl.h"
#include "cntrrc.h"
// REVIEW: should load from string resource
#define DEFOBJNAMEPREFIX "Obj" // Prefix for auto-generated stg names
#define DEFOBJWIDTH 5000 // default size for embedded obj.
#define DEFOBJHEIGHT 5000 // default size for embedded obj.
#define UNKNOWN_OLEOBJ_TYPE "Unknown OLE Object Type"
#define szOLEOBJECT "Object"
#define szOLELINK "Link"
#define CONTAINERDOCFORMAT "CntrOutl" // CF_CntrOutl format name
/* Forward definition of types */
typedef struct tagCONTAINERDOC FAR* LPCONTAINERDOC;
typedef struct tagCONTAINERLINE FAR* LPCONTAINERLINE;
// Flags to specify type of OLECREATE???FROMDATA call required
typedef enum tagOLECREATEFROMDATATYPE {
OLECREATEFROMDATA_LINK = 1,
OLECREATEFROMDATA_OBJECT = 2,
OLECREATEFROMDATA_STATIC = 3
} OLECREATEFROMDATATYPE;
/*************************************************************************
** class CONTAINERLINE : LINE
** The class CONTAINERLINE is a concrete subclass of the abstract base
** class LINE. The CONTAINERLINE maintains all information about the
** place within the CONTAINERDOC that an OLE object is embedded. This
** object implements the following OLE 2.0 interfaces:
** IOleClientSite
** IAdviseSink
** In the CntrOutl client app either CONTAINERLINE objects or TEXTLINE
** objects can be created. The CONTAINERLINE class inherits all fields
** from the LINE class. This inheritance is achieved by including a
** member variable of type LINE as the first field in the CONTAINERLINE
** structure. Thus a pointer to a CONTAINERLINE object can be cast to be
** a pointer to a LINE object.
** Each CONTAINERLINE object that is created in added to the LINELIST of
** the associated OUTLINEDOC document.
*************************************************************************/
typedef struct tagCONTAINERLINE {
LINE m_Line; // ContainerLine inherits fields of Line
ULONG m_cRef; // total ref count for line
char m_szStgName[CWCSTORAGENAME]; // stg name w/i cntr stg
BOOL m_fObjWinOpen; // is obj window open? if so, shade obj.
BOOL m_fMonikerAssigned; // has a moniker been assigned to obj
DWORD m_dwDrawAspect; // current display aspect for obj
// (either DVASPECT_CONTENT or
// DVASPECT_ICON)
BOOL m_fGuardObj; // Guard against re-entrancy while
// loading or creating an OLE object
BOOL m_fDoGetExtent; // indicates extents may have changed
BOOL m_fDoSetExtent; // obj was resized when not running
// IOO::SetExtent needed on next run
SIZEL m_sizeInHimetric; // extents of obj in himetric units
LPSTORAGE m_lpStg; // open pstg when obj is loaded
LPCONTAINERDOC m_lpDoc; // ptr to associated client doc
LPOLEOBJECT m_lpOleObj; // ptr to IOleObject* when obj is loaded
LPVIEWOBJECT2 m_lpViewObj2; // ptr to IViewObject2* when obj is loaded
LPPERSISTSTORAGE m_lpPersistStg;// ptr to IPersistStorage* when obj loaded
LPOLELINK m_lpOleLink; // ptr to IOleLink* if link is loaded
DWORD m_dwLinkType; // is it a linked object?
// 0 -- NOT a link
// OLEUPDATE_ALWAYS (1) -- auto link
// OLEUPDATE_ONCALL (3) -- man. link
BOOL m_fLinkUnavailable; // is the link unavailable?
LPSTR m_lpszShortType;// short type name of OLE object needed
// to make the Edit.Object.Verb menu
int m_nHorizScrollShift; // horiz scroll shift required
// for object's inplace window.
// (note: this is ICNTROTL specific)
#if defined( INPLACE_CNTR )
BOOL m_fIpActive; // is object in-place active (undo valid)
BOOL m_fUIActive; // is object UIActive
BOOL m_fIpVisible; // is object's in-place window visible
BOOL m_fInsideOutObj;// is obj inside-out (visible when loaded)
LPOLEINPLACEOBJECT m_lpOleIPObj; // IOleInPlaceObject* of in-place obj
BOOL m_fIpChangesUndoable; // can in-place object do undo
BOOL m_fIpServerRunning; // is in-place server running
HWND m_hWndIpObject;
struct COleInPlaceSiteImpl {
IOleInPlaceSiteVtbl FAR* lpVtbl;
LPCONTAINERLINE lpContainerLine;
int cRef; // interface specific ref count.
} m_OleInPlaceSite;
#endif // INPLACE_CNTR
struct CUnknownImpl {
IUnknownVtbl FAR* lpVtbl;
LPCONTAINERLINE lpContainerLine;
int cRef; // interface specific ref count.
} m_Unknown;
struct COleClientSiteImpl {
IOleClientSiteVtbl FAR* lpVtbl;
LPCONTAINERLINE lpContainerLine;
int cRef; // interface specific ref count.
} m_OleClientSite;
struct CAdviseSinkImpl {
IAdviseSinkVtbl FAR* lpVtbl;
LPCONTAINERLINE lpContainerLine;
int cRef; // interface specific ref count.
} m_AdviseSink;
} CONTAINERLINE;
/* ContainerLine methods (functions) */
void ContainerLine_Init(LPCONTAINERLINE lpContainerLine, int nTab, HDC hDC);
BOOL ContainerLine_SetupOleObject(
LPCONTAINERLINE lpContainerLine,
BOOL fDisplayAsIcon,
HGLOBAL hMetaPict
);
LPCONTAINERLINE ContainerLine_Create(
DWORD dwOleCreateType,
HDC hDC,
UINT nTab,
LPCONTAINERDOC lpContainerDoc,
LPCLSID lpclsid,
LPSTR lpszFileName,
BOOL fDisplayAsIcon,
HGLOBAL hMetaPict,
LPSTR lpszStgName
);
LPCONTAINERLINE ContainerLine_CreateFromData(
HDC hDC,
UINT nTab,
LPCONTAINERDOC lpContainerDoc,
LPDATAOBJECT lpSrcDataObj,
DWORD dwCreateType,
CLIPFORMAT cfFormat,
BOOL fDisplayAsIcon,
HGLOBAL hMetaPict,
LPSTR lpszStgName
);
ULONG ContainerLine_AddRef(LPCONTAINERLINE lpContainerLine);
ULONG ContainerLine_Release(LPCONTAINERLINE lpContainerLine);
HRESULT ContainerLine_QueryInterface(
LPCONTAINERLINE lpContainerLine,
REFIID riid,
LPVOID FAR* lplpUnk
);
BOOL ContainerLine_CloseOleObject(
LPCONTAINERLINE lpContainerLine,
DWORD dwSaveOption
);
void ContainerLine_UnloadOleObject(
LPCONTAINERLINE lpContainerLine,
DWORD dwSaveOption
);
void ContainerLine_Delete(LPCONTAINERLINE lpContainerLine);
void ContainerLine_Destroy(LPCONTAINERLINE lpContainerLine);
BOOL ContainerLine_CopyToDoc(
LPCONTAINERLINE lpSrcLine,
LPOUTLINEDOC lpDestDoc,
int nIndex
);
BOOL ContainerLine_LoadOleObject(LPCONTAINERLINE lpContainerLine);
BOOL ContainerLine_UpdateExtent(
LPCONTAINERLINE lpContainerLine,
LPSIZEL lpsizelHim
);
BOOL ContainerLine_DoVerb(
LPCONTAINERLINE lpContainerLine,
LONG iVerb,
LPMSG lpMsg,
BOOL fMessage,
BOOL fAction
);
LPUNKNOWN ContainerLine_GetOleObject(
LPCONTAINERLINE lpContainerLine,
REFIID riid
);
HRESULT ContainerLine_RunOleObject(LPCONTAINERLINE lpContainerLine);
BOOL ContainerLine_ProcessOleRunError(
LPCONTAINERLINE lpContainerLine,
HRESULT hrErr,
BOOL fAction,
BOOL fMenuInvoked
);
HRESULT ContainerLine_ReCreateLinkBecauseClassDiff(
LPCONTAINERLINE lpContainerLine
);
BOOL ContainerLine_IsOleLink(LPCONTAINERLINE lpContainerLine);
void ContainerLine_BindLinkIfLinkSrcIsRunning(LPCONTAINERLINE lpContainerLine);
void ContainerLine_Draw(
LPCONTAINERLINE lpContainerLine,
HDC hDC,
LPRECT lpRect,
LPRECT lpRectWBounds,
BOOL fHighlight
);
void ContainerLine_DrawSelHilight(
LPCONTAINERLINE lpContainerLine,
HDC hDC,
LPRECT lpRect,
UINT itemAction,
UINT itemState
);
BOOL ContainerLine_Edit(LPCONTAINERLINE lpContainerLine,HWND hWndDoc,HDC hDC);
void ContainerLine_SetHeightInHimetric(LPCONTAINERLINE lpContainerLine, int nHeight);
void ContainerLine_SetLineHeightFromObjectExtent(
LPCONTAINERLINE lpContainerLine,
LPSIZEL lpsizelOleObject
);
BOOL ContainerLine_SaveToStm(
LPCONTAINERLINE lpContainerLine,
LPSTREAM lpLLStm
);
BOOL ContainerLine_SaveOleObjectToStg(
LPCONTAINERLINE lpContainerLine,
LPSTORAGE lpSrcStg,
LPSTORAGE lpDestStg,
BOOL fRemember
);
LPLINE ContainerLine_LoadFromStg(
LPSTORAGE lpSrcStg,
LPSTREAM lpLLStm,
LPOUTLINEDOC lpDestDoc
);
LPMONIKER ContainerLine_GetRelMoniker(
LPCONTAINERLINE lpContainerLine,
DWORD dwAssign
);
LPMONIKER ContainerLine_GetFullMoniker(
LPCONTAINERLINE lpContainerLine,
DWORD dwAssign
);
int ContainerLine_GetTextLen(LPCONTAINERLINE lpContainerLine);
void ContainerLine_GetTextData(LPCONTAINERLINE lpContainerLine,LPSTR lpszBuf);
BOOL ContainerLine_GetOutlineData(
LPCONTAINERLINE lpContainerLine,
LPTEXTLINE lpBuf
);
void ContainerLine_GetOleObjectRectInPixels(
LPCONTAINERLINE lpContainerLine,
LPRECT lprc
);
void ContainerLine_GetPosRect(
LPCONTAINERLINE lpContainerLine,
LPRECT lprcPosRect
);
void ContainerLine_GetOleObjectSizeInHimetric(
LPCONTAINERLINE lpContainerLine,
LPSIZEL lpsizel
);
#if defined( INPLACE_CNTR )
void ContainerLine_UIDeactivate(LPCONTAINERLINE lpContainerLine);
void ContainerLine_InPlaceDeactivate(LPCONTAINERLINE lpContainerLine);
void ContainerLine_UpdateInPlaceObjectRects(
LPCONTAINERLINE lpContainerLine,
LPRECT lprcClipRect
);
void ContainerLine_ContextSensitiveHelp(
LPCONTAINERLINE lpContainerLine,
BOOL fEnterMode
);
void ContainerLine_ForwardPaletteChangedMsg(
LPCONTAINERLINE lpContainerLine,
HWND hwndPalChg
);
void ContainerDoc_ContextSensitiveHelp(
LPCONTAINERDOC lpContainerDoc,
BOOL fEnterMode,
BOOL fInitiatedByObj
);
void ContainerDoc_ForwardPaletteChangedMsg(
LPCONTAINERDOC lpContainerDoc,
HWND hwndPalChg
);
#endif // INPLACE_CNTR
/* ContainerLine::IUnknown methods (functions) */
STDMETHODIMP CntrLine_Unk_QueryInterface(
LPUNKNOWN lpThis,
REFIID riid,
LPVOID FAR* lplpvObj
);
STDMETHODIMP_(ULONG) CntrLine_Unk_AddRef(LPUNKNOWN lpThis);
STDMETHODIMP_(ULONG) CntrLine_Unk_Release(LPUNKNOWN lpThis);
/* ContainerLine::IOleClientSite methods (functions) */
STDMETHODIMP CntrLine_CliSite_QueryInterface(
LPOLECLIENTSITE lpThis,
REFIID riid,
LPVOID FAR* lplpvObj
);
STDMETHODIMP_(ULONG) CntrLine_CliSite_AddRef(LPOLECLIENTSITE lpThis);
STDMETHODIMP_(ULONG) CntrLine_CliSite_Release(LPOLECLIENTSITE lpThis);
STDMETHODIMP CntrLine_CliSite_SaveObject(LPOLECLIENTSITE lpThis);
STDMETHODIMP CntrLine_CliSite_GetMoniker(
LPOLECLIENTSITE lpThis,
DWORD dwAssign,
DWORD dwWhichMoniker,
LPMONIKER FAR* lplpmk
);
STDMETHODIMP CntrLine_CliSite_GetContainer(
LPOLECLIENTSITE lpThis,
LPOLECONTAINER FAR* lplpContainer
);
STDMETHODIMP CntrLine_CliSite_ShowObject(LPOLECLIENTSITE lpThis);
STDMETHODIMP CntrLine_CliSite_OnShowWindow(LPOLECLIENTSITE lpThis,BOOL fShow);
STDMETHODIMP CntrLine_CliSite_RequestNewObjectLayout(LPOLECLIENTSITE lpThis);
/* ContainerLine::IAdviseSink methods (functions) */
STDMETHODIMP CntrLine_AdvSink_QueryInterface(
LPADVISESINK lpThis,
REFIID riid,
LPVOID FAR* lplpvObj
);
STDMETHODIMP_(ULONG) CntrLine_AdvSink_AddRef(LPADVISESINK lpThis);
STDMETHODIMP_(ULONG) CntrLine_AdvSink_Release (LPADVISESINK lpThis);
STDMETHODIMP_(void) CntrLine_AdvSink_OnDataChange(
LPADVISESINK lpThis,
FORMATETC FAR* lpFormatetc,
STGMEDIUM FAR* lpStgmed
);
STDMETHODIMP_(void) CntrLine_AdvSink_OnViewChange(
LPADVISESINK lpThis,
DWORD aspects,
LONG lindex
);
STDMETHODIMP_(void) CntrLine_AdvSink_OnRename(
LPADVISESINK lpThis,
LPMONIKER lpmk
);
STDMETHODIMP_(void) CntrLine_AdvSink_OnSave(LPADVISESINK lpThis);
STDMETHODIMP_(void) CntrLine_AdvSink_OnClose(LPADVISESINK lpThis);
#if defined( INPLACE_CNTR )
/* ContainerLine::IOleInPlaceSite methods (functions) */
STDMETHODIMP CntrLine_IPSite_QueryInterface(
LPOLEINPLACESITE lpThis,
REFIID riid,
LPVOID FAR* lplpvObj
);
STDMETHODIMP_(ULONG) CntrLine_IPSite_AddRef(LPOLEINPLACESITE lpThis);
STDMETHODIMP_(ULONG) CntrLine_IPSite_Release(LPOLEINPLACESITE lpThis);
STDMETHODIMP CntrLine_IPSite_GetWindow(
LPOLEINPLACESITE lpThis,
HWND FAR* lphwnd
);
STDMETHODIMP CntrLine_IPSite_ContextSensitiveHelp(
LPOLEINPLACESITE lpThis,
BOOL fEnterMode
);
STDMETHODIMP CntrLine_IPSite_CanInPlaceActivate(LPOLEINPLACESITE lpThis);
STDMETHODIMP CntrLine_IPSite_OnInPlaceActivate(LPOLEINPLACESITE lpThis);
STDMETHODIMP CntrLine_IPSite_OnUIActivate (LPOLEINPLACESITE lpThis);
STDMETHODIMP CntrLine_IPSite_GetWindowContext(
LPOLEINPLACESITE lpThis,
LPOLEINPLACEFRAME FAR* lplpFrame,
LPOLEINPLACEUIWINDOW FAR* lplpDoc,
LPRECT lprcPosRect,
LPRECT lprcClipRect,
LPOLEINPLACEFRAMEINFO lpFrameInfo
);
STDMETHODIMP CntrLine_IPSite_Scroll(
LPOLEINPLACESITE lpThis,
SIZE scrollExtent
);
STDMETHODIMP CntrLine_IPSite_OnUIDeactivate(
LPOLEINPLACESITE lpThis,
BOOL fUndoable
);
STDMETHODIMP CntrLine_IPSite_OnInPlaceDeactivate(LPOLEINPLACESITE lpThis);
STDMETHODIMP CntrLine_IPSite_DiscardUndoState(LPOLEINPLACESITE lpThis);
STDMETHODIMP CntrLine_IPSite_DeactivateAndUndo(LPOLEINPLACESITE lpThis);
STDMETHODIMP CntrLine_IPSite_OnPosRectChange(
LPOLEINPLACESITE lpThis,
LPCRECT lprcPosRect
);
#endif // INPLACE_CNTR
/* struct definition for persistant data storage of ContainerLine */
#pragma pack(push, 2)
typedef struct tagCONTAINERLINERECORD_ONDISK
{
char m_szStgName[CWCSTORAGENAME]; // stg name w/i cntr stg
USHORT m_fMonikerAssigned; // has a moniker been assigned to obj
DWORD m_dwDrawAspect; // current display aspect for obj
// (either DVASPECT_CONTENT or
// DVASPECT_ICON)
SIZEL m_sizeInHimetric; // extents of obj in himetric units
DWORD m_dwLinkType; // is it a linked object?
// 0 -- NOT a link
// OLEUPDATE_ALWAYS (1) -- auto link
// OLEUPDATE_ONCALL (3) -- man. link
USHORT m_fDoSetExtent; // obj was resized when not running
// IOO::SetExtent needed on next run
} CONTAINERLINERECORD_ONDISK, FAR* LPCONTAINERLINERECORD_ONDISK;
#pragma pack(pop)
typedef struct tagCONTAINERLINERECORD {
char m_szStgName[CWCSTORAGENAME]; // stg name w/i cntr stg
BOOL m_fMonikerAssigned; // has a moniker been assigned to obj
DWORD m_dwDrawAspect; // current display aspect for obj
// (either DVASPECT_CONTENT or
// DVASPECT_ICON)
SIZEL m_sizeInHimetric; // extents of obj in himetric units
DWORD m_dwLinkType; // is it a linked object?
// 0 -- NOT a link
// OLEUPDATE_ALWAYS (1) -- auto link
// OLEUPDATE_ONCALL (3) -- man. link
BOOL m_fDoSetExtent; // obj was resized when not running
// IOO::SetExtent needed on next run
} CONTAINERLINERECORD, FAR* LPCONTAINERLINERECORD;
/*************************************************************************
** class CONTAINERDOC : OUTLINEDOC
** CONTAINERDOC is an extention to the base OUTLINEDOC object (structure)
** that adds OLE 2.0 Container functionality. There is one instance of
** CONTAINERDOC object created per document open in the app. The SDI
** version of the app supports one CONTAINERDOC at a time. The MDI
** version of the app can manage multiple documents at one time.
** The CONTAINERDOC class inherits all fields
** from the OUTLINEDOC class. This inheritance is achieved by including a
** member variable of type OUTLINEDOC as the first field in the
** CONTAINERDOC structure. Thus a pointer to a CONTAINERDOC object
** can be cast to be a pointer to a OUTLINEDOC object.
*************************************************************************/
typedef struct tagCONTAINERDOC {
OLEDOC m_OleDoc; // ContainerDoc inherits all fields of OleDoc
ULONG m_nNextObjNo; // next available obj no. for stg name
LPSTORAGE m_lpNewStg; // holds new pStg when SaveAs is pending
BOOL m_fEmbeddedObjectAvail; // is single OLE embed copied to doc
CLSID m_clsidOleObjCopied; // if obj copied, CLSID of obj
DWORD m_dwAspectOleObjCopied; // if obj copied, draw aspect of obj
LPCONTAINERLINE m_lpSrcContainerLine; // src line if doc created for copy
BOOL m_fShowObject; // show object flag
#if defined( INPLACE_CNTR )
LPCONTAINERLINE m_lpLastIpActiveLine; // last in-place active line
LPCONTAINERLINE m_lpLastUIActiveLine; // last UIActive line
HWND m_hWndUIActiveObj; // HWND of UIActive obj.
BOOL m_fAddMyUI; // if adding tools/menu postponed
int m_cIPActiveObjects;
#if defined( INPLACE_CNTRSVR )
LPOLEINPLACEFRAME m_lpTopIPFrame; // ptr to Top In-place frame.
LPOLEINPLACEFRAME m_lpTopIPDoc; // ptr to Top In-place Doc window.
HMENU m_hSharedMenu; // combined obj/cntr menu
// NULL if we are top container
HOLEMENU m_hOleMenu; // returned by OleCreateMenuDesc.
// NULL if we are top container
#endif // INPLACE_CNTRSVR
#endif // INPLACE_CNTR
struct CDocOleUILinkContainerImpl {
IOleUILinkContainerVtbl FAR* lpVtbl;
LPCONTAINERDOC lpContainerDoc;
int cRef; // interface specific ref count.
} m_OleUILinkContainer;
} CONTAINERDOC;
/* ContainerDoc methods (functions) */
BOOL ContainerDoc_Init(LPCONTAINERDOC lpContainerDoc, BOOL fDataTransferDoc);
LPCONTAINERLINE ContainerDoc_GetNextLink(
LPCONTAINERDOC lpContainerDoc,
LPCONTAINERLINE lpContainerLine
);
void ContainerDoc_UpdateLinks(LPCONTAINERDOC lpContainerDoc);
void ContainerDoc_SetShowObjectFlag(LPCONTAINERDOC lpContainerDoc, BOOL fShow);
BOOL ContainerDoc_GetShowObjectFlag(LPCONTAINERDOC lpContainerDoc);
void ContainerDoc_InsertOleObjectCommand(LPCONTAINERDOC lpContainerDoc);
void ContainerDoc_EditLinksCommand(LPCONTAINERDOC lpContainerDoc);
void ContainerDoc_PasteLinkCommand(LPCONTAINERDOC lpContainerDoc);
void ContainerDoc_ConvertCommand(
LPCONTAINERDOC lpContainerDoc,
BOOL fServerNotRegistered
);
BOOL ContainerDoc_PasteFormatFromData(
LPCONTAINERDOC lpContainerDoc,
CLIPFORMAT cfFormat,
LPDATAOBJECT lpSrcDataObj,
BOOL fLocalDataObj,
BOOL fLink,
BOOL fDisplayAsIcon,
HGLOBAL hMetaPict,
LPSIZEL lpSizelInSrc
);
int ContainerDoc_PasteCntrOutlData(
LPCONTAINERDOC lpDestContainerDoc,
LPSTORAGE lpSrcStg,
int nStartIndex
);
BOOL ContainerDoc_QueryPasteFromData(
LPCONTAINERDOC lpContainerDoc,
LPDATAOBJECT lpSrcDataObj,
BOOL fLink
);
int ContainerDoc_PasteOleObject(
LPCONTAINERDOC lpContainerDoc,
LPDATAOBJECT lpSrcDataObj,
DWORD dwCreateType,
CLIPFORMAT cfFormat,
int nIndex,
BOOL fDisplayAsIcon,
HGLOBAL hMetaPict,
LPSIZEL lpSizelInSrc
);
BOOL ContainerDoc_CloseAllOleObjects(
LPCONTAINERDOC lpContainerDoc,
DWORD dwSaveOption
);
void ContainerDoc_UnloadAllOleObjectsOfClass(
LPCONTAINERDOC lpContainerDoc,
REFCLSID rClsid,
DWORD dwSaveOption
);
void ContainerDoc_InformAllOleObjectsDocRenamed(
LPCONTAINERDOC lpContainerDoc,
LPMONIKER lpmkDoc
);
void ContainerDoc_UpdateExtentOfAllOleObjects(LPCONTAINERDOC lpContainerDoc);
BOOL ContainerDoc_SaveToFile(
LPCONTAINERDOC lpContainerDoc,
LPCSTR lpszFileName,
UINT uFormat,
BOOL fRemember
);
void ContainerDoc_ContainerLineDoVerbCommand(
LPCONTAINERDOC lpContainerDoc,
LONG iVerb
);
void ContainerDoc_GetNextStgName(
LPCONTAINERDOC lpContainerDoc,
LPSTR lpszStgName,
int nLen
);
BOOL ContainerDoc_IsStgNameUsed(
LPCONTAINERDOC lpContainerDoc,
LPSTR lpszStgName
);
LPSTORAGE ContainerDoc_GetStg(LPCONTAINERDOC lpContainerDoc);
HRESULT ContainerDoc_GetObject(
LPCONTAINERDOC lpContainerDoc,
LPOLESTR lpszItem,
DWORD dwSpeedNeeded,
REFIID riid,
LPVOID FAR* lplpvObject
);
HRESULT ContainerDoc_GetObjectStorage(
LPCONTAINERDOC lpContainerDoc,
LPOLESTR lpszItem,
LPSTORAGE FAR* lplpStg
);
HRESULT ContainerDoc_IsRunning(LPCONTAINERDOC lpContainerDoc, LPOLESTR lpszItem);
LPUNKNOWN ContainerDoc_GetSingleOleObject(
LPCONTAINERDOC lpContainerDoc,
REFIID riid,
LPCONTAINERLINE FAR* lplpContainerLine
);
BOOL ContainerDoc_IsSelAnOleObject(
LPCONTAINERDOC lpContainerDoc,
REFIID riid,
LPUNKNOWN FAR* lplpvObj,
int FAR* lpnIndex,
LPCONTAINERLINE FAR* lplpContainerLine
);
HRESULT ContainerDoc_GetData (
LPCONTAINERDOC lpContainerDoc,
LPFORMATETC lpformatetc,
LPSTGMEDIUM lpMedium
);
HRESULT ContainerDoc_GetDataHere (
LPCONTAINERDOC lpContainerDoc,
LPFORMATETC lpformatetc,
LPSTGMEDIUM lpMedium
);
HRESULT ContainerDoc_QueryGetData (
LPCONTAINERDOC lpContainerDoc,
LPFORMATETC lpformatetc
);
HRESULT ContainerDoc_SetData (
LPCONTAINERDOC lpContainerDoc,
LPFORMATETC lpformatetc,
LPSTGMEDIUM lpmedium,
BOOL fRelease
);
HRESULT ContainerDoc_EnumFormatEtc(
LPCONTAINERDOC lpContainerDoc,
DWORD dwDirection,
LPENUMFORMATETC FAR* lplpenumFormatEtc
);
BOOL ContainerDoc_SetupDocGetFmts(
LPCONTAINERDOC lpContainerDoc,
LPCONTAINERLINE lpContainerLine
);
#if defined( INPLACE_CNTR )
void ContainerDoc_ShutDownLastInPlaceServerIfNotNeeded(
LPCONTAINERDOC lpContainerDoc,
LPCONTAINERLINE lpNextActiveLine
);
BOOL ContainerDoc_IsUIDeactivateNeeded(
LPCONTAINERDOC lpContainerDoc,
POINT pt
);
HWND ContainerDoc_GetUIActiveWindow(LPCONTAINERDOC lpContainerDoc);
void ContainerDoc_UpdateInPlaceObjectRects(LPCONTAINERDOC lpContainerDoc, int nIndex);
void ContainerDoc_GetClipRect(
LPCONTAINERDOC lpContainerDoc,
LPRECT lprcClipRect
);
void ContainerDoc_FrameWindowResized(LPCONTAINERDOC lpContainerDoc);
LPOLEINPLACEFRAME ContainerDoc_GetTopInPlaceFrame(
LPCONTAINERDOC lpContainerDoc
);
void ContainerDoc_GetSharedMenuHandles(
LPCONTAINERDOC lpContainerDoc,
HMENU FAR* lphSharedMenu,
HOLEMENU FAR* lphOleMenu
);
void ContainerDoc_RemoveFrameLevelTools(LPCONTAINERDOC lpContainerDoc);
void ContainerDoc_AddFrameLevelUI(LPCONTAINERDOC lpContainerDoc);
void ContainerDoc_AddFrameLevelTools(LPCONTAINERDOC lpContainerDoc);
#if defined( INPLACE_CNTRSVR ) || defined( INPLACE_MDICNTR )
LPOLEINPLACEUIWINDOW ContainerDoc_GetTopInPlaceDoc(
LPCONTAINERDOC lpContainerDoc
);
void ContainerDoc_RemoveDocLevelTools(LPCONTAINERDOC lpContainerDoc);
void ContainerDoc_AddDocLevelTools(LPCONTAINERDOC lpContainerDoc);
#endif // INPLACE_CNTRSVR || INPLACE_MDICNTR
#endif // INPLACE_CNTR
/* ContainerDoc::IOleUILinkContainer methods (functions) */
STDMETHODIMP CntrDoc_LinkCont_QueryInterface(
LPOLEUILINKCONTAINER lpThis,
REFIID riid,
LPVOID FAR* lplpvObj
);
STDMETHODIMP_(ULONG) CntrDoc_LinkCont_AddRef(LPOLEUILINKCONTAINER lpThis);
STDMETHODIMP_(ULONG) CntrDoc_LinkCont_Release(LPOLEUILINKCONTAINER lpThis);
STDMETHODIMP_(DWORD) CntrDoc_LinkCont_GetNextLink(
LPOLEUILINKCONTAINER lpThis,
DWORD dwLink
);
STDMETHODIMP CntrDoc_LinkCont_SetLinkUpdateOptions(
LPOLEUILINKCONTAINER lpThis,
DWORD dwLink,
DWORD dwUpdateOpt
);
STDMETHODIMP CntrDoc_LinkCont_GetLinkUpdateOptions(
LPOLEUILINKCONTAINER lpThis,
DWORD dwLink,
DWORD FAR* dwUpdateOpt
);
STDMETHODIMP CntrDoc_LinkCont_SetLinkSource(
LPOLEUILINKCONTAINER lpThis,
DWORD dwLink,
LPSTR lpszDisplayName,
ULONG clenFileName,
ULONG FAR* lpchEaten,
BOOL fValidateSource
);
STDMETHODIMP CntrDoc_LinkCont_GetLinkSource(
LPOLEUILINKCONTAINER lpThis,
DWORD dwLink,
LPSTR FAR* lplpszDisplayName,
ULONG FAR* lplenFileName,
LPSTR FAR* lplpszFullLinkType,
LPSTR FAR* lplpszShortLinkType,
BOOL FAR* lpfSourceAvailable,
BOOL FAR* lpfIsSelected
);
STDMETHODIMP CntrDoc_LinkCont_OpenLinkSource(
LPOLEUILINKCONTAINER lpThis,
DWORD dwLink
);
STDMETHODIMP CntrDoc_LinkCont_UpdateLink(
LPOLEUILINKCONTAINER lpThis,
DWORD dwLink,
BOOL fErrorMessage,
BOOL fErrorAction
);
STDMETHODIMP CntrDoc_LinkCont_CancelLink(
LPOLEUILINKCONTAINER lpThis,
DWORD dwLink
);
/*************************************************************************
** class CONTAINERAPP : OLEAPP
** CONTAINERAPP is an extention to the base OLEAPP object (structure)
** that adds special Container functionality. There is one instance of
** CONTAINERApp object created per running application instance. This
** object holds many fields that could otherwise be organized as
** global variables. The CONTAINERAPP class inherits all fields
** from the OLEAPP class. This inheritance is achieved by including a
** member variable of type OLEAPP as the first field in the CONTAINERAPP
** structure. OLEAPP inherits from OUTLINEAPP. This inheritance is
** achieved in the same manner. Thus a pointer to a CONTAINERAPP object
** can be cast to be a pointer to an OLEAPP or an OUTLINEAPP object
*************************************************************************/
/* Forward definition of types */
typedef struct tagCONTAINERAPP FAR* LPCONTAINERAPP;
typedef struct tagCONTAINERAPP {
OLEAPP m_OleApp; // ContainerApp inherits all fields of OleApp
UINT m_cfCntrOutl; // clipboard format for CntrOutl (client ver) data
int m_nSingleObjGetFmts; // no. formats avail when single obj copied
FORMATETC m_arrSingleObjGetFmts[MAXNOFMTS];
// array of FormatEtc's available via
// IDataObject::GetData when a single
// OLE object is copied.
#if defined( INPLACE_CNTR )
HACCEL m_hAccelIPCntr; // accelerators for container's workspace commands
HMENU m_hMenuFile; // handle to File menu of container app
HMENU m_hMenuView; // handle to View menu of container app
HMENU m_hMenuDebug; // handle to Debug menu of container app
LPOLEINPLACEACTIVEOBJECT m_lpIPActiveObj; // ptr to inplace active OLE obj
HWND m_hWndUIActiveObj; // HWND of UIActive obj.
BOOL m_fPendingUIDeactivate; // should app UIDeactivate on LBUTTONUP
BOOL m_fMustResizeClientArea;// if client area resize pending
// (see Doc_FrameWindowResized)
BOOL m_fMenuHelpMode;// is F1 pressed in menu, if so give help
#ifdef _DEBUG
BOOL m_fOutSideIn;
#endif
struct COleInPlaceFrameImpl {
IOleInPlaceFrameVtbl FAR* lpVtbl;
LPCONTAINERAPP lpContainerApp;
int cRef; // interface specific ref count.
} m_OleInPlaceFrame;
#endif // INPLACE_CNTR
} CONTAINERAPP;
/* ContainerApp methods (functions) */
BOOL ContainerApp_InitInstance(
LPCONTAINERAPP lpContainerApp,
HINSTANCE hInst,
int nCmdShow
);
BOOL ContainerApp_InitVtbls(LPCONTAINERAPP lpApp);
#if defined( INPLACE_CNTR )
/* ContainerApp::IOleInPlaceFrame methods (functions) */
STDMETHODIMP CntrApp_IPFrame_QueryInterface(
LPOLEINPLACEFRAME lpThis,
REFIID riid,
LPVOID FAR* lplpvObj
);
STDMETHODIMP_(ULONG) CntrApp_IPFrame_AddRef(LPOLEINPLACEFRAME lpThis);
STDMETHODIMP_(ULONG) CntrApp_IPFrame_Release(LPOLEINPLACEFRAME lpThis);
STDMETHODIMP CntrApp_IPFrame_GetWindow(
LPOLEINPLACEFRAME lpThis,
HWND FAR* lphwnd
);
STDMETHODIMP CntrApp_IPFrame_ContextSensitiveHelp(
LPOLEINPLACEFRAME lpThis,
BOOL fEnterMode
);
STDMETHODIMP CntrApp_IPFrame_GetBorder(
LPOLEINPLACEFRAME lpThis,
LPRECT lprectBorder
);
STDMETHODIMP CntrApp_IPFrame_RequestBorderSpace(
LPOLEINPLACEFRAME lpThis,
LPCBORDERWIDTHS lpWidths
);
STDMETHODIMP CntrApp_IPFrame_SetBorderSpace(
LPOLEINPLACEFRAME lpThis,
LPCBORDERWIDTHS lpWidths
);
STDMETHODIMP CntrApp_IPFrame_SetActiveObject(
LPOLEINPLACEFRAME lpThis,
LPOLEINPLACEACTIVEOBJECT lpActiveObject,
LPCOLESTR lpszObjName
);
STDMETHODIMP CntrApp_IPFrame_InsertMenus(
LPOLEINPLACEFRAME lpThis,
HMENU hmenu,
LPOLEMENUGROUPWIDTHS lpMenuWidths
);
STDMETHODIMP CntrApp_IPFrame_SetMenu(
LPOLEINPLACEFRAME lpThis,
HMENU hmenuShared,
HOLEMENU holemenu,
HWND hwndActiveObject
);
STDMETHODIMP CntrApp_IPFrame_RemoveMenus(
LPOLEINPLACEFRAME lpThis,
HMENU hmenu
);
STDMETHODIMP CntrApp_IPFrame_SetStatusText(
LPOLEINPLACEFRAME lpThis,
LPCOLESTR lpszStatusText
);
STDMETHODIMP CntrApp_IPFrame_EnableModeless(
LPOLEINPLACEFRAME lpThis,
BOOL fEnable
);
STDMETHODIMP CntrApp_IPFrame_TranslateAccelerator(
LPOLEINPLACEFRAME lpThis,
LPMSG lpmsg,
WORD wID
);
#endif // INPLACE_CNTR
#endif // _CNTROUTL_H_