Tricks of the Windows Gam…ming Gurus (2nd Edition)/Disc2.iso/vc98/mfc/include/afxole.h

C/C++ Source or Header | 1998-06-16 | 68KB | 1,960 lines

// This is a part of the Microsoft Foundation Classes C++ library.
// Copyright (C) 1992-1998 Microsoft Corporation
// All rights reserved.
//
// This source code is only intended as a supplement to the
// Microsoft Foundation Classes Reference and related
// electronic documentation provided with the library.
// See these sources for detailed information regarding the
// Microsoft Foundation Classes product.

#ifndef __AFXOLE_H__
#define __AFXOLE_H__

#ifdef _AFX_NO_OLE_SUPPORT
    #error OLE classes not supported in this library variant.
#endif

#ifndef __AFXEXT_H__
    #include <afxext.h>
#endif

#ifndef __AFXDISP_H__
    #include <afxdisp.h>
#endif

// include OLE Compound Document headers
#ifndef _OLE2_H_
    #include <ole2.h>
#endif

// ActiveX Document support
#ifndef __docobj_h__
    #include <docobj.h>
#endif

// URL Monikers support
#ifndef __urlmon_h__
    #include <urlmon.h>
#endif

#ifndef __AFXCOM_H__
#include <afxcom_.h>
#endif

#ifdef _AFX_MINREBUILD
#pragma component(minrebuild, off)
#endif
#ifndef _AFX_FULLTYPEINFO
#pragma component(mintypeinfo, on)
#endif

#ifdef _AFX_PACKING
#pragma pack(push, _AFX_PACKING)
#endif


#ifndef _AFX_NOFORCE_LIBS

#pragma comment(lib, "urlmon.lib")

#endif // !_AFX_NOFORCE_LIBS

/////////////////////////////////////////////////////////////////////////////
// AFXOLE.H - MFC OLE support

// Classes declared in this file

//CDocument
    class COleDocument;             // OLE container document
        class COleLinkingDoc;       // supports links to embeddings
            class COleServerDoc;    // OLE server document
    class CDocObjectServer;         // might be owned by a COleServerDoc

//CCmdTarget
    class CDocItem;                 // part of a document
        class COleClientItem;       // embedded ole object from outside
            class COleDocObjectItem;// ActiveX Document item
        class COleServerItem;       // ole object to export
    class COleDataSource;           // clipboard data source mechanism
    class COleDropSource;           // drag/drop source
    class COleDropTarget;           // drag/drop target
    class COleMessageFilter;        // concurrency management

//CFrameWnd
    class COleIPFrameWnd;           // frame window for in-place servers

//CControlBar
    class COleResizeBar;            // implements in-place resizing

//CFile
    class COleStreamFile;           // CFile wrapper for IStream interface
        class CMonikerFile;         // bound to via IMoniker
            class CAsyncMonikerFile;// asynchronous IMoniker

class COleDataObject;               // wrapper for IDataObject interface

/////////////////////////////////////////////////////////////////////////////

// AFXDLL support
#undef AFX_DATA
#define AFX_DATA AFX_OLE_DATA

/////////////////////////////////////////////////////////////////////////////
// backward compatibility

// COleClientDoc is now obsolete -- use COleDocument instead
#define COleClientDoc COleDocument

// COleServer has been replaced by the more general COleObjectFactory
#define COleServer  COleObjectFactory

/////////////////////////////////////////////////////////////////////////////
// Useful OLE specific types (some from OLE 1.0 headers)

// Codes for CallBack events
enum OLE_NOTIFICATION
{
    OLE_CHANGED,        // representation of a draw aspect has changed
    OLE_SAVED,          // the item has committed its storage
    OLE_CLOSED,         // the item has closed
    OLE_RENAMED,        // the item has changed its moniker
    OLE_CHANGED_STATE,  // the item state (open, active, etc.) has changed
    OLE_CHANGED_ASPECT, // the item draw aspect has changed
};

// Object types
enum OLE_OBJTYPE
{
    OT_UNKNOWN = 0,

    // These are OLE 1.0 types and OLE 2.0 types as returned from GetType().
    OT_LINK = 1,
    OT_EMBEDDED = 2,
    OT_STATIC = 3,

    // All OLE2 objects are written with this tag when serialized.  This
    //  differentiates them from OLE 1.0 objects written with MFC 2.0.
    //  This value will never be returned from GetType().
    OT_OLE2 = 256,
};

/////////////////////////////////////////////////////////////////////////////
// COleDataObject -- simple wrapper for IDataObject

class COleDataObject
{
// Constructors
public:
    COleDataObject();

// Operations
    void Attach(LPDATAOBJECT lpDataObject, BOOL bAutoRelease = TRUE);
    LPDATAOBJECT Detach();  // detach and get ownership of m_lpDataObject
    void Release(); // detach and Release ownership of m_lpDataObject
    BOOL AttachClipboard(); // attach to current clipboard object

// Attributes
    void BeginEnumFormats();
    BOOL GetNextFormat(LPFORMATETC lpFormatEtc);
    CFile* GetFileData(CLIPFORMAT cfFormat, LPFORMATETC lpFormatEtc = NULL);
    HGLOBAL GetGlobalData(CLIPFORMAT cfFormat, LPFORMATETC lpFormatEtc = NULL);
    BOOL GetData(CLIPFORMAT cfFormat, LPSTGMEDIUM lpStgMedium,
        LPFORMATETC lpFormatEtc = NULL);
    BOOL IsDataAvailable(CLIPFORMAT cfFormat, LPFORMATETC lpFormatEtc = NULL);

// Implementation
public:
    LPDATAOBJECT m_lpDataObject;
    LPENUMFORMATETC m_lpEnumerator;
    ~COleDataObject();

    // advanced use and implementation
    LPDATAOBJECT GetIDataObject(BOOL bAddRef);
    void EnsureClipboardObject();
    BOOL m_bClipboard;      // TRUE if represents the Win32 clipboard

protected:
    BOOL m_bAutoRelease;    // TRUE if destructor should call Release

private:
    // Disable the copy constructor and assignment by default so you will get
    //   compiler errors instead of unexpected behaviour if you pass objects
    //   by value or assign objects.
    COleDataObject(const COleDataObject&);  // no implementation
    void operator=(const COleDataObject&);  // no implementation
};

/////////////////////////////////////////////////////////////////////////////
// COleDataSource -- wrapper for implementing IDataObject
//  (works similar to how data is provided on the clipboard)

struct AFX_DATACACHE_ENTRY;
class COleDropSource;

class COleDataSource : public CCmdTarget
{
// Constructors
public:
    COleDataSource();

// Operations
    void Empty();   // empty cache (similar to ::EmptyClipboard)

    // CacheData & DelayRenderData operations similar to ::SetClipboardData
    void CacheGlobalData(CLIPFORMAT cfFormat, HGLOBAL hGlobal,
        LPFORMATETC lpFormatEtc = NULL);    // for HGLOBAL based data
    void DelayRenderFileData(CLIPFORMAT cfFormat,
        LPFORMATETC lpFormatEtc = NULL);    // for CFile* based delayed render

    // Clipboard and Drag/Drop access
    DROPEFFECT DoDragDrop(
        DWORD dwEffects = DROPEFFECT_COPY|DROPEFFECT_MOVE|DROPEFFECT_LINK,
        LPCRECT lpRectStartDrag = NULL,
        COleDropSource* pDropSource = NULL);
    void SetClipboard();
    static void PASCAL FlushClipboard();
    static COleDataSource* PASCAL GetClipboardOwner();

    // Advanced: STGMEDIUM based cached data
    void CacheData(CLIPFORMAT cfFormat, LPSTGMEDIUM lpStgMedium,
        LPFORMATETC lpFormatEtc = NULL);    // for LPSTGMEDIUM based data
    // Advanced: STGMEDIUM or HGLOBAL based delayed render
    void DelayRenderData(CLIPFORMAT cfFormat, LPFORMATETC lpFormatEtc = NULL);

    // Advanced: support for SetData in COleServerItem
    //  (not generally useful for clipboard or drag/drop operations)
    void DelaySetData(CLIPFORMAT cfFormat, LPFORMATETC lpFormatEtc = NULL);

// Overidables
    virtual BOOL OnRenderGlobalData(LPFORMATETC lpFormatEtc, HGLOBAL* phGlobal);
    virtual BOOL OnRenderFileData(LPFORMATETC lpFormatEtc, CFile* pFile);
    virtual BOOL OnRenderData(LPFORMATETC lpFormatEtc, LPSTGMEDIUM lpStgMedium);
        // OnRenderFileData and OnRenderGlobalData are called by
        //  the default implementation of OnRenderData.

    virtual BOOL OnSetData(LPFORMATETC lpFormatEtc, LPSTGMEDIUM lpStgMedium,
        BOOL bRelease);
        // used only in COleServerItem implementation

// Implementation
public:
    virtual ~COleDataSource();
#ifdef _DEBUG
    virtual void AssertValid() const;
    virtual void Dump(CDumpContext& dc) const;
#endif

protected:
    AFX_DATACACHE_ENTRY* m_pDataCache;  // data cache itself
    UINT m_nMaxSize;    // current allocated size
    UINT m_nSize;       // current size of the cache
    UINT m_nGrowBy;     // number of cache elements to grow by for new allocs

    AFX_DATACACHE_ENTRY* Lookup(
        LPFORMATETC lpFormatEtc, DATADIR nDataDir) const;
    AFX_DATACACHE_ENTRY* GetCacheEntry(
        LPFORMATETC lpFormatEtc, DATADIR nDataDir);

// Interface Maps
public:
    BEGIN_INTERFACE_PART(DataObject, IDataObject)
        INIT_INTERFACE_PART(COleDataSource, DataObject)
        STDMETHOD(GetData)(LPFORMATETC, LPSTGMEDIUM);
        STDMETHOD(GetDataHere)(LPFORMATETC, LPSTGMEDIUM);
        STDMETHOD(QueryGetData)(LPFORMATETC);
        STDMETHOD(GetCanonicalFormatEtc)(LPFORMATETC, LPFORMATETC);
        STDMETHOD(SetData)(LPFORMATETC, LPSTGMEDIUM, BOOL);
        STDMETHOD(EnumFormatEtc)(DWORD, LPENUMFORMATETC*);
        STDMETHOD(DAdvise)(LPFORMATETC, DWORD, LPADVISESINK, LPDWORD);
        STDMETHOD(DUnadvise)(DWORD);
        STDMETHOD(EnumDAdvise)(LPENUMSTATDATA*);
    END_INTERFACE_PART(DataObject)

