/*************************************************************************
**
**    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"
#include "ansiapi.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 OLESTR("Object")
#define szOLELINK   OLESTR("Link")

#ifdef TEST32
#define CONTAINERDOCFORMAT  OLESTR("CntrOu32")      // CF_CntrOutl format name
#else
#define CONTAINERDOCFORMAT  OLESTR("CntrOutl")      // CF_CntrOutl format name
#endif //TEST32

/* 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
   OLECHAR         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?
   LPOLESTR        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,
      LPOLESTR                lpszFileName,
      BOOL                    fDisplayAsIcon,
      HGLOBAL                 hMetaPict,
      LPOLESTR                lpszStgName
);
LPCONTAINERLINE ContainerLine_CreateFromData(
      HDC                     hDC,
      UINT                    nTab,
      LPCONTAINERDOC          lpContainerDoc,
      LPDATAOBJECT            lpSrcDataObj,
      DWORD                   dwCreateType,
      CLIPFORMAT              cfFormat,
      BOOL                    fDisplayAsIcon,
      HGLOBAL                 hMetaPict,
      LPOLESTR                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,LPOLESTR 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
{
      OLECHAR 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 {
   OLECHAR 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,
      LPCOLESTR               lpszFileName,
      UINT                    uFormat,
      BOOL                    fRemember
);
void ContainerDoc_ContainerLineDoVerbCommand(
      LPCONTAINERDOC          lpContainerDoc,
      LONG                    iVerb
);
void ContainerDoc_GetNextStgName(
      LPCONTAINERDOC          lpContainerDoc,
      LPOLESTR                lpszStgName,
      int                     nLen
);
BOOL ContainerDoc_IsStgNameUsed(
      LPCONTAINERDOC          lpContainerDoc,
      LPOLESTR                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,
      LPOLESTR                lpszDisplayName,
      ULONG                   clenFileName,
      ULONG FAR*              lpchEaten,
      BOOL                    fValidateSource
);
STDMETHODIMP CntrDoc_LinkCont_GetLinkSource(
      LPOLEUILINKCONTAINER    lpThis,
      DWORD                   dwLink,
      LPOLESTR FAR*           lplpszDisplayName,
      ULONG FAR*              lplenFileName,
      LPOLESTR FAR*           lplpszFullLinkType,
      LPOLESTR 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_