    DECLARE_INTERFACE_MAP()

    friend class COleServerItem;
};

//////////////////////////////////////////////////////////////////////////////
// DocItem support

#ifdef _AFXDLL
class CDocItem : public CCmdTarget
#else
class AFX_NOVTABLE CDocItem : public CCmdTarget
#endif
{
    DECLARE_SERIAL(CDocItem)

// Constructors
protected:      // abstract class
    CDocItem();

// Attributes
public:
    CDocument* GetDocument() const; // return container document

// Overridables
public:
    // Raw data access (native format)
    virtual BOOL IsBlank() const;

// Implementation
protected:
    COleDocument* m_pDocument;

public:
    virtual void Serialize(CArchive& ar);   // for Native data
    virtual ~CDocItem();
#ifdef _DEBUG
    virtual void AssertValid() const;
    virtual void Dump(CDumpContext& dc) const;
#endif

    friend class COleDocument;              // for access to back pointer
};

//////////////////////////////////////////////////////////////////////////////
// COleDocument - common OLE container behavior (enables server functionality)

class COleDocument : public CDocument
{
    DECLARE_DYNAMIC(COleDocument)

// Constructors
public:
    COleDocument();

// Attributes
    BOOL HasBlankItems() const; // check for BLANK items
    virtual COleClientItem* GetInPlaceActiveItem(CWnd* pWnd);
        // return in-place active item for this view or NULL if none

// Operations
    // iterating over existing items
    virtual POSITION GetStartPosition() const;
    virtual CDocItem* GetNextItem(POSITION& pos) const;

    // iterator helpers (helpers use virtual GetNextItem above)
    COleClientItem* GetNextClientItem(POSITION& pos) const;
    COleServerItem* GetNextServerItem(POSITION& pos) const;

    // adding new items - called from item constructors
    virtual void AddItem(CDocItem* pItem);
    virtual void RemoveItem(CDocItem* pItem);

    void EnableCompoundFile(BOOL bEnable = TRUE);
        // enable compound file support (only call during constructor)
    virtual void UpdateModifiedFlag();
        // scan for modified items -- mark document modified

    // printer-device caching/control
    BOOL ApplyPrintDevice(const DVTARGETDEVICE* ptd);
    BOOL ApplyPrintDevice(const PRINTDLG* ppd);
        // these apply the target device to all COleClientItem objects

// Overridables
    virtual COleClientItem* GetPrimarySelectedItem(CView* pView);
        // return primary selected item or NULL if none
    virtual void OnShowViews(BOOL bVisible);
        // called during app-idle when visibility of a document has changed

// Implementation
public:
    CObList m_docItemList;  // not owned items

#ifdef _DEBUG
    virtual void AssertValid() const;
    virtual void Dump(CDumpContext& dc) const;
#endif
    CFrameWnd* GetFirstFrame();

    // document handling overrides
    virtual void SetPathName(LPCTSTR lpszPathName, BOOL bAddToMRU = TRUE);
    virtual ~COleDocument();
    virtual void DeleteContents(); // delete client items in list
    virtual void Serialize(CArchive& ar);   // serialize items to file
    virtual void PreCloseFrame(CFrameWnd* pFrame);
    virtual BOOL SaveModified();
    virtual void OnIdle();

    // compound file implementation
    virtual BOOL OnNewDocument();
    virtual BOOL OnOpenDocument(LPCTSTR lpszPathName);
    virtual BOOL OnSaveDocument(LPCTSTR lpszPathName);
    virtual void OnCloseDocument();
    void CommitItems(BOOL bSuccess);    // called during File.Save & File.Save As

    // minimal linking protocol
    virtual LPMONIKER GetMoniker(OLEGETMONIKER nAssign);
    virtual LPOLEITEMCONTAINER GetContainer();

protected:
    // document state implementation
    UINT m_dwNextItemNumber;// serial number for next item in this document
    BOOL m_bLastVisible;    // TRUE if one or more views was last visible

    // 'docfile' support
    BOOL m_bCompoundFile;   // TRUE if use compound files
    LPSTORAGE m_lpRootStg;  // root storage for the document
    BOOL m_bSameAsLoad;     // TRUE = file-save, FALSE = Save [Copy] As
    BOOL m_bRemember;       // if FALSE, indicates Save Copy As

    DVTARGETDEVICE* m_ptd;  // current document target device

    // implementation helpers
    virtual void LoadFromStorage();
    virtual void SaveToStorage(CObject* pObject = NULL);
    CDocItem* GetNextItemOfKind(POSITION& pos, CRuntimeClass* pClass) const;

    // command handling
public:
    virtual BOOL OnCmdMsg(UINT nID, int nCode, void* pExtra,
        AFX_CMDHANDLERINFO* pHandlerInfo);

protected:
    afx_msg void OnUpdatePasteMenu(CCmdUI* pCmdUI);
    afx_msg void OnUpdatePasteLinkMenu(CCmdUI* pCmdUI);
    afx_msg void OnUpdateEditLinksMenu(CCmdUI* pCmdUI);
    afx_msg void OnEditLinks();
    afx_msg void OnEditConvert();
    afx_msg void OnUpdateEditChangeIcon(CCmdUI* pCmdUI);
    afx_msg void OnEditChangeIcon();
    afx_msg void OnUpdateObjectVerbMenu(CCmdUI* pCmdUI);
    afx_msg void OnFileSendMail();

    friend class COleClientItem;
    friend class COleServerItem;
};

/////////////////////////////////////////////////////////////////////////////
// COleClientItem - Supports OLE2 non-inplace editing.
//      implements IOleClientSite, IAdviseSink, and IOleInPlaceSite

class COleFrameHook;    // forward reference (see ..\src\oleimpl2.h)

class COleClientItem : public CDocItem
{
    DECLARE_DYNAMIC(COleClientItem)

// Constructors
public:
    COleClientItem(COleDocument* pContainerDoc = NULL);

    // create from the clipboard
    BOOL CreateFromClipboard(OLERENDER render = OLERENDER_DRAW,
        CLIPFORMAT cfFormat = 0, LPFORMATETC lpFormatEtc = NULL);
    BOOL CreateLinkFromClipboard(OLERENDER render = OLERENDER_DRAW,
        CLIPFORMAT cfFormat = 0, LPFORMATETC lpFormatEtc = NULL);
    BOOL CreateStaticFromClipboard(OLERENDER render = OLERENDER_DRAW,
        CLIPFORMAT cfFormat = 0, LPFORMATETC lpFormatEtc = NULL);

    // create from a class ID (Insert New Object dialog)
    BOOL CreateNewItem(REFCLSID clsid, OLERENDER render = OLERENDER_DRAW,
        CLIPFORMAT cfFormat = 0, LPFORMATETC lpFormatEtc = NULL);

    // create from COleDataObject
    BOOL CreateFromData(COleDataObject* pDataObject,
        OLERENDER render = OLERENDER_DRAW,
        CLIPFORMAT cfFormat = 0, LPFORMATETC lpFormatEtc = NULL);
    BOOL CreateLinkFromData(COleDataObject* pDataObject,
        OLERENDER render = OLERENDER_DRAW,
        CLIPFORMAT cfFormat = 0, LPFORMATETC lpFormatEtc = NULL);
    BOOL CreateStaticFromData(COleDataObject* pDataObject,
        OLERENDER render = OLERENDER_DRAW,
        CLIPFORMAT cfFormat = 0, LPFORMATETC lpFormatEtc = NULL);

    // create from file (package support)
    BOOL CreateFromFile(LPCTSTR lpszFileName, REFCLSID clsid = CLSID_NULL,
        OLERENDER render = OLERENDER_DRAW,
        CLIPFORMAT cfFormat = 0, LPFORMATETC lpFormatEtc = NULL);
    BOOL CreateLinkFromFile(LPCTSTR lpszFileName,
        OLERENDER render = OLERENDER_DRAW,
        CLIPFORMAT cfFormat = 0, LPFORMATETC lpFormatEtc = NULL);

    // create a copy
    BOOL CreateCloneFrom(const COleClientItem* pSrcItem);

// General Attributes
public:
    HICON GetIconFromRegistry() const;
    static HICON GetIconFromRegistry(CLSID& clsid);
    SCODE GetLastStatus() const;
    OLE_OBJTYPE GetType() const; // OT_LINK, OT_EMBEDDED, OT_STATIC
    void GetClassID(CLSID* pClassID) const;
    void GetUserType(USERCLASSTYPE nUserClassType, CString& rString);
    BOOL GetExtent(LPSIZE lpSize, DVASPECT nDrawAspect = (DVASPECT)-1);
        // will return FALSE if item is BLANK
    BOOL GetCachedExtent(LPSIZE lpSize, DVASPECT nDrawAspect = (DVASPECT)-1);

    // getting/setting iconic cache
    HGLOBAL GetIconicMetafile();
    BOOL SetIconicMetafile(HGLOBAL hMetaPict);

    // setting/getting default display aspect
    DVASPECT GetDrawAspect() const;
    virtual void SetDrawAspect(DVASPECT nDrawAspect);

    // for printer presentation cache
    BOOL SetPrintDevice(const DVTARGETDEVICE* ptd);
    BOOL SetPrintDevice(const PRINTDLG* ppd);

    // Item state
    enum ItemState
        { emptyState, loadedState, openState, activeState, activeUIState };
    UINT GetItemState() const;

    BOOL IsModified() const;
    BOOL IsRunning() const;
    BOOL IsInPlaceActive() const;
    BOOL IsOpen() const;
    CView* GetActiveView() const;

    // Data access
    void AttachDataObject(COleDataObject& rDataObject) const;

    // other rare access information
    COleDocument* GetDocument() const; // return container

    // helpers for checking clipboard data availability
    static BOOL PASCAL CanPaste();
    static BOOL PASCAL CanPasteLink();

    // helpers for checking COleDataObject, useful in drag drop
    static BOOL PASCAL CanCreateFromData(const COleDataObject* pDataObject);
    static BOOL PASCAL CanCreateLinkFromData(const COleDataObject* pDataObject);

// General Operations
    virtual void Release(OLECLOSE dwCloseOption = OLECLOSE_NOSAVE);
        // cleanup, detach (close if needed)
    void Close(OLECLOSE dwCloseOption = OLECLOSE_SAVEIFDIRTY);
        // close without releasing the item
    void Delete(BOOL bAutoDelete = TRUE);
        // logically delete from file -- not part of the document anymore
    void Run(); // insure item is in running state

    // Drawing
    BOOL Draw(CDC* pDC, LPCRECT lpBounds,
        DVASPECT nDrawAspect = (DVASPECT)-1);   // defaults to m_nDrawAspect

    // Activation
    virtual BOOL DoVerb(LONG nVerb, CView* pView, LPMSG lpMsg = NULL);
    void Activate(LONG nVerb, CView* pView, LPMSG lpMsg = NULL);

    // In-place Activation
    void Deactivate();          // completely deactivate
    void DeactivateUI();        // deactivate the user interface
    BOOL ReactivateAndUndo();   // reactivate then perform undo command
    BOOL SetItemRects(LPCRECT lpPosRect = NULL, LPCRECT lpClipRect = NULL);
    CWnd* GetInPlaceWindow();

    // Clipboard operations
    void CopyToClipboard(BOOL bIncludeLink = FALSE);
    DROPEFFECT DoDragDrop(LPCRECT lpItemRect, CPoint ptOffset,
        BOOL bIncludeLink = FALSE,
        DWORD dwEffects = DROPEFFECT_COPY|DROPEFFECT_MOVE,
        LPCRECT lpRectStartDrag = NULL);
    void GetClipboardData(COleDataSource* pDataSource,
        BOOL bIncludeLink = FALSE, LPPOINT lpOffset = NULL,
        LPSIZE lpSize = NULL);

    // called for creating a COleDataSource by CopyToClipboard and DoDragDrop
    virtual COleDataSource* OnGetClipboardData(BOOL bIncludeLink,
        LPPOINT lpOffset, LPSIZE lpSize);

    // Operations that apply to embedded items only
    void SetHostNames(LPCTSTR lpszHost, LPCTSTR lpszHostObj);
    void SetExtent(const CSize& size, DVASPECT nDrawAspect = DVASPECT_CONTENT);

    // Operations that apply to linked items only
    //  (link options are rarely changed, except through Links dialog)
    OLEUPDATE GetLinkUpdateOptions();
    void SetLinkUpdateOptions(OLEUPDATE dwUpdateOpt);

    // Link-source update status (also useful for embeddings that contain links)
    BOOL UpdateLink();  // make up-to-date
    BOOL IsLinkUpToDate() const;    // is link up-to-date

    // object conversion
    virtual BOOL ConvertTo(REFCLSID clsidNew);
    virtual BOOL ActivateAs(LPCTSTR lpszUserType, REFCLSID clsidOld, REFCLSID clsidNew);
    BOOL Reload();  // for lazy reload after ActivateAs

// Overridables (notifications of IAdviseSink, IOleClientSite and IOleInPlaceSite)
    // Callbacks/notifications from the server you must/should implement
    virtual void OnChange(OLE_NOTIFICATION nCode, DWORD dwParam);
        // implement OnChange to invalidate when item changes

protected:
    virtual void OnGetItemPosition(CRect& rPosition);
        // implement OnGetItemPosition if you support in-place activation

    // Common overrides for in-place activation
    virtual BOOL OnScrollBy(CSize sizeExtent);

    // Common overrides for applications supporting undo
    virtual void OnDiscardUndoState();
    virtual void OnDeactivateAndUndo();

public:
    virtual void OnDeactivateUI(BOOL bUndoable);

protected:
    // Common overrides for applications supporting links to embeddings
    virtual void OnShowItem();

    // Advanced overrides for in-place activation
    virtual void OnGetClipRect(CRect& rClipRect);
    virtual BOOL CanActivate();

public:
    virtual void OnActivate();
    virtual void OnActivateUI();
    virtual void OnDeactivate();

protected:
    virtual BOOL OnGetWindowContext(CFrameWnd** ppMainFrame,
        CFrameWnd** ppDocFrame, LPOLEINPLACEFRAMEINFO lpFrameInfo);
    virtual BOOL OnChangeItemPosition(const CRect& rectPos);
        // default calls SetItemRects and caches the pos rect

public:
    // Advanced overrides for menu/title handling (rarely overridden)
    virtual void OnInsertMenus(CMenu* pMenuShared,
        LPOLEMENUGROUPWIDTHS lpMenuWidths);
    virtual void OnSetMenu(CMenu* pMenuShared, HOLEMENU holemenu,
        HWND hwndActiveObject);
    virtual void OnRemoveMenus(CMenu* pMenuShared);
    virtual BOOL OnUpdateFrameTitle();

    // Advanced override for control bar handling
    virtual BOOL OnShowControlBars(CFrameWnd* pFrameWnd, BOOL bShow);

// Implementation
public:
    // data to support non-inplace activated items
    LPOLEOBJECT m_lpObject; // in case you want direct access to the OLE object
    LPVIEWOBJECT2 m_lpViewObject;// IViewObject for IOleObject above
    DWORD m_dwItemNumber;   // serial number for this item in this document
    DVASPECT m_nDrawAspect; // current default display aspect
    SCODE m_scLast;         // last error code encountered
    LPSTORAGE m_lpStorage;  // provides storage for m_lpObject
    LPLOCKBYTES m_lpLockBytes;  // part of implementation of m_lpStorage
    DWORD m_dwConnection;   // advise connection to the m_lpObject
    BYTE m_bLinkUnavail;    // TRUE if link is currently unavailable
    BYTE m_bMoniker;        // TRUE if moniker is assigned
    BYTE m_bLocked;         // TRUE if object has external lock
    BYTE m_bNeedCommit;     // TRUE if need CommitItem
    BYTE m_bClosing;        // TRUE if currently doing COleClientItem::Close
    BYTE m_bReserved[3];    // (reserved for future use)

    // for compound file support
    LPSTORAGE m_lpNewStorage;   // used during Save As situations

    // item state & item type
    ItemState m_nItemState; // item state (see ItemState enumeration)
    OLE_OBJTYPE m_nItemType;    // item type (depends on how created)

    // data valid when in-place activated
    CView* m_pView; // view when object is in-place activated
    DWORD m_dwContainerStyle;   // style of the container wnd before activation
    COleFrameHook* m_pInPlaceFrame;// frame window when in-place active
    COleFrameHook* m_pInPlaceDoc;   // doc window when in-place (may be NULL)
    HWND m_hWndServer;  // HWND of in-place server window

public:
    virtual ~COleClientItem();
    virtual void Serialize(CArchive& ar);
#ifdef _DEBUG
    virtual void AssertValid() const;
    virtual void Dump(CDumpContext& dc) const;
#endif

// Implementation
public:
    virtual BOOL ReportError(SCODE sc) const;
    virtual BOOL FreezeLink();  // converts to static: for edit links dialog

    DWORD GetNewItemNumber();   // generates new item number
    void GetItemName(LPTSTR lpszItemName) const; // gets readable item name

    void UpdateItemType();  // update m_nItemType

protected:
    // clipboard helpers
    void GetEmbeddedItemData(LPSTGMEDIUM lpStgMedium);
    void AddCachedData(COleDataSource* pDataSource);
    BOOL GetLinkSourceData(LPSTGMEDIUM lpStgMedium);
    void GetObjectDescriptorData(LPPOINT lpOffset, LPSIZE lpSize,
        LPSTGMEDIUM lpStgMedium);

    // interface helpers
    virtual LPOLECLIENTSITE GetClientSite();

    // helpers for printer-cached representation
    BOOL GetPrintDeviceInfo(LPOLECACHE* plpOleCache,
        DVTARGETDEVICE** pptd, DWORD* pdwConnection);

// Advanced Overridables for implementation
protected:
    virtual BOOL FinishCreate(SCODE sc);
    virtual void CheckGeneral(SCODE sc);

    virtual void OnDataChange(LPFORMATETC lpFormatEtc,
        LPSTGMEDIUM lpStgMedium);

public:
    // for storage hookability (override to use 'docfiles')
    virtual void GetItemStorage();  // allocate storage for new item
    virtual void ReadItem(CArchive& ar);    // read item from archive
    virtual void WriteItem(CArchive& ar);   // write item to archive
    virtual void CommitItem(BOOL bSuccess); // commit item's storage

    // compound & flat file implementations of above
    void GetItemStorageFlat();
    void ReadItemFlat(CArchive& ar);
    void WriteItemFlat(CArchive& ar);
    void GetItemStorageCompound();
    void ReadItemCompound(CArchive& ar);
    void WriteItemCompound(CArchive& ar);

// Interface Maps
public:
    BEGIN_INTERFACE_PART(OleClientSite, IOleClientSite)
        INIT_INTERFACE_PART(COleClientItem, OleClientSite)
        STDMETHOD(SaveObject)();
        STDMETHOD(GetMoniker)(DWORD, DWORD, LPMONIKER*);
        STDMETHOD(GetContainer)(LPOLECONTAINER*);
        STDMETHOD(ShowObject)();
        STDMETHOD(OnShowWindow)(BOOL);
        STDMETHOD(RequestNewObjectLayout)();
    END_INTERFACE_PART(OleClientSite)

    BEGIN_INTERFACE_PART(AdviseSink, IAdviseSink)
        INIT_INTERFACE_PART(COleClientItem, AdviseSink)
        STDMETHOD_(void,OnDataChange)(LPFORMATETC, LPSTGMEDIUM);
        STDMETHOD_(void,OnViewChange)(DWORD, LONG);
        STDMETHOD_(void,OnRename)(LPMONIKER);
        STDMETHOD_(void,OnSave)();
        STDMETHOD_(void,OnClose)();
    END_INTERFACE_PART(AdviseSink)

    BEGIN_INTERFACE_PART(OleIPSite, IOleInPlaceSite)
        INIT_INTERFACE_PART(COleClientItem, OleIPSite)
        STDMETHOD(GetWindow)(HWND*);
        STDMETHOD(ContextSensitiveHelp)(BOOL);
        STDMETHOD(CanInPlaceActivate)();
        STDMETHOD(OnInPlaceActivate)();
        STDMETHOD(OnUIActivate)();
        STDMETHOD(GetWindowContext)(LPOLEINPLACEFRAME*,
            LPOLEINPLACEUIWINDOW*, LPRECT, LPRECT, LPOLEINPLACEFRAMEINFO);
        STDMETHOD(Scroll)(SIZE);
        STDMETHOD(OnUIDeactivate)(BOOL);
        STDMETHOD(OnInPlaceDeactivate)();
        STDMETHOD(DiscardUndoState)();
        STDMETHOD(DeactivateAndUndo)();
        STDMETHOD(OnPosRectChange)(LPCRECT);
    END_INTERFACE_PART(OleIPSite)

    DECLARE_INTERFACE_MAP()

// Friendship declarations (to avoid many public members)
    friend class COleUIWindow;
    friend class COleFrameWindow;
    friend class COleLinkingDoc;
};

class COleDocObjectItem : public COleClientItem
{
    friend class COleFrameHook;
    DECLARE_DYNAMIC(COleDocObjectItem)

// Constructors
public:
    COleDocObjectItem(COleDocument* pContainerDoc = NULL);

//Overridables
public:
    LPOLEDOCUMENTVIEW GetActiveView() const;
    virtual void Release(OLECLOSE dwCloseOption = OLECLOSE_NOSAVE);
    virtual void OnInsertMenus(CMenu* pMenuShared,
        LPOLEMENUGROUPWIDTHS lpMenuWidths);
    virtual void OnRemoveMenus(CMenu *pMenuShared);

// Operations
public:
    static BOOL OnPreparePrinting(CView* pCaller, CPrintInfo* pInfo,
        BOOL bPrintAll = TRUE);
    static void OnPrint(CView* pCaller, CPrintInfo* pInfo,
        BOOL bPrintAll = TRUE);
    BOOL GetPageCount(LPLONG pnFirstPage, LPLONG pcPages);
    HRESULT ExecCommand(DWORD nCmdID,
        DWORD nCmdExecOpt = OLECMDEXECOPT_DONTPROMPTUSER,
        const GUID* pguidCmdGroup = NULL);

// Implementation
public:
    virtual ~COleDocObjectItem();
    CMenu* m_pHelpPopupMenu;

protected:
    virtual void OnGetItemPosition(CRect& rPosition);
    virtual CMenu* GetHelpMenu(UINT& nPosition);
    void ActivateAndShow();
    LPOLEDOCUMENTVIEW m_pActiveView;
    LPPRINT m_pIPrint;
    BOOL SupportsIPrint();
    BOOL m_bInHelpMenu;

    BEGIN_INTERFACE_PART(OleDocumentSite, IOleDocumentSite)
        INIT_INTERFACE_PART(COleDocObjectItem, OleDocumentSite)
        STDMETHOD(ActivateMe)(LPOLEDOCUMENTVIEW pViewToActivate);
    END_INTERFACE_PART(OleDocumentSite)

    DECLARE_INTERFACE_MAP()
};

/////////////////////////////////////////////////////////////////////////////
// COleServerItem - IOleObject & IDataObject OLE component

#ifdef _AFXDLL
class COleServerItem : public CDocItem
#else
class AFX_NOVTABLE COleServerItem : public CDocItem
#endif
{
    DECLARE_DYNAMIC(COleServerItem)
protected:
    // NOTE: many members in this class are protected - since everything
    //   in this class is designed for implementing an OLE server.
    // Requests will come from OLE containers through non-C++ mechanisms,
    //   which will result in virtual functions in this class being called.

// Constructors
    COleServerItem(COleServerDoc* pServerDoc, BOOL bAutoDelete);
        // If your COleServerItem is an integral part of your data,
        //  bAutoDelete should be FALSE.  If your COleServerItem can be
        //  deleted when a link is released, it can be TRUE.

    COleDataSource* GetDataSource();
        // Use this data source to add conversion formats that your
        //  server should support.  Usually such formats are
        //  added in the item's constructor.

// Public Attributes
public:
    COleServerDoc* GetDocument() const; // return server document

    // naming (for links only)
    const CString& GetItemName() const; // get name of linked item
    void SetItemName(LPCTSTR lpszItemName);  // set name of linked item

    // link state
    BOOL IsConnected() const;   // returns TRUE if item has a client
    BOOL IsLinkedItem() const;  // returns TRUE if item is not embedded item

    // extents
    CSize m_sizeExtent;
        // HIMETRIC size -- the default implementation of OnSetExtent
        //  updates this member variable.  This member tells the server how
        //  much of the object is visible in the container document.

// Operations
public:
    void NotifyChanged(DVASPECT nDrawAspect = DVASPECT_CONTENT);
        // call this after you change item
    void CopyToClipboard(BOOL bIncludeLink = FALSE);
        // helper for implementing server 'copy to clipboard'
    DROPEFFECT DoDragDrop(LPCRECT lpRectItem, CPoint ptOffset,
        BOOL bIncludeLink = FALSE,
        DWORD dwEffects = DROPEFFECT_COPY|DROPEFFECT_MOVE,
        LPCRECT lpRectStartDrag = NULL);
    void GetClipboardData(COleDataSource* pDataSource,
        BOOL bIncludeLink = FALSE, LPPOINT lpOffset = NULL,
        LPSIZE lpSize = NULL);

// Overridables
    // overridables you must implement for yourself
    virtual BOOL OnDraw(CDC* pDC, CSize& rSize) = 0;
        // drawing for metafile format (return FALSE if not supported or error)
        //  (called for DVASPECT_CONTENT only)

    // overridables you may want to implement yourself
    virtual void OnUpdate(COleServerItem* pSender,
        LPARAM lHint, CObject* pHint, DVASPECT nDrawAspect);
        // the default implementation always calls NotifyChanged

    virtual BOOL OnDrawEx(CDC* pDC, DVASPECT nDrawAspect, CSize& rSize);
        // advanced drawing -- called for DVASPECT other than DVASPECT_CONTENT
    virtual BOOL OnSetExtent(DVASPECT nDrawAspect, const CSize& size);
    virtual BOOL OnGetExtent(DVASPECT nDrawAspect, CSize& rSize);
        // default implementation uses m_sizeExtent

    // overridables you do not have to implement
    virtual void OnDoVerb(LONG iVerb);
        // default routes to OnShow &/or OnOpen
    virtual BOOL OnSetColorScheme(const LOGPALETTE* lpLogPalette);
        // default does nothing
    virtual COleDataSource* OnGetClipboardData(BOOL bIncludeLink,
        LPPOINT lpOffset, LPSIZE lpSize);
        // called for access to clipboard data
    virtual BOOL OnQueryUpdateItems();
        // called to determine if there are any contained out-of-date links
    virtual void OnUpdateItems();
        // called to update any out-of-date links

protected:
    virtual void OnShow();
        // show item in the user interface (may edit in-place)
    virtual void OnOpen();
        // show item in the user interface (must open fully)
    virtual void OnHide();
        // hide document (and sometimes application)

    // very advanced overridables
public:
    virtual BOOL OnInitFromData(COleDataObject* pDataObject, BOOL bCreation);
        // initialize object from IDataObject

    // see COleDataSource for a description of these overridables
    virtual BOOL OnRenderGlobalData(LPFORMATETC lpFormatEtc, HGLOBAL* phGlobal);
    virtual BOOL OnRenderFileData(LPFORMATETC lpFormatEtc, CFile* pFile);
    virtual BOOL OnRenderData(LPFORMATETC lpFormatEtc, LPSTGMEDIUM lpStgMedium);
        // HGLOBAL version will be called first, then CFile* version

    virtual BOOL OnSetData(LPFORMATETC lpFormatEtc, LPSTGMEDIUM lpStgMedium,
        BOOL bRelease);
        // Rare -- only if you support SetData (programmatic paste)

    // advanced helpers for CopyToClipboard
    void GetEmbedSourceData(LPSTGMEDIUM lpStgMedium);
    void AddOtherClipboardData(COleDataSource* pDataSource);
    BOOL GetLinkSourceData(LPSTGMEDIUM lpStgMedium);
    void GetObjectDescriptorData(LPPOINT lpOffset, LPSIZE lpSize,
        LPSTGMEDIUM lpStgMedium);

// Implementation
public:
    BOOL m_bNeedUnlock;             // if TRUE need to pDoc->LockExternal(FALSE)
    BOOL m_bAutoDelete;             // if TRUE will OnRelease will 'delete this'

    // special version of OnFinalRelease to implement document locking
    virtual void OnFinalRelease();

protected:
    CString m_strItemName;          // simple item name

public:
    LPOLEADVISEHOLDER m_lpOleAdviseHolder;  // may be NULL
    LPDATAADVISEHOLDER m_lpDataAdviseHolder;    // may be NULL

    virtual ~COleServerItem();
#ifdef _DEBUG
    virtual void AssertValid() const;
    virtual void Dump(CDumpContext& dc) const;
#endif

    // implementation helpers
    void NotifyClient(OLE_NOTIFICATION wNotification, DWORD dwParam);
    LPDATAOBJECT GetDataObject();
    LPOLEOBJECT GetOleObject();
    LPMONIKER GetMoniker(OLEGETMONIKER nAssign);

protected:
    virtual BOOL GetMetafileData(LPFORMATETC lpFormatEtc, LPSTGMEDIUM pmedium);
        // calls OnDraw or OnDrawEx
    virtual void OnSaveEmbedding(LPSTORAGE lpStorage);
    virtual BOOL IsBlank() const;

    // CItemDataSource implements OnRender reflections to COleServerItem
    class CItemDataSource : public COleDataSource
    {
    protected:
        // the GetData and SetData interfaces forward to m_pItem
        virtual BOOL OnRenderGlobalData(LPFORMATETC lpFormatEtc, HGLOBAL* phGlobal);
        virtual BOOL OnRenderFileData(LPFORMATETC lpFormatEtc, CFile* pFile);
        virtual BOOL OnRenderData(LPFORMATETC lpFormatEtc, LPSTGMEDIUM lpStgMedium);
            // HGLOBAL version will be called first, then CFile* version

        virtual BOOL OnSetData(LPFORMATETC lpFormatEtc, LPSTGMEDIUM lpStgMedium,
            BOOL bRelease);
    };
    CItemDataSource m_dataSource;
        // data source used to implement IDataObject

// Interface Maps
//  (Note: these interface maps are used just for link implementation)
public:
    BEGIN_INTERFACE_PART(OleObject, IOleObject)
        INIT_INTERFACE_PART(COleServerItem, OleObject)
        STDMETHOD(SetClientSite)(LPOLECLIENTSITE);
        STDMETHOD(GetClientSite)(LPOLECLIENTSITE*);
        STDMETHOD(SetHostNames)(LPCOLESTR, LPCOLESTR);
        STDMETHOD(Close)(DWORD);
        STDMETHOD(SetMoniker)(DWORD, LPMONIKER);
        STDMETHOD(GetMoniker)(DWORD, DWORD, LPMONIKER*);
        STDMETHOD(InitFromData)(LPDATAOBJECT, BOOL, DWORD);
        STDMETHOD(GetClipboardData)(DWORD, LPDATAOBJECT*);
        STDMETHOD(DoVerb)(LONG, LPMSG, LPOLECLIENTSITE, LONG, HWND, LPCRECT);
        STDMETHOD(EnumVerbs)(LPENUMOLEVERB*);
        STDMETHOD(Update)();
        STDMETHOD(IsUpToDate)();
        STDMETHOD(GetUserClassID)(LPCLSID);
        STDMETHOD(GetUserType)(DWORD, LPOLESTR*);
        STDMETHOD(SetExtent)(DWORD, LPSIZEL);
        STDMETHOD(GetExtent)(DWORD, LPSIZEL);
        STDMETHOD(Advise)(LPADVISESINK, LPDWORD);
        STDMETHOD(Unadvise)(DWORD);
        STDMETHOD(EnumAdvise)(LPENUMSTATDATA*);
        STDMETHOD(GetMiscStatus)(DWORD, LPDWORD);
        STDMETHOD(SetColorScheme)(LPLOGPALETTE);
    END_INTERFACE_PART(OleObject)

    BEGIN_INTERFACE_PART(DataObject, IDataObject)
        INIT_INTERFACE_PART(COleServerItem, DataObject)
        STDMETHOD(GetData)(LPFORMATETC, LPSTGMEDIUM);
        STDMETHOD(GetDataHere)(LPFORMATETC, LPSTGMEDIUM);
        STDMETHOD(QueryGetData)(LPFORMATETC);
        STDMETHOD(GetCanonicalFormatEtc)(LPFORMATETC, LPFORMATETC);
        STDMETHOD(SetData)(LPFORMATETC, LPSTGMEDIUM, BOOL);
        STDMETHOD(EnumFormatEtc)(DWORD, LPENUMFORMATETC*);
        STDMETHOD(DAdvise)(LPFORMATETC, DWORD, LPADVISESINK, LPDWORD);
        STDMETHOD(DUnadvise)(DWORD);
        STDMETHOD(EnumDAdvise)(LPENUMSTATDATA*);
    END_INTERFACE_PART(DataObject)

    DECLARE_INTERFACE_MAP()

    friend class CItemDataSource;
    friend class COleServerDoc;
    friend class COleLinkingDoc;
};

/////////////////////////////////////////////////////////////////////////////
// COleLinkingDoc -
//  (enables linking to embeddings - beginnings of server fuctionality)

class COleLinkingDoc : public COleDocument
{
    DECLARE_DYNAMIC(COleLinkingDoc)

// Constructors
public:
    COleLinkingDoc();

// Operations
    BOOL Register(COleObjectFactory* pFactory, LPCTSTR lpszPathName);
        // notify the running object table and connect to pServer
    void Revoke();
        // revoke from running object table

// Overridables
protected:
    virtual COleServerItem* OnGetLinkedItem(LPCTSTR lpszItemName);
        // return item for the named linked item (for supporting links)
    virtual COleClientItem* OnFindEmbeddedItem(LPCTSTR lpszItemName);
        // return item for the named embedded item (for links to embeddings)

// Implementation
public:
    COleObjectFactory* m_pFactory;  // back-pointer to server

#ifdef _DEBUG
    virtual void AssertValid() const;
    virtual void Dump(CDumpContext& dc) const;
#endif
    virtual ~COleLinkingDoc();

    // overrides for updating of monikers & running object table registration
    virtual BOOL OnNewDocument();
    virtual BOOL OnOpenDocument(LPCTSTR lpszPathName);
    virtual BOOL OnSaveDocument(LPCTSTR lpszPathName);
    virtual void OnCloseDocument();
    virtual LPOLEITEMCONTAINER GetContainer();
    virtual LPMONIKER GetMoniker(OLEGETMONIKER nAssign);

    // special handling of error messages during save/load
    virtual void ReportSaveLoadException(LPCTSTR lpszPathName,
        CException* e, BOOL bSaving, UINT nIDPDefault);
    void BeginDeferErrors();
    SCODE EndDeferErrors(SCODE sc);

protected:
    BOOL m_bDeferErrors;    // TRUE if in non-interactive OLE mode
    CException* m_pLastException;

    DWORD m_dwRegister;     // file moniker's registration in the ROT
    LPMONIKER m_lpMonikerROT; // file moniker that is registered
    CString m_strMoniker;   // filename used to create moniker
    BOOL m_bVisibleLock;    // TRUE if user is holding lock on document

    // implementation helpers
    virtual BOOL RegisterIfServerAttached(LPCTSTR lpszPathName, BOOL bMessage);
    void LockExternal(BOOL bLock, BOOL bRemoveRefs);
    void UpdateVisibleLock(BOOL bVisible, BOOL bRemoveRefs);
    virtual void OnShowViews(BOOL bVisible);

    virtual void SaveToStorage(CObject* pObject = NULL);

// Interface Maps
public:
    BEGIN_INTERFACE_PART(PersistFile, IPersistFile)
        INIT_INTERFACE_PART(COleLinkingDoc, PersistFile)
        STDMETHOD(GetClassID)(LPCLSID);
        STDMETHOD(IsDirty)();
        STDMETHOD(Load)(LPCOLESTR, DWORD);
        STDMETHOD(Save)(LPCOLESTR, BOOL);
        STDMETHOD(SaveCompleted)(LPCOLESTR);
        STDMETHOD(GetCurFile)(LPOLESTR*);
    END_INTERFACE_PART(PersistFile)

    BEGIN_INTERFACE_PART(OleItemContainer, IOleItemContainer)
        INIT_INTERFACE_PART(COleLinkingDoc, OleItemContainer)
        STDMETHOD(ParseDisplayName)(LPBC, LPOLESTR, ULONG*, LPMONIKER*);
        STDMETHOD(EnumObjects)(DWORD, LPENUMUNKNOWN*);
        STDMETHOD(LockContainer)(BOOL);
        STDMETHOD(GetObject)(LPOLESTR, DWORD, LPBINDCTX, REFIID, LPVOID*);
        STDMETHOD(GetObjectStorage)(LPOLESTR, LPBINDCTX, REFIID, LPVOID*);
        STDMETHOD(IsRunning)(LPOLESTR);
    END_INTERFACE_PART(OleItemContainer)

    DECLARE_INTERFACE_MAP()

    friend class COleClientItem;
    friend class COleClientItem::XOleClientSite;
    friend class COleServerItem::XOleObject;
};

//////////////////////////////////////////////////////////////////////////////
// COleServerDoc - registered server document containing COleServerItems

#ifdef _AFXDLL
class COleServerDoc : public COleLinkingDoc
#else
class AFX_NOVTABLE COleServerDoc : public COleLinkingDoc
#endif
{
    DECLARE_DYNAMIC(COleServerDoc)

// Constructors and Destructors
public:
    COleServerDoc();

// Attributes
    BOOL IsEmbedded() const;    // TRUE if document is an embedding
    BOOL IsDocObject() const;   // TRUE if document is a DocObject
    COleServerItem* GetEmbeddedItem();
        // return embedded item for document (will allocate if necessary)

    // attributes specific to in-place activation
    BOOL IsInPlaceActive() const;
    void GetItemPosition(LPRECT lpPosRect) const;
        // get current position rectangle of in-place edit
    void GetItemClipRect(LPRECT lpClipRect) const;
        // get current clipping rectangle of in-place edit
    BOOL GetZoomFactor(LPSIZE lpSizeNum = NULL, LPSIZE lpSizeDenom = NULL,
        LPCRECT lpPosRect = NULL) const;
        // returns the zoom factor in pixels

// Operations
    void NotifyChanged();
        // call this after you change some global attribute like
        //  document dimensions
    void UpdateAllItems(COleServerItem* pSender,
        LPARAM lHint = 0L, CObject* pHint = NULL,
        DVASPECT nDrawAspect = DVASPECT_CONTENT);

    // changes to the entire document (automatically notifies clients)
    void NotifyRename(LPCTSTR lpszNewName);
    void NotifySaved();
    void NotifyClosed();        // call this after you close document

    // specific operations for embedded documents
    void SaveEmbedding();       // call this to save embedded (before closing)

    // specific to in-place activation
    BOOL ActivateInPlace();
    void ActivateDocObject();
    void RequestPositionChange(LPCRECT lpPosRect);
    BOOL ScrollContainerBy(CSize sizeScroll);
    BOOL DeactivateAndUndo();
    BOOL DiscardUndoState();

public:
// Overridables for standard user interface (full server)
    virtual BOOL OnUpdateDocument(); // implementation of embedded update

protected:
// Overridables you must implement for yourself
    virtual COleServerItem* OnGetEmbeddedItem() = 0;
        // return item representing entire (embedded) document

// Overridables you do not have to implement
    virtual void OnClose(OLECLOSE dwCloseOption);
    virtual void OnSetHostNames(LPCTSTR lpszHost, LPCTSTR lpszHostObj);
    virtual HRESULT OnExecOleCmd(const GUID* pguidCmdGroup, DWORD nCmdID,
        DWORD nCmdExecOpt, VARIANTARG* pvarargIn, VARIANTARG* pvarargOut);
    virtual CDocObjectServer* GetDocObjectServer(LPOLEDOCUMENTSITE pDocSite);

// Advanced overridables
    LPUNKNOWN GetInterfaceHook(const void* piid);
    virtual void OnShowDocument(BOOL bShow);
        // show first frame for document or hide all frames for document

// Advanced overridables for in-place activation
public:
    virtual void OnDeactivate();
    virtual void OnDeactivateUI(BOOL bUndoable);

protected:
    virtual void OnSetItemRects(LPCRECT lpPosRect, LPCRECT lpClipRect);
    virtual BOOL OnReactivateAndUndo();

    virtual void OnFrameWindowActivate(BOOL bActivate);
    virtual void OnDocWindowActivate(BOOL bActivate);
    virtual void OnShowControlBars(CFrameWnd* pFrameWnd, BOOL bShow);
    virtual COleIPFrameWnd* CreateInPlaceFrame(CWnd* pParentWnd);
    virtual void DestroyInPlaceFrame(COleIPFrameWnd* pFrameWnd);
public:
    virtual void OnResizeBorder(LPCRECT lpRectBorder,
        LPOLEINPLACEUIWINDOW lpUIWindow, BOOL bFrame);

// Implementation
protected:
    LPOLECLIENTSITE m_lpClientSite;     // for embedded item
    CString m_strHostObj;               // name of document in container
    BOOL m_bCntrVisible;                // TRUE if OnShowWindow(TRUE) called
    BOOL m_bClosing;                    // TRUE if shutting down
    COleServerItem* m_pEmbeddedItem;    // pointer to embedded item for document

    COleIPFrameWnd* m_pInPlaceFrame;    // not NULL if in-place activated
    CWnd* m_pOrigParent;                // not NULL if existing view used
    DWORD m_dwOrigStyle;                // original style of in-place view
    DWORD m_dwOrigStyleEx;              // original extended style

    CDocObjectServer* m_pDocObjectServer;  // if DocObject, ptr to doc site

public:
    virtual ~COleServerDoc();
#ifdef _DEBUG
    virtual void AssertValid() const;
    virtual void Dump(CDumpContext& dc) const;
#endif

    // overridables for implementation
    virtual BOOL OnSaveDocument(LPCTSTR lpszPathName);
    virtual void OnCloseDocument();
    virtual void DeleteContents(); // delete auto-delete server items
    virtual LPMONIKER GetMoniker(OLEGETMONIKER nAssign);
    virtual COleServerItem* OnGetLinkedItem(LPCTSTR lpszItemName);
        // return item for the named linked item (only if supporting links)
    virtual BOOL CanCloseFrame(CFrameWnd* pFrame);

protected:
    // overrides to handle server user-interface
    virtual BOOL SaveModified();        // return TRUE if ok to continue
    virtual HMENU GetDefaultMenu();     // return menu based on doc type
    virtual HACCEL GetDefaultAccelerator(); // return accel table based on doc type
    virtual BOOL GetFileTypeString(CString& rString);

    // IPersistStorage implementation
    virtual void OnNewEmbedding(LPSTORAGE lpStorage);
    virtual void OnOpenEmbedding(LPSTORAGE lpStorage);
    virtual void OnSaveEmbedding(LPSTORAGE lpStorage);

    // Implementation helpers
    void NotifyAllItems(OLE_NOTIFICATION wNotification, DWORD dwParam);
    BOOL SaveModifiedPrompt();
    void ConnectView(CWnd* pParentWnd, CView* pView);
    void UpdateUsingHostObj(UINT nIDS, CCmdUI* pCmdUI);

// Message Maps
    //{{AFX_MSG(COleServerDoc)
    afx_msg void OnFileUpdate();
    afx_msg void OnFileSaveCopyAs();
    afx_msg void OnUpdateFileUpdate(CCmdUI* pCmdUI);
    afx_msg void OnUpdateFileExit(CCmdUI* pCmdUI);
    //}}AFX_MSG
    DECLARE_MESSAGE_MAP()

// Interface Maps
public:
    BEGIN_INTERFACE_PART(PersistStorage, IPersistStorage)
        INIT_INTERFACE_PART(COleServerDoc, PersistStorage)
        STDMETHOD(GetClassID)(LPCLSID);
        STDMETHOD(IsDirty)();
        STDMETHOD(InitNew)(LPSTORAGE);
        STDMETHOD(Load)(LPSTORAGE);
        STDMETHOD(Save)(LPSTORAGE, BOOL);
        STDMETHOD(SaveCompleted)(LPSTORAGE);
        STDMETHOD(HandsOffStorage)();
    END_INTERFACE_PART(PersistStorage)

    BEGIN_INTERFACE_PART(OleObject, IOleObject)
        INIT_INTERFACE_PART(COleServerDoc, OleObject)
        STDMETHOD(SetClientSite)(LPOLECLIENTSITE);
        STDMETHOD(GetClientSite)(LPOLECLIENTSITE*);
        STDMETHOD(SetHostNames)(LPCOLESTR, LPCOLESTR);
        STDMETHOD(Close)(DWORD);
        STDMETHOD(SetMoniker)(DWORD, LPMONIKER);
        STDMETHOD(GetMoniker)(DWORD, DWORD, LPMONIKER*);
        STDMETHOD(InitFromData)(LPDATAOBJECT, BOOL, DWORD);
        STDMETHOD(GetClipboardData)(DWORD, LPDATAOBJECT*);
        STDMETHOD(DoVerb)(LONG, LPMSG, LPOLECLIENTSITE, LONG, HWND, LPCRECT);
        STDMETHOD(EnumVerbs)(IEnumOLEVERB**);
        STDMETHOD(Update)();
        STDMETHOD(IsUpToDate)();
        STDMETHOD(GetUserClassID)(CLSID*);
        STDMETHOD(GetUserType)(DWORD, LPOLESTR*);
        STDMETHOD(SetExtent)(DWORD, LPSIZEL);
        STDMETHOD(GetExtent)(DWORD, LPSIZEL);
        STDMETHOD(Advise)(LPADVISESINK, LPDWORD);
        STDMETHOD(Unadvise)(DWORD);
        STDMETHOD(EnumAdvise)(LPENUMSTATDATA*);
        STDMETHOD(GetMiscStatus)(DWORD, LPDWORD);
        STDMETHOD(SetColorScheme)(LPLOGPALETTE);
    END_INTERFACE_PART(OleObject)

    BEGIN_INTERFACE_PART(DataObject, IDataObject)
        INIT_INTERFACE_PART(COleServerDoc, DataObject)
        STDMETHOD(GetData)(LPFORMATETC, LPSTGMEDIUM);
        STDMETHOD(GetDataHere)(LPFORMATETC, LPSTGMEDIUM);
        STDMETHOD(QueryGetData)(LPFORMATETC);
        STDMETHOD(GetCanonicalFormatEtc)(LPFORMATETC, LPFORMATETC);
        STDMETHOD(SetData)(LPFORMATETC, LPSTGMEDIUM, BOOL);
        STDMETHOD(EnumFormatEtc)(DWORD, LPENUMFORMATETC*);
        STDMETHOD(DAdvise)(LPFORMATETC, DWORD, LPADVISESINK, LPDWORD);
        STDMETHOD(DUnadvise)(DWORD);
        STDMETHOD(EnumDAdvise)(LPENUMSTATDATA*);
    END_INTERFACE_PART(DataObject)

    BEGIN_INTERFACE_PART(OleInPlaceObject, IOleInPlaceObject)
        INIT_INTERFACE_PART(COleServerDoc, OleInPlaceObject)
        STDMETHOD(GetWindow)(HWND*);
        STDMETHOD(ContextSensitiveHelp)(BOOL);
        STDMETHOD(InPlaceDeactivate)();
        STDMETHOD(UIDeactivate)();
        STDMETHOD(SetObjectRects)(LPCRECT, LPCRECT);
        STDMETHOD(ReactivateAndUndo)();
    END_INTERFACE_PART(OleInPlaceObject)

    BEGIN_INTERFACE_PART(OleInPlaceActiveObject, IOleInPlaceActiveObject)
        INIT_INTERFACE_PART(COleServerDoc, OleInPlaceActiveObject)
        STDMETHOD(GetWindow)(HWND*);
        STDMETHOD(ContextSensitiveHelp)(BOOL);
        STDMETHOD(TranslateAccelerator)(LPMSG);
        STDMETHOD(OnFrameWindowActivate)(BOOL);
        STDMETHOD(OnDocWindowActivate)(BOOL);
        STDMETHOD(ResizeBorder)(LPCRECT, LPOLEINPLACEUIWINDOW, BOOL);
        STDMETHOD(EnableModeless)(BOOL);
    END_INTERFACE_PART(OleInPlaceActiveObject)

    DECLARE_INTERFACE_MAP()

    friend class COleServer;
    friend class COleServerItem;
    friend class CDocObjectServer;
};

//////////////////////////////////////////////////////////////////////////////
// COleIPFrameWnd

class COleCntrFrameWnd;

class COleIPFrameWnd : public CFrameWnd
{
    DECLARE_DYNCREATE(COleIPFrameWnd)

// Constructors
public:
    COleIPFrameWnd();

// Overridables
public:
    virtual BOOL OnCreateControlBars(CWnd* pWndFrame, CWnd* pWndDoc);
        // create control bars on container windows (pWndDoc can be NULL)
    virtual BOOL OnCreateControlBars(CFrameWnd* pWndFrame, CFrameWnd* pWndDoc);
        // create control bars on container windows (pWndDoc can be NULL)

    virtual void RepositionFrame(LPCRECT lpPosRect, LPCRECT lpClipRect);
        // Advanced: reposition frame to wrap around new lpPosRect

// Implementation
public:
    BOOL m_bUIActive;   // TRUE if currently in uiacitve state

    virtual BOOL LoadFrame(UINT nIDResource,
        DWORD dwDefaultStyle = WS_CHILD|WS_BORDER|WS_CLIPSIBLINGS,
        CWnd* pParentWnd = NULL,
        CCreateContext* pContext = NULL);
    virtual void RecalcLayout(BOOL bNotify = TRUE);
    virtual BOOL PreTranslateMessage(MSG* pMsg);
    virtual LRESULT OnSetMessageString(WPARAM wParam, LPARAM lParam);
    virtual ~COleIPFrameWnd();
#ifdef _DEBUG
    virtual void AssertValid() const;
    virtual void Dump(CDumpContext& dc) const;
#endif

protected:
    // in-place state
    OLEINPLACEFRAMEINFO m_frameInfo;
    LPOLEINPLACEFRAME m_lpFrame;
    LPOLEINPLACEUIWINDOW m_lpDocFrame;
    COleCntrFrameWnd* m_pMainFrame;
    COleCntrFrameWnd* m_pDocFrame;

    HMENU m_hSharedMenu;
    OLEMENUGROUPWIDTHS m_menuWidths;
    HOLEMENU m_hOleMenu;
    CRect m_rectPos;            // client area rect of the item
    CRect m_rectClip;           // area to which frame should be clipped
    BOOL m_bInsideRecalc;

    HMENU _m_Reserved;

    // Advanced: in-place activation virtual implementation
    virtual BOOL BuildSharedMenu();
    virtual void DestroySharedMenu();
    virtual HMENU GetInPlaceMenu();

    // Advanced: possible override to change in-place sizing behavior
    virtual void OnRequestPositionChange(LPCRECT lpRect);

protected:
    //{{AFX_MSG(COleIPFrameWnd)
    afx_msg void OnSize(UINT nType, int cx, int cy);
    afx_msg LRESULT OnRecalcParent(WPARAM wParam, LPARAM lParam);
    afx_msg void OnIdleUpdateCmdUI();
    afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct);
    afx_msg void OnDestroy();
    afx_msg LRESULT OnResizeChild(WPARAM wParam, LPARAM lParam);
    afx_msg void OnContextHelp();
    afx_msg void OnUpdateControlBarMenu(CCmdUI* pCmdUI);
    afx_msg BOOL OnBarCheck(UINT nID);
    afx_msg void OnWindowPosChanging(LPWINDOWPOS lpWndPos);
    //}}AFX_MSG
    DECLARE_MESSAGE_MAP()

    friend class COleServerDoc;
    friend class COleCntrFrameWnd;
    friend class CDocObjectServer;
};

/////////////////////////////////////////////////////////////////////////////
// COleResizeBar - supports in-place resizing in server applications

class COleResizeBar : public CControlBar
{
    DECLARE_DYNAMIC(COleResizeBar)

// Constructors
public:
    COleResizeBar();
    BOOL Create(CWnd* pParentWnd, DWORD dwStyle = WS_CHILD | WS_VISIBLE,
        UINT nID = AFX_IDW_RESIZE_BAR);

// Implementation
public:
    virtual ~COleResizeBar();
    virtual void OnUpdateCmdUI(CFrameWnd* pTarget, BOOL bDisableIfNoHndler);

protected:
    CRectTracker m_tracker;     // implemented with a tracker

protected:
    //{{AFX_MSG(COleResizeBar)
    afx_msg BOOL OnEraseBkgnd(CDC* pDC);
    afx_msg void OnPaint();
    afx_msg void OnSize(UINT nType, int cx, int cy);
    afx_msg BOOL OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message);
    afx_msg void OnLButtonDown(UINT, CPoint point);
    afx_msg LRESULT OnSizeParent(WPARAM wParam, LPARAM lParam);
    //}}AFX_MSG
    DECLARE_MESSAGE_MAP()
};

/////////////////////////////////////////////////////////////////////////////
// COleStreamFile - implementation of CFile which uses an IStream

class COleStreamFile : public CFile
{
    DECLARE_DYNAMIC(COleStreamFile)

// Constructors and Destructors
public:
    COleStreamFile(LPSTREAM lpStream = NULL);

// Operations
    // Note: OpenStream and CreateStream can accept eith STGM_ flags or
    //  CFile::OpenFlags bits since common values are guaranteed to have
    //  the same semantics.
    BOOL OpenStream(LPSTORAGE lpStorage, LPCTSTR lpszStreamName,
        DWORD nOpenFlags = modeReadWrite|shareExclusive,
        CFileException* pError = NULL);
    BOOL CreateStream(LPSTORAGE lpStorage, LPCTSTR lpszStreamName,
        DWORD nOpenFlags = modeReadWrite|shareExclusive|modeCreate,
        CFileException* pError = NULL);

    BOOL CreateMemoryStream(CFileException* pError = NULL);

    // attach & detach can be used when Open/Create functions aren't adequate
    void Attach(LPSTREAM lpStream);
    LPSTREAM Detach();

    IStream* GetStream() const;
    // Returns the current stream

// Implementation
public:
    LPSTREAM m_lpStream;
#ifdef _DEBUG
    virtual void AssertValid() const;
    virtual void Dump(CDumpContext& dc) const;
#endif
    virtual ~COleStreamFile();

    // attributes for implementation
    BOOL GetStatus(CFileStatus& rStatus) const;
    virtual DWORD GetPosition() const;

    virtual const CString GetStorageName() const;

    // overrides for implementation
    virtual CFile* Duplicate() const;
    virtual LONG Seek(LONG lOff, UINT nFrom);
    virtual void SetLength(DWORD dwNewLen);
    virtual DWORD GetLength() const;
    virtual UINT Read(void* lpBuf, UINT nCount);
    virtual void Write(const void* lpBuf, UINT nCount);
    virtual void LockRange(DWORD dwPos, DWORD dwCount);
    virtual void UnlockRange(DWORD dwPos, DWORD dwCount);
    virtual void Abort();
    virtual void Flush();
    virtual void Close();

protected:
    CString m_strStorageName;
};

/////////////////////////////////////////////////////////////////////////////
// CMonikerFile - implementation of COleStreamFile that uses an IMoniker to
//                get the IStream

class CMonikerFile: public COleStreamFile
{
    DECLARE_DYNAMIC(CMonikerFile)

public:
    CMonikerFile();

    virtual BOOL Open(LPCTSTR lpszURL, CFileException* pError=NULL);
    // Uses synchronous URLMonikers to create a moniker.
    // Opens the URL specified.
    // If provided, pError will be set in case of error.
    // Return value: TRUE if successful, FALSE otherwise.

    virtual BOOL Open(IMoniker* pMoniker, CFileException* pError=NULL);
    // Binds to the provided moniker to obtain a stream.
    // If provided, pError will be set in case of error.
    // Return value: TRUE if successful, FALSE otherwise.

    virtual void Close();
    // Detaches the stream, Release()s it, and the moniker.  Close may be
    // called on unopened, or already closed streams.

    BOOL Detach(CFileException* pError = NULL);
    // Closes the stream.  If there is an error when closing, then the
    // error code will be placed in pError and the function will return FALSE.

    IMoniker* GetMoniker() const;
    // Returns the current moniker.  The moniker returned is not AddRef()'ed.

protected:
// Overidables
    IBindCtx* CreateBindContext(CFileException* pError);
    // A hook so users can provide a particular IBindCtx, potentially one
    // on which the user has registered one or more objects.

// Implementation
protected:
    virtual BOOL Open(LPCTSTR lpszUrl, IBindHost* pBindHost,
        IBindStatusCallback* pBSC, IBindCtx* pBindCtx, CFileException* pError);
    BOOL Attach(LPCTSTR lpszUrl, IBindHost* pBindHost,
        IBindStatusCallback* pBSC, IBindCtx* pBindCtx, CFileException* pError);
    virtual BOOL Open(IMoniker* pMoniker, IBindHost* pBindHost,
        IBindStatusCallback* pBSC, IBindCtx* pBindCtx, CFileException* pError);

    BOOL Attach(IMoniker* pMoniker, IBindHost* pBindHost,
        IBindStatusCallback* pBSC, IBindCtx* pBindCtx, CFileException* pError);

    virtual BOOL PostBindToStream(CFileException* pError);

    static IBindHost* CreateBindHost();
public:
    virtual ~CMonikerFile();
    // Closes the stream, and releases the moniker if needed.

    virtual void Flush();

#ifdef _DEBUG
    virtual void AssertValid() const;
    virtual void Dump(CDumpContext& dc) const;
    // Calls COleStreamFile::Dump(), and prints out moniker value.
#endif

protected:
    IPTR(IMoniker) m_Moniker;
    // The moniker provided or created to which this class is bound.

    CMonikerFile(const CMonikerFile&);
    // Prevents copying.
};

/////////////////////////////////////////////////////////////////////////////
// CAsyncMonikerFile - implementation of COleStreamFile that uses an
//                     asynchronous IMoniker to get the IStream

class _AfxBindStatusCallback; // Forward declaration

class CAsyncMonikerFile: public CMonikerFile
{
    DECLARE_DYNAMIC(CAsyncMonikerFile)

public:
    CAsyncMonikerFile();
    // Creates the IBindStatusCallback used internally to provide asynchronous
    // operation.

    //All Open overloads call one of these two.
    virtual BOOL Open(LPCTSTR lpszURL, IBindHost* pBindHost,
        CFileException* pError=NULL);
    virtual BOOL Open(IMoniker* pMoniker, IBindHost* pBindHost,
        CFileException* pError=NULL);

    //Open overloads that take monikers
    virtual BOOL Open(IMoniker* pMoniker, CFileException* pError=NULL);
    virtual BOOL Open(IMoniker* pMoniker, IServiceProvider* pServiceProvider,
        CFileException* pError=NULL);
    virtual BOOL Open(IMoniker* pMoniker, IUnknown* pUnknown,
        CFileException* pError=NULL);

    //Open overloads that take strings
    virtual BOOL Open(LPCTSTR lpszURL, CFileException* pError=NULL);
    virtual BOOL Open(LPCTSTR lpszURL, IServiceProvider* pServiceProvider,
        CFileException* pError=NULL);
    virtual BOOL Open(LPCTSTR lpszURL, IUnknown* pUnknown,
        CFileException* pError=NULL);

    virtual void Close();

    IBinding* GetBinding() const;
    // Returns the binding provided when the asychronous transfer begins.
    // With the IBinding*, the user may abort, or pause the transfer.
    // NULL may be returned if for any reason the transfer could not be
    // made asynchronous, or if the IBinding* has not yet been provided by
    // the system.

    FORMATETC* GetFormatEtc() const;
    // Returns the FORMATETC for the currently opened stream.  NULL will be
    // returned if this is called from outside the context of OnDataAvailable.
    // If you want to keep the FORMATETC beyond this call, make a copy of it.
    // The FORMATETC indicates the format of the data in the stream.

protected:
// Overidables
    virtual IUnknown* CreateBindStatusCallback(IUnknown* pUnkControlling);

    virtual DWORD GetBindInfo() const;
    // Returns the settings returned by IBindStatusCallback::GetBindInfo.
    // The default values returned should work for most cases and should not
    // be changed lightly.

    virtual LONG GetPriority() const;
    // Returns the priority at which the asynchronous transfer will take
    // place.  The value is one of the standard thread priority flags.
    // By default THREAD_PRIORITY_NORMAL is returned.

    virtual void OnDataAvailable(DWORD dwSize, DWORD bscfFlag);
    // Called when there is data available to be read.  dwSize indicates
    // the cumulative number of bytes which can be read.  The bscfFlag may be used
    // to identify first, last, and intermediate blocks of data.

    virtual void OnLowResource();
    // This is called when resources are low.

    virtual void OnStartBinding();
    // Called when the binding is starting up.

    virtual void OnProgress(ULONG ulProgress, ULONG ulProgressMax,
        ULONG ulStatusCode, LPCTSTR szStatusText);

    virtual void OnStopBinding(HRESULT hresult, LPCTSTR szError);
    // Called when the transfer is stopped.  This function releases the
    // IBinding and should nearly always be call when overidden.

// Implementation
public:
    virtual ~CAsyncMonikerFile();
#ifdef _DEBUG
    virtual void AssertValid() const;
    virtual void Dump(CDumpContext& dc) const;
    // Calls CMonikerFile::Dump(), and prints out IBinding,
    // IBindStatusCallback, and m_pFormatEtc values.
#endif
    virtual UINT Read(void* lpBuf, UINT nCount);

protected:
    friend class _AfxBindStatusCallback;
    _AfxBindStatusCallback* m_pAfxBSCCurrent;
    BOOL m_bStopBindingReceived;
    void EndCallbacks();

    IPTR(IBinding) m_Binding;
    FORMATETC* m_pFormatEtc;

    void SetBinding(IBinding* pBinding);
    // Sets and AddRefs m_Binding

    void SetFormatEtc(FORMATETC* pFormatEtc);
    // Sets the FORMATETC for the current stream.

    virtual BOOL PostBindToStream(CFileException* pError);
};

/////////////////////////////////////////////////////////////////////////////
// COleDropSource (advanced drop source support)

class COleDropSource : public CCmdTarget
{
// Constructors
public:
    COleDropSource();

// Overridables
    virtual SCODE QueryContinueDrag(BOOL bEscapePressed, DWORD dwKeyState);
    virtual SCODE GiveFeedback(DROPEFFECT dropEffect);
    virtual BOOL OnBeginDrag(CWnd* pWnd);

// Implementation
public:
#ifdef _DEBUG
    virtual void Dump(CDumpContext& dc) const;
#endif

public:
    BEGIN_INTERFACE_PART(DropSource, IDropSource)
        INIT_INTERFACE_PART(COleDropSource, DropSource)
        STDMETHOD(QueryContinueDrag)(BOOL, DWORD);
        STDMETHOD(GiveFeedback)(DWORD);
    END_INTERFACE_PART(DropSource)

    DECLARE_INTERFACE_MAP()

    CRect m_rectStartDrag;  // when mouse leaves this rect, drag drop starts
    BOOL m_bDragStarted;    // has drag really started yet?
    DWORD m_dwButtonCancel; // which button will cancel (going down)
    DWORD m_dwButtonDrop;   // which button will confirm (going up)

    // metrics for drag start determination
    static AFX_DATA UINT nDragMinDist;  // min. amount mouse must move for drag
    static AFX_DATA UINT nDragDelay;    // delay before drag starts

    friend class COleDataSource;
};

/////////////////////////////////////////////////////////////////////////////
// COleDropTarget (advanced drop target support)

class COleDropTarget : public CCmdTarget
{
// Constructors
public:
    COleDropTarget();

// Operations
    BOOL Register(CWnd* pWnd);
    virtual void Revoke();  // virtual for implementation

// Overridables
    virtual DROPEFFECT OnDragEnter(CWnd* pWnd, COleDataObject* pDataObject,
        DWORD dwKeyState, CPoint point);
    virtual DROPEFFECT OnDragOver(CWnd* pWnd, COleDataObject* pDataObject,
        DWORD dwKeyState, CPoint point);
    virtual BOOL OnDrop(CWnd* pWnd, COleDataObject* pDataObject,
        DROPEFFECT dropEffect, CPoint point);
    virtual DROPEFFECT OnDropEx(CWnd* pWnd, COleDataObject* pDataObject,
        DROPEFFECT dropDefault, DROPEFFECT dropList, CPoint point);
    virtual void OnDragLeave(CWnd* pWnd);
    virtual DROPEFFECT OnDragScroll(CWnd* pWnd, DWORD dwKeyState,
        CPoint point);

// Implementation
public:
    virtual ~COleDropTarget();
#ifdef _DEBUG
    virtual void AssertValid() const;
    virtual void Dump(CDumpContext& dc) const;
#endif

protected:
    HWND m_hWnd;            // HWND this IDropTarget is attached to
    LPDATAOBJECT m_lpDataObject;    // != NULL between OnDragEnter, OnDragLeave
    UINT m_nTimerID;        // != MAKEWORD(-1, -1) when in scroll area
    DWORD m_dwLastTick;     // only valid when m_nTimerID valid
    UINT m_nScrollDelay;    // time to next scroll

    // metrics for drag-scrolling
    static AFX_DATA int nScrollInset;
    static AFX_DATA UINT nScrollDelay;
    static AFX_DATA UINT nScrollInterval;

    // implementation helpers
    void SetupTimer(CView* pView, UINT nTimerID);
    void CancelTimer(CWnd* pWnd);

// Interface Maps
public:
    BEGIN_INTERFACE_PART(DropTarget, IDropTarget)
        INIT_INTERFACE_PART(COleDropTarget, DropTarget)
        STDMETHOD(DragEnter)(LPDATAOBJECT, DWORD, POINTL, LPDWORD);
        STDMETHOD(DragOver)(DWORD, POINTL, LPDWORD);
        STDMETHOD(DragLeave)();
        STDMETHOD(Drop)(LPDATAOBJECT, DWORD, POINTL pt, LPDWORD);
    END_INTERFACE_PART(DropTarget)

    DECLARE_INTERFACE_MAP()
};

/////////////////////////////////////////////////////////////////////////////
// COleMessageFilter (implements IMessageFilter)

class COleMessageFilter : public CCmdTarget
{
// Constructors
public:
    COleMessageFilter();

// Operations
    BOOL Register();
    void Revoke();

    // for controlling the busy state of the server application (called app)
    virtual void BeginBusyState();
    virtual void EndBusyState();
    void SetBusyReply(SERVERCALL nBusyReply);

    // for controlling actions taken against rejected/retried calls
    void SetRetryReply(DWORD nRetryReply = 0);
        // only used when the "not responding" dialog is disabled
    void SetMessagePendingDelay(DWORD nTimeout = 5000);
        // used to determine amount of time before significant message
    void EnableBusyDialog(BOOL bEnableBusy = TRUE);
    void EnableNotRespondingDialog(BOOL bEnableNotResponding = TRUE);
        // used to enable/disable the two types of busy dialogs

// Overridables
    virtual BOOL OnMessagePending(const MSG* pMsg);
        // return TRUE to eat the message (usually only if processed)

// Implementation
public:
#ifdef _DEBUG
    virtual void AssertValid() const;
    virtual void Dump(CDumpContext& dc) const;
#endif
    virtual ~COleMessageFilter();
    virtual BOOL IsSignificantMessage(MSG* pMsg);
        // determine if any significant messages are present in the queue
    virtual int OnBusyDialog(HTASK htaskBusy);
    virtual int OnNotRespondingDialog(HTASK htaskBusy);
        // these functions display the busy dialog

protected:
    BOOL m_bRegistered;
    LONG m_nBusyCount;  // for BeginBusyState & EndBusyState
    BOOL m_bEnableBusy;
    BOOL m_bEnableNotResponding;
    BOOL m_bUnblocking;
    DWORD m_nRetryReply;    // only used if m_bEnableNotResponding == FALSE
    DWORD m_nBusyReply;
    DWORD m_nTimeout;

// Interface Maps
public:
    BEGIN_INTERFACE_PART(MessageFilter, IMessageFilter)
        INIT_INTERFACE_PART(COleMessageFilter, MessageFilter)
        STDMETHOD_(DWORD, HandleInComingCall)(DWORD, HTASK, DWORD,
            LPINTERFACEINFO);
        STDMETHOD_(DWORD, RetryRejectedCall)(HTASK, DWORD, DWORD);
        STDMETHOD_(DWORD, MessagePending)(HTASK, DWORD, DWORD);
    END_INTERFACE_PART(MessageFilter)

    DECLARE_INTERFACE_MAP()
};

/////////////////////////////////////////////////////////////////////////////
// message map entries for OLE verbs

#define ON_STDOLEVERB(iVerb, memberFxn) \
    { 0xC002, 0, (UINT)iVerb, (UINT)iVerb, (UINT)-1, \
        (AFX_PMSG)(BOOL (AFX_MSG_CALL CCmdTarget::*)(LPMSG, HWND, LPCRECT))&memberFxn },

#define ON_OLEVERB(idsVerbName, memberFxn) \
    { 0xC002, 0, 1, 1, idsVerbName, \
        (AFX_PMSG)(BOOL (AFX_MSG_CALL CCmdTarget::*)(LPMSG, HWND, LPCRECT))&memberFxn },

/////////////////////////////////////////////////////////////////////////////
// global helpers and debugging

void AFXAPI AfxOleSetEditMenu(COleClientItem* pClient, CMenu* pMenu,
    UINT iMenuItem, UINT nIDVerbMin, UINT nIDVerbMax = 0, UINT nIDConvert = 0);

#ifdef _DEBUG
// Mapping SCODEs to readable text
LPCTSTR AFXAPI AfxGetFullScodeString(SCODE sc);
LPCTSTR AFXAPI AfxGetScodeString(SCODE sc);
LPCTSTR AFXAPI AfxGetScodeRangeString(SCODE sc);
LPCTSTR AFXAPI AfxGetSeverityString(SCODE sc);
LPCTSTR AFXAPI AfxGetFacilityString(SCODE sc);

// Mapping IIDs to readable text
LPCTSTR AFXAPI AfxGetIIDString(REFIID iid);
#endif

/////////////////////////////////////////////////////////////////////////////
// Inline function declarations

#ifdef _AFX_PACKING
#pragma pack(pop)
#endif

#ifdef _AFX_ENABLE_INLINES
#define _AFXOLE_INLINE AFX_INLINE
#define _AFXOLECLI_INLINE AFX_INLINE
#define _AFXOLESVR_INLINE AFX_INLINE
#define _AFXOLEDOBJ_INLINE AFX_INLINE
#define _AFXOLEMONIKER_INLINE AFX_INLINE
#include <afxole.inl>
#undef _AFXOLE_INLINE
#undef _AFXOLECLI_INLINE
#undef _AFXOLESVR_INLINE
#undef _AFXOLEDOBJ_INLINE
#undef _AFXOLEMONIKER_INLINE
#endif

#undef AFX_DATA
#define AFX_DATA

#ifdef _AFX_MINREBUILD
#pragma component(minrebuild, on)
#endif
#ifndef _AFX_FULLTYPEINFO
#pragma component(mintypeinfo, off)
#endif

#endif //__AFXOLE_H__

/////////////////////////////////////////////////////////////////////////////x