home *** CD-ROM | disk | FTP | other *** search
/ Total C++ 2 / TOTALCTWO.iso / borland / mfcinc.pak / AFXOLE.H < prev    next >
C/C++ Source or Header  |  1997-05-06  |  59KB  |  1,667 lines
  1. // This is a part of the Microsoft Foundation Classes C++ library.
  2. // Copyright (C) 1992-1995 Microsoft Corporation
  3. // All rights reserved.
  4. //
  5. // This source code is only intended as a supplement to the
  6. // Microsoft Foundation Classes Reference and related
  7. // electronic documentation provided with the library.
  8. // See these sources for detailed information regarding the
  9. // Microsoft Foundation Classes product.
  10.  
  11. #ifndef __AFXOLE_H__
  12. #define __AFXOLE_H__
  13.  
  14. #ifdef _AFX_NO_OLE_SUPPORT
  15.     #error OLE classes not supported in this library variant.
  16. #endif
  17.  
  18. #ifndef __AFXEXT_H__
  19.     #include <afxext.h>
  20. #endif
  21.  
  22. #ifndef __AFXDISP_H__
  23.     #include <afxdisp.h>
  24. #endif
  25.  
  26. // include OLE Compound Document headers
  27. #ifndef _OLE2_H_
  28.     #include <ole2.h>
  29. #endif
  30.  
  31. #ifdef _AFX_MINREBUILD
  32. #pragma component(minrebuild, off)
  33. #endif
  34. #ifndef _AFX_FULLTYPEINFO
  35. #pragma component(mintypeinfo, on)
  36. #endif
  37.  
  38. #ifdef _AFX_PACKING
  39. #pragma pack(push, _AFX_PACKING)
  40. #endif
  41.  
  42. /////////////////////////////////////////////////////////////////////////////
  43. // AFXOLE.H - MFC OLE support
  44.  
  45. // Classes declared in this file
  46.  
  47. //CDocument
  48.     class COleDocument;             // OLE container document
  49.         class COleLinkingDoc;       // supports links to embeddings
  50.             class COleServerDoc;    // OLE server document
  51.  
  52. //CCmdTarget
  53.     class CDocItem;                 // part of a document
  54.         class COleClientItem;       // embedded ole object from outside
  55.         class COleServerItem;       // ole object to export
  56.     class COleDataSource;           // clipboard data source mechanism
  57.     class COleDropSource;           // drag/drop source
  58.     class COleDropTarget;           // drag/drop target
  59.     class COleMessageFilter;        // concurrency management
  60.  
  61. //CFrameWnd
  62.     class COleIPFrameWnd;           // frame window for in-place servers
  63.  
  64. //CControlBar
  65.     class COleResizeBar;            // implements in-place resizing
  66.  
  67. //CFile
  68.     class COleStreamFile;           // CFile wrapper for IStream interface
  69.  
  70. class COleDataObject;               // wrapper for IDataObject interface
  71.  
  72. /////////////////////////////////////////////////////////////////////////////
  73.  
  74. // AFXDLL support
  75. #undef AFX_DATA
  76. #define AFX_DATA AFX_OLE_DATA
  77.  
  78. /////////////////////////////////////////////////////////////////////////////
  79. // backward compatibility
  80.  
  81. // COleClientDoc is now obsolete -- use COleDocument instead
  82. #define COleClientDoc COleDocument
  83.  
  84. // COleServer has been replaced by the more general COleObjectFactory
  85. #define COleServer  COleObjectFactory
  86.  
  87. /////////////////////////////////////////////////////////////////////////////
  88. // Useful OLE specific types (some from OLE 1.0 headers)
  89.  
  90. // Codes for CallBack events
  91. enum OLE_NOTIFICATION
  92. {
  93.     OLE_CHANGED,        // representation of a draw aspect has changed
  94.     OLE_SAVED,          // the item has committed its storage
  95.     OLE_CLOSED,         // the item has closed
  96.     OLE_RENAMED,        // the item has changed its moniker
  97.     OLE_CHANGED_STATE,  // the item state (open, active, etc.) has changed
  98.     OLE_CHANGED_ASPECT, // the item draw aspect has changed
  99. };
  100.  
  101. // Object types
  102. enum OLE_OBJTYPE
  103. {
  104.     OT_UNKNOWN = 0,
  105.  
  106.     // These are OLE 1.0 types and OLE 2.0 types as returned from GetType().
  107.     OT_LINK = 1,
  108.     OT_EMBEDDED = 2,
  109.     OT_STATIC = 3,
  110.  
  111.     // All OLE2 objects are written with this tag when serialized.  This
  112.     //  differentiates them from OLE 1.0 objects written with MFC 2.0.
  113.     //  This value will never be returned from GetType().
  114.     OT_OLE2 = 256,
  115. };
  116.  
  117. /////////////////////////////////////////////////////////////////////////////
  118. // COleDataObject -- simple wrapper for IDataObject
  119.  
  120. class COleDataObject
  121. {
  122. // Constructors
  123. public:
  124.     COleDataObject();
  125.  
  126. // Operations
  127.     void Attach(LPDATAOBJECT lpDataObject, BOOL bAutoRelease = TRUE);
  128.     LPDATAOBJECT Detach();  // detach and get ownership of m_lpDataObject
  129.     void Release(); // detach and Release ownership of m_lpDataObject
  130.     BOOL AttachClipboard(); // attach to current clipboard object
  131.  
  132. // Attributes
  133.     void BeginEnumFormats();
  134.     BOOL GetNextFormat(LPFORMATETC lpFormatEtc);
  135.     CFile* GetFileData(CLIPFORMAT cfFormat, LPFORMATETC lpFormatEtc = NULL);
  136.     HGLOBAL GetGlobalData(CLIPFORMAT cfFormat, LPFORMATETC lpFormatEtc = NULL);
  137.     BOOL GetData(CLIPFORMAT cfFormat, LPSTGMEDIUM lpStgMedium,
  138.         LPFORMATETC lpFormatEtc = NULL);
  139.     BOOL IsDataAvailable(CLIPFORMAT cfFormat, LPFORMATETC lpFormatEtc = NULL);
  140.  
  141. // Implementation
  142. public:
  143.     LPDATAOBJECT m_lpDataObject;
  144.     LPENUMFORMATETC m_lpEnumerator;
  145.     ~COleDataObject();
  146.  
  147.     // advanced use and implementation
  148.     LPDATAOBJECT GetIDataObject(BOOL bAddRef);
  149.     void EnsureClipboardObject();
  150.     BOOL m_bClipboard;      // TRUE if represents the Win32 clipboard
  151.  
  152. protected:
  153.     BOOL m_bAutoRelease;    // TRUE if destructor should call Release
  154.  
  155. private:
  156.     // Disable the copy constructor and assignment by default so you will get
  157.     //   compiler errors instead of unexpected behaviour if you pass objects
  158.     //   by value or assign objects.
  159.     COleDataObject(const COleDataObject&);  // no implementation
  160.     void operator=(const COleDataObject&);  // no implementation
  161. };
  162.  
  163. /////////////////////////////////////////////////////////////////////////////
  164. // COleDataSource -- wrapper for implementing IDataObject
  165. //  (works similar to how data is provided on the clipboard)
  166.  
  167. struct AFX_DATACACHE_ENTRY;
  168. class COleDropSource;
  169.  
  170. class COleDataSource : public CCmdTarget
  171. {
  172. // Constructors
  173. public:
  174.     COleDataSource();
  175.  
  176. // Operations
  177.     void Empty();   // empty cache (similar to ::EmptyClipboard)
  178.  
  179.     // CacheData & DelayRenderData operations similar to ::SetClipboardData
  180.     void CacheGlobalData(CLIPFORMAT cfFormat, HGLOBAL hGlobal,
  181.         LPFORMATETC lpFormatEtc = NULL);    // for HGLOBAL based data
  182.     void DelayRenderFileData(CLIPFORMAT cfFormat,
  183.         LPFORMATETC lpFormatEtc = NULL);    // for CFile* based delayed render
  184.  
  185.     // Clipboard and Drag/Drop access
  186.     DROPEFFECT DoDragDrop(
  187.         DWORD dwEffects = DROPEFFECT_COPY|DROPEFFECT_MOVE|DROPEFFECT_LINK,
  188.         LPCRECT lpRectStartDrag = NULL,
  189.         COleDropSource* pDropSource = NULL);
  190.     void SetClipboard();
  191.     static void PASCAL FlushClipboard();
  192.     static COleDataSource* PASCAL GetClipboardOwner();
  193.  
  194.     // Advanced: STGMEDIUM based cached data
  195.     void CacheData(CLIPFORMAT cfFormat, LPSTGMEDIUM lpStgMedium,
  196.         LPFORMATETC lpFormatEtc = NULL);    // for LPSTGMEDIUM based data
  197.     // Advanced: STGMEDIUM or HGLOBAL based delayed render
  198.     void DelayRenderData(CLIPFORMAT cfFormat, LPFORMATETC lpFormatEtc = NULL);
  199.  
  200.     // Advanced: support for SetData in COleServerItem
  201.     //  (not generally useful for clipboard or drag/drop operations)
  202.     void DelaySetData(CLIPFORMAT cfFormat, LPFORMATETC lpFormatEtc = NULL);
  203.  
  204. // Overidables
  205.     virtual BOOL OnRenderGlobalData(LPFORMATETC lpFormatEtc, HGLOBAL* phGlobal);
  206.     virtual BOOL OnRenderFileData(LPFORMATETC lpFormatEtc, CFile* pFile);
  207.     virtual BOOL OnRenderData(LPFORMATETC lpFormatEtc, LPSTGMEDIUM lpStgMedium);
  208.         // OnRenderFileData and OnRenderGlobalData are called by
  209.         //  the default implementation of OnRenderData.
  210.  
  211.     virtual BOOL OnSetData(LPFORMATETC lpFormatEtc, LPSTGMEDIUM lpStgMedium,
  212.         BOOL bRelease);
  213.         // used only in COleServerItem implementation
  214.  
  215. // Implementation
  216. public:
  217.     virtual ~COleDataSource();
  218. #ifdef _DEBUG
  219.     virtual void AssertValid() const;
  220.     virtual void Dump(CDumpContext& dc) const;
  221. #endif
  222.  
  223. protected:
  224.     AFX_DATACACHE_ENTRY* m_pDataCache;  // data cache itself
  225.     UINT m_nMaxSize;    // current allocated size
  226.     UINT m_nSize;       // current size of the cache
  227.     UINT m_nGrowBy;     // number of cache elements to grow by for new allocs
  228.  
  229.     AFX_DATACACHE_ENTRY* Lookup(
  230.         LPFORMATETC lpFormatEtc, DATADIR nDataDir) const;
  231.     AFX_DATACACHE_ENTRY* GetCacheEntry(
  232.         LPFORMATETC lpFormatEtc, DATADIR nDataDir);
  233.  
  234. // Interface Maps
  235. public:
  236.     BEGIN_INTERFACE_PART(DataObject, IDataObject)
  237.         INIT_INTERFACE_PART(COleDataSource, DataObject)
  238.         STDMETHOD(GetData)(LPFORMATETC, LPSTGMEDIUM);
  239.         STDMETHOD(GetDataHere)(LPFORMATETC, LPSTGMEDIUM);
  240.         STDMETHOD(QueryGetData)(LPFORMATETC);
  241.         STDMETHOD(GetCanonicalFormatEtc)(LPFORMATETC, LPFORMATETC);
  242.         STDMETHOD(SetData)(LPFORMATETC, LPSTGMEDIUM, BOOL);
  243.         STDMETHOD(EnumFormatEtc)(DWORD, LPENUMFORMATETC*);
  244.         STDMETHOD(DAdvise)(LPFORMATETC, DWORD, LPADVISESINK, LPDWORD);
  245.         STDMETHOD(DUnadvise)(DWORD);
  246.         STDMETHOD(EnumDAdvise)(LPENUMSTATDATA*);
  247.     END_INTERFACE_PART(DataObject)
  248.  
  249.     DECLARE_INTERFACE_MAP()
  250.  
  251.     friend class COleServerItem;
  252. };
  253.  
  254. //////////////////////////////////////////////////////////////////////////////
  255. // DocItem support
  256.  
  257. class CDocItem : public CCmdTarget
  258. {
  259.     DECLARE_SERIAL(CDocItem)
  260.  
  261. // Constructors
  262. protected:      // abstract class
  263.     CDocItem();
  264.  
  265. // Attributes
  266. public:
  267.     CDocument* GetDocument() const; // return container document
  268.  
  269. // Overridables
  270. public:
  271.     // Raw data access (native format)
  272.     virtual BOOL IsBlank() const;
  273.  
  274. // Implementation
  275. protected:
  276.     COleDocument* m_pDocument;
  277.  
  278. public:
  279.     virtual void Serialize(CArchive& ar);   // for Native data
  280.     virtual ~CDocItem();
  281. #ifdef _DEBUG
  282.     virtual void AssertValid() const;
  283.     virtual void Dump(CDumpContext& dc) const;
  284. #endif
  285.  
  286.     friend class COleDocument;              // for access to back pointer
  287. };
  288.  
  289. //////////////////////////////////////////////////////////////////////////////
  290. // COleDocument - common OLE container behavior (enables server functionality)
  291.  
  292. class COleDocument : public CDocument
  293. {
  294.     DECLARE_DYNAMIC(COleDocument)
  295.  
  296. // Constructors
  297. public:
  298.     COleDocument();
  299.  
  300. // Attributes
  301.     BOOL HasBlankItems() const; // check for BLANK items
  302.     virtual COleClientItem* GetInPlaceActiveItem(CWnd* pWnd);
  303.         // return in-place active item for this view or NULL if none
  304.  
  305. // Operations
  306.     // iterating over existing items
  307.     virtual POSITION GetStartPosition() const;
  308.     virtual CDocItem* GetNextItem(POSITION& pos) const;
  309.  
  310.     // iterator helpers (helpers use virtual GetNextItem above)
  311.     COleClientItem* GetNextClientItem(POSITION& pos) const;
  312.     COleServerItem* GetNextServerItem(POSITION& pos) const;
  313.  
  314.     // adding new items - called from item constructors
  315.     virtual void AddItem(CDocItem* pItem);
  316.     virtual void RemoveItem(CDocItem* pItem);
  317.  
  318.     void EnableCompoundFile(BOOL bEnable = TRUE);
  319.         // enable compound file support (only call during constructor)
  320.     virtual void UpdateModifiedFlag();
  321.         // scan for modified items -- mark document modified
  322.  
  323.     // printer-device caching/control
  324.     BOOL ApplyPrintDevice(const DVTARGETDEVICE* ptd);
  325.     BOOL ApplyPrintDevice(const PRINTDLG* ppd);
  326.         // these apply the target device to all COleClientItem objects
  327.  
  328. // Overridables
  329.     virtual COleClientItem* GetPrimarySelectedItem(CView* pView);
  330.         // return primary selected item or NULL if none
  331.     virtual void OnShowViews(BOOL bVisible);
  332.         // called during app-idle when visibility of a document has changed
  333.  
  334. // Implementation
  335. public:
  336.     CObList m_docItemList;  // not owned items
  337.  
  338. #ifdef _DEBUG
  339.     virtual void AssertValid() const;
  340.     virtual void Dump(CDumpContext& dc) const;
  341. #endif
  342.     CFrameWnd* GetFirstFrame();
  343.  
  344.     // document handling overrides
  345.     virtual void SetPathName(LPCTSTR lpszPathName, BOOL bAddToMRU = TRUE);
  346.     virtual ~COleDocument();
  347.     virtual void DeleteContents(); // delete client items in list
  348.     virtual void Serialize(CArchive& ar);   // serialize items to file
  349.     virtual void PreCloseFrame(CFrameWnd* pFrame);
  350.     virtual BOOL SaveModified();
  351.     virtual void OnIdle();
  352.  
  353.     // compound file implementation
  354.     virtual BOOL OnNewDocument();
  355.     virtual BOOL OnOpenDocument(LPCTSTR lpszPathName);
  356.     virtual BOOL OnSaveDocument(LPCTSTR lpszPathName);
  357.     virtual void OnCloseDocument();
  358.     void CommitItems(BOOL bSuccess);    // called during File.Save & File.Save As
  359.  
  360.     // minimal linking protocol
  361.     virtual LPMONIKER GetMoniker(OLEGETMONIKER nAssign);
  362.     virtual LPOLEITEMCONTAINER GetContainer();
  363.  
  364. protected:
  365.     // document state implementation
  366.     UINT m_dwNextItemNumber;// serial number for next item in this document
  367.     BOOL m_bLastVisible;    // TRUE if one or more views was last visible
  368.  
  369.     // 'docfile' support
  370.     BOOL m_bCompoundFile;   // TRUE if use compound files
  371.     LPSTORAGE m_lpRootStg;  // root storage for the document
  372.     BOOL m_bSameAsLoad;     // TRUE = file-save, FALSE = Save [Copy] As
  373.     BOOL m_bRemember;       // if FALSE, indicates Save Copy As
  374.  
  375.     DVTARGETDEVICE* m_ptd;  // current document target device
  376.  
  377.     // implementation helpers
  378.     virtual void LoadFromStorage();
  379.     virtual void SaveToStorage(CObject* pObject = NULL);
  380.     CDocItem* GetNextItemOfKind(POSITION& pos, CRuntimeClass* pClass) const;
  381.  
  382.     // command handling
  383.     virtual BOOL OnCmdMsg(UINT nID, int nCode, void* pExtra,
  384.         AFX_CMDHANDLERINFO* pHandlerInfo);
  385.  
  386.     afx_msg void OnUpdatePasteMenu(CCmdUI* pCmdUI);
  387.     afx_msg void OnUpdatePasteLinkMenu(CCmdUI* pCmdUI);
  388.     afx_msg void OnUpdateEditLinksMenu(CCmdUI* pCmdUI);
  389.     afx_msg void OnEditLinks();
  390.     afx_msg void OnEditConvert();
  391.     afx_msg void OnUpdateEditChangeIcon(CCmdUI* pCmdUI);
  392.     afx_msg void OnEditChangeIcon();
  393.     afx_msg void OnUpdateObjectVerbMenu(CCmdUI* pCmdUI);
  394.     afx_msg void OnFileSendMail();
  395.  
  396.     friend class COleClientItem;
  397.     friend class COleServerItem;
  398. };
  399.  
  400. /////////////////////////////////////////////////////////////////////////////
  401. // COleClientItem - Supports OLE2 non-inplace editing.
  402. //      implements IOleClientSite, IAdviseSink, and IOleInPlaceSite
  403.  
  404. class COleFrameHook;    // forward reference (see ..\src\oleimpl.h)
  405.  
  406. class COleClientItem : public CDocItem
  407. {
  408.     DECLARE_DYNAMIC(COleClientItem)
  409.  
  410. // Constructors
  411. public:
  412.     COleClientItem(COleDocument* pContainerDoc = NULL);
  413.  
  414.     // create from the clipboard
  415.     BOOL CreateFromClipboard(OLERENDER render = OLERENDER_DRAW,
  416.         CLIPFORMAT cfFormat = 0, LPFORMATETC lpFormatEtc = NULL);
  417.     BOOL CreateLinkFromClipboard(OLERENDER render = OLERENDER_DRAW,
  418.         CLIPFORMAT cfFormat = 0, LPFORMATETC lpFormatEtc = NULL);
  419.     BOOL CreateStaticFromClipboard(OLERENDER render = OLERENDER_DRAW,
  420.         CLIPFORMAT cfFormat = 0, LPFORMATETC lpFormatEtc = NULL);
  421.  
  422.     // create from a class ID (Insert New Object dialog)
  423.     BOOL CreateNewItem(REFCLSID clsid, OLERENDER render = OLERENDER_DRAW,
  424.         CLIPFORMAT cfFormat = 0, LPFORMATETC lpFormatEtc = NULL);
  425.  
  426.     // create from COleDataObject
  427.     BOOL CreateFromData(COleDataObject* pDataObject,
  428.         OLERENDER render = OLERENDER_DRAW,
  429.         CLIPFORMAT cfFormat = 0, LPFORMATETC lpFormatEtc = NULL);
  430.     BOOL CreateLinkFromData(COleDataObject* pDataObject,
  431.         OLERENDER render = OLERENDER_DRAW,
  432.         CLIPFORMAT cfFormat = 0, LPFORMATETC lpFormatEtc = NULL);
  433.     BOOL CreateStaticFromData(COleDataObject* pDataObject,
  434.         OLERENDER render = OLERENDER_DRAW,
  435.         CLIPFORMAT cfFormat = 0, LPFORMATETC lpFormatEtc = NULL);
  436.  
  437.     // create from file (package support)
  438.     BOOL CreateFromFile(LPCTSTR lpszFileName, REFCLSID clsid = CLSID_NULL,
  439.         OLERENDER render = OLERENDER_DRAW,
  440.         CLIPFORMAT cfFormat = 0, LPFORMATETC lpFormatEtc = NULL);
  441.     BOOL CreateLinkFromFile(LPCTSTR lpszFileName,
  442.         OLERENDER render = OLERENDER_DRAW,
  443.         CLIPFORMAT cfFormat = 0, LPFORMATETC lpFormatEtc = NULL);
  444.  
  445.     // create a copy
  446.     BOOL CreateCloneFrom(const COleClientItem* pSrcItem);
  447.  
  448. // General Attributes
  449. public:
  450.     SCODE GetLastStatus() const;
  451.     OLE_OBJTYPE GetType() const; // OT_LINK, OT_EMBEDDED, OT_STATIC
  452.     void GetClassID(CLSID* pClassID) const;
  453.     void GetUserType(USERCLASSTYPE nUserClassType, CString& rString);
  454.     BOOL GetExtent(LPSIZE lpSize, DVASPECT nDrawAspect = (DVASPECT)-1);
  455.         // will return FALSE if item is BLANK
  456.     BOOL GetCachedExtent(LPSIZE lpSize, DVASPECT nDrawAspect = (DVASPECT)-1);
  457.  
  458.     // getting/setting iconic cache
  459.     HGLOBAL GetIconicMetafile();
  460.     BOOL SetIconicMetafile(HGLOBAL hMetaPict);
  461.  
  462.     // setting/getting default display aspect
  463.     DVASPECT GetDrawAspect() const;
  464.     virtual void SetDrawAspect(DVASPECT nDrawAspect);
  465.  
  466.     // for printer presentation cache
  467.     BOOL SetPrintDevice(const DVTARGETDEVICE* ptd);
  468.     BOOL SetPrintDevice(const PRINTDLG* ppd);
  469.  
  470.     // Item state
  471.     enum ItemState
  472.         { emptyState, loadedState, openState, activeState, activeUIState };
  473.     UINT GetItemState() const;
  474.  
  475.     BOOL IsModified() const;
  476.     BOOL IsRunning() const;
  477.     BOOL IsInPlaceActive() const;
  478.     BOOL IsOpen() const;
  479.     CView* GetActiveView() const;
  480.  
  481.     // Data access
  482.     void AttachDataObject(COleDataObject& rDataObject) const;
  483.  
  484.     // other rare access information
  485.     COleDocument* GetDocument() const; // return container
  486.  
  487.     // helpers for checking clipboard data availability
  488.     static BOOL PASCAL CanPaste();
  489.     static BOOL PASCAL CanPasteLink();
  490.  
  491.     // helpers for checking COleDataObject, useful in drag drop
  492.     static BOOL PASCAL CanCreateFromData(const COleDataObject* pDataObject);
  493.     static BOOL PASCAL CanCreateLinkFromData(const COleDataObject* pDataObject);
  494.  
  495. // General Operations
  496.     virtual void Release(OLECLOSE dwCloseOption = OLECLOSE_NOSAVE);
  497.         // cleanup, detach (close if needed)
  498.     void Close(OLECLOSE dwCloseOption = OLECLOSE_SAVEIFDIRTY);
  499.         // close without releasing the item
  500.     void Delete(BOOL bAutoDelete = TRUE);
  501.         // logically delete from file -- not part of the document anymore
  502.     void Run(); // insure item is in running state
  503.  
  504.     // Drawing
  505.     BOOL Draw(CDC* pDC, LPCRECT lpBounds,
  506.         DVASPECT nDrawAspect = (DVASPECT)-1);   // defaults to m_nDrawAspect
  507.  
  508.     // Activation
  509.     virtual BOOL DoVerb(LONG nVerb, CView* pView, LPMSG lpMsg = NULL);
  510.     void Activate(LONG nVerb, CView* pView, LPMSG lpMsg = NULL);
  511.  
  512.     // In-place Activation
  513.     void Deactivate();          // completely deactivate
  514.     void DeactivateUI();        // deactivate the user interface
  515.     BOOL ReactivateAndUndo();   // reactivate then perform undo command
  516.     BOOL SetItemRects(LPCRECT lpPosRect = NULL, LPCRECT lpClipRect = NULL);
  517.     CWnd* GetInPlaceWindow();
  518.  
  519.     // Clipboard operations
  520.     void CopyToClipboard(BOOL bIncludeLink = FALSE);
  521.     DROPEFFECT DoDragDrop(LPCRECT lpItemRect, CPoint ptOffset,
  522.         BOOL bIncludeLink = FALSE,
  523.         DWORD dwEffects = DROPEFFECT_COPY|DROPEFFECT_MOVE,
  524.         LPCRECT lpRectStartDrag = NULL);
  525.     void GetClipboardData(COleDataSource* pDataSource,
  526.         BOOL bIncludeLink = FALSE, LPPOINT lpOffset = NULL,
  527.         LPSIZE lpSize = NULL);
  528.  
  529.     // called for creating a COleDataSource by CopyToClipboard and DoDragDrop
  530.     virtual COleDataSource* OnGetClipboardData(BOOL bIncludeLink,
  531.         LPPOINT lpOffset, LPSIZE lpSize);
  532.  
  533.     // Operations that apply to embedded items only
  534.     void SetHostNames(LPCTSTR lpszHost, LPCTSTR lpszHostObj);
  535.     void SetExtent(const CSize& size, DVASPECT nDrawAspect = DVASPECT_CONTENT);
  536.  
  537.     // Operations that apply to linked items only
  538.     //  (link options are rarely changed, except through Links dialog)
  539.     OLEUPDATE GetLinkUpdateOptions();
  540.     void SetLinkUpdateOptions(OLEUPDATE dwUpdateOpt);
  541.  
  542.     // Link-source update status (also useful for embeddings that contain links)
  543.     BOOL UpdateLink();  // make up-to-date
  544.     BOOL IsLinkUpToDate() const;    // is link up-to-date
  545.  
  546.     // object conversion
  547.     virtual BOOL ConvertTo(REFCLSID clsidNew);
  548.     virtual BOOL ActivateAs(LPCTSTR lpszUserType, REFCLSID clsidOld, REFCLSID clsidNew);
  549.     BOOL Reload();  // for lazy reload after ActivateAs
  550.  
  551. // Overridables (notifications of IAdviseSink, IOleClientSite and IOleInPlaceSite)
  552.     // Callbacks/notifications from the server you must/should implement
  553.     virtual void OnChange(OLE_NOTIFICATION nCode, DWORD dwParam);
  554.         // implement OnChange to invalidate when item changes
  555.  
  556. protected:
  557.     virtual void OnGetItemPosition(CRect& rPosition);
  558.         // implement OnGetItemPosition if you support in-place activation
  559.  
  560.     // Common overrides for in-place activation
  561.     virtual BOOL OnScrollBy(CSize sizeExtent);
  562.  
  563.     // Common overrides for applications supporting undo
  564.     virtual void OnDiscardUndoState();
  565.     virtual void OnDeactivateAndUndo();
  566.  
  567. public:
  568.     virtual void OnDeactivateUI(BOOL bUndoable);
  569.  
  570. protected:
  571.     // Common overrides for applications supporting links to embeddings
  572.     virtual void OnShowItem();
  573.  
  574.     // Advanced overrides for in-place activation
  575.     virtual void OnGetClipRect(CRect& rClipRect);
  576.     virtual BOOL CanActivate();
  577.  
  578. public:
  579.     virtual void OnActivate();
  580.     virtual void OnActivateUI();
  581.     virtual void OnDeactivate();
  582.  
  583. protected:
  584.     virtual BOOL OnGetWindowContext(CFrameWnd** ppMainFrame,
  585.         CFrameWnd** ppDocFrame, LPOLEINPLACEFRAMEINFO lpFrameInfo);
  586.     virtual BOOL OnChangeItemPosition(const CRect& rectPos);
  587.         // default calls SetItemRects and caches the pos rect
  588.  
  589. public:
  590.     // Advanced overrides for menu/title handling (rarely overridden)
  591.     virtual void OnInsertMenus(CMenu* pMenuShared,
  592.         LPOLEMENUGROUPWIDTHS lpMenuWidths);
  593.     virtual void OnSetMenu(CMenu* pMenuShared, HOLEMENU holemenu,
  594.         HWND hwndActiveObject);
  595.     virtual void OnRemoveMenus(CMenu* pMenuShared);
  596.     virtual BOOL OnUpdateFrameTitle();
  597.  
  598.     // Advanced override for control bar handling
  599.     virtual BOOL OnShowControlBars(CFrameWnd* pFrameWnd, BOOL bShow);
  600.  
  601. // Implementation
  602. public:
  603.     // data to support non-inplace activated items
  604.     LPOLEOBJECT m_lpObject; // in case you want direct access to the OLE object
  605.     LPVIEWOBJECT2 m_lpViewObject;// IViewObject for IOleObject above
  606.     DWORD m_dwItemNumber;   // serial number for this item in this document
  607.     DVASPECT m_nDrawAspect; // current default display aspect
  608.     SCODE m_scLast;         // last error code encountered
  609.     LPSTORAGE m_lpStorage;  // provides storage for m_lpObject
  610.     LPLOCKBYTES m_lpLockBytes;  // part of implementation of m_lpStorage
  611.     DWORD m_dwConnection;   // advise connection to the m_lpObject
  612.     BYTE m_bLinkUnavail;    // TRUE if link is currently unavailable
  613.     BYTE m_bMoniker;        // TRUE if moniker is assigned
  614.     BYTE m_bLocked;         // TRUE if object has external lock
  615.     BYTE m_bNeedCommit;     // TRUE if need CommitItem
  616.     BYTE m_bClosing;        // TRUE if currently doing COleClientItem::Close
  617.     BYTE m_bReserved[3];    // (reserved for future use)
  618.  
  619.     // for compound file support
  620.     LPSTORAGE m_lpNewStorage;   // used during Save As situations
  621.  
  622.     // item state & item type
  623.     ItemState m_nItemState; // item state (see ItemState enumeration)
  624.     OLE_OBJTYPE m_nItemType;    // item type (depends on how created)
  625.  
  626.     // data valid when in-place activated
  627.     CView* m_pView; // view when object is in-place activated
  628.     DWORD m_dwContainerStyle;   // style of the container wnd before activation
  629.     COleFrameHook* m_pInPlaceFrame;// frame window when in-place active
  630.     COleFrameHook* m_pInPlaceDoc;   // doc window when in-place (may be NULL)
  631.     HWND m_hWndServer;  // HWND of in-place server window
  632.  
  633. public:
  634.     virtual ~COleClientItem();
  635.     virtual void Serialize(CArchive& ar);
  636. #ifdef _DEBUG
  637.     virtual void AssertValid() const;
  638.     virtual void Dump(CDumpContext& dc) const;
  639. #endif
  640.  
  641. // Implementation
  642. public:
  643.     virtual BOOL ReportError(SCODE sc) const;
  644.     virtual BOOL FreezeLink();  // converts to static: for edit links dialog
  645.  
  646.     DWORD GetNewItemNumber();   // generates new item number
  647.     void GetItemName(LPTSTR lpszItemName) const; // gets readable item name
  648.  
  649.     void UpdateItemType();  // update m_nItemType
  650.  
  651. protected:
  652.     // clipboard helpers
  653.     void GetEmbeddedItemData(LPSTGMEDIUM lpStgMedium);
  654.     void AddCachedData(COleDataSource* pDataSource);
  655.     BOOL GetLinkSourceData(LPSTGMEDIUM lpStgMedium);
  656.     void GetObjectDescriptorData(LPPOINT lpOffset, LPSIZE lpSize,
  657.         LPSTGMEDIUM lpStgMedium);
  658.  
  659.     // interface helpers
  660.     virtual LPOLECLIENTSITE GetClientSite();
  661.  
  662.     // helpers for printer-cached representation
  663.     BOOL GetPrintDeviceInfo(LPOLECACHE* plpOleCache,
  664.         DVTARGETDEVICE** pptd, DWORD* pdwConnection);
  665.  
  666. // Advanced Overridables for implementation
  667. protected:
  668.     virtual BOOL FinishCreate(SCODE sc);
  669.     virtual void CheckGeneral(SCODE sc);
  670.  
  671.     virtual void OnDataChange(LPFORMATETC lpFormatEtc,
  672.         LPSTGMEDIUM lpStgMedium);
  673.  
  674. public:
  675.     // for storage hookability (override to use 'docfiles')
  676.     virtual void GetItemStorage();  // allocate storage for new item
  677.     virtual void ReadItem(CArchive& ar);    // read item from archive
  678.     virtual void WriteItem(CArchive& ar);   // write item to archive
  679.     virtual void CommitItem(BOOL bSuccess); // commit item's storage
  680.  
  681.     // compound & flat file implementations of above
  682.     void GetItemStorageFlat();
  683.     void ReadItemFlat(CArchive& ar);
  684.     void WriteItemFlat(CArchive& ar);
  685.     void GetItemStorageCompound();
  686.     void ReadItemCompound(CArchive& ar);
  687.     void WriteItemCompound(CArchive& ar);
  688.  
  689. // Interface Maps
  690. public:
  691.     BEGIN_INTERFACE_PART(OleClientSite, IOleClientSite)
  692.         INIT_INTERFACE_PART(COleClientItem, OleClientSite)
  693.         STDMETHOD(SaveObject)();
  694.         STDMETHOD(GetMoniker)(DWORD, DWORD, LPMONIKER*);
  695.         STDMETHOD(GetContainer)(LPOLECONTAINER*);
  696.         STDMETHOD(ShowObject)();
  697.         STDMETHOD(OnShowWindow)(BOOL);
  698.         STDMETHOD(RequestNewObjectLayout)();
  699.     END_INTERFACE_PART(OleClientSite)
  700.  
  701.     BEGIN_INTERFACE_PART(AdviseSink, IAdviseSink)
  702.         INIT_INTERFACE_PART(COleClientItem, AdviseSink)
  703.         STDMETHOD_(void,OnDataChange)(LPFORMATETC, LPSTGMEDIUM);
  704.         STDMETHOD_(void,OnViewChange)(DWORD, LONG);
  705.         STDMETHOD_(void,OnRename)(LPMONIKER);
  706.         STDMETHOD_(void,OnSave)();
  707.         STDMETHOD_(void,OnClose)();
  708.     END_INTERFACE_PART(AdviseSink)
  709.  
  710.     BEGIN_INTERFACE_PART(OleIPSite, IOleInPlaceSite)
  711.         INIT_INTERFACE_PART(COleClientItem, OleIPSite)
  712.         STDMETHOD(GetWindow)(HWND*);
  713.         STDMETHOD(ContextSensitiveHelp)(BOOL);
  714.         STDMETHOD(CanInPlaceActivate)();
  715.         STDMETHOD(OnInPlaceActivate)();
  716.         STDMETHOD(OnUIActivate)();
  717.         STDMETHOD(GetWindowContext)(LPOLEINPLACEFRAME*,
  718.             LPOLEINPLACEUIWINDOW*, LPRECT, LPRECT, LPOLEINPLACEFRAMEINFO);
  719.         STDMETHOD(Scroll)(SIZE);
  720.         STDMETHOD(OnUIDeactivate)(BOOL);
  721.         STDMETHOD(OnInPlaceDeactivate)();
  722.         STDMETHOD(DiscardUndoState)();
  723.         STDMETHOD(DeactivateAndUndo)();
  724.         STDMETHOD(OnPosRectChange)(LPCRECT);
  725.     END_INTERFACE_PART(OleIPSite)
  726.  
  727.     DECLARE_INTERFACE_MAP()
  728.  
  729. // Friendship declarations (to avoid many public members)
  730.     friend class COleUIWindow;
  731.     friend class COleFrameWindow;
  732.     friend class COleLinkingDoc;
  733. };
  734.  
  735. /////////////////////////////////////////////////////////////////////////////
  736. // COleServerItem - IOleObject & IDataObject OLE component
  737.  
  738. class COleServerItem : public CDocItem
  739. {
  740.     DECLARE_DYNAMIC(COleServerItem)
  741. protected:
  742.     // NOTE: many members in this class are protected - since everything
  743.     //   in this class is designed for implementing an OLE server.
  744.     // Requests will come from OLE containers through non-C++ mechanisms,
  745.     //   which will result in virtual functions in this class being called.
  746.  
  747. // Constructors
  748.     COleServerItem(COleServerDoc* pServerDoc, BOOL bAutoDelete);
  749.         // If your COleServerItem is an integral part of your data,
  750.         //  bAutoDelete should be FALSE.  If your COleServerItem can be
  751.         //  deleted when a link is released, it can be TRUE.
  752.  
  753.     COleDataSource* GetDataSource();
  754.         // Use this data source to add conversion formats that your
  755.         //  server should support.  Usually such formats are
  756.         //  added in the item's constructor.
  757.  
  758. // Public Attributes
  759. public:
  760.     COleServerDoc* GetDocument() const; // return server document
  761.  
  762.     // naming (for links only)
  763.     const CString& GetItemName() const; // get name of linked item
  764.     void SetItemName(LPCTSTR lpszItemName);  // set name of linked item
  765.  
  766.     // link state
  767.     BOOL IsConnected() const;   // returns TRUE if item has a client
  768.     BOOL IsLinkedItem() const;  // returns TRUE if item is not embedded item
  769.  
  770.     // extents
  771.     CSize m_sizeExtent;
  772.         // HIMETRIC size -- the default implementation of OnSetExtent
  773.         //  updates this member variable.  This member tells the server how
  774.         //  much of the object is visible in the container document.
  775.  
  776. // Operations
  777. public:
  778.     void NotifyChanged(DVASPECT nDrawAspect = DVASPECT_CONTENT);
  779.         // call this after you change item
  780.     void CopyToClipboard(BOOL bIncludeLink = FALSE);
  781.         // helper for implementing server 'copy to clipboard'
  782.     DROPEFFECT DoDragDrop(LPCRECT lpRectItem, CPoint ptOffset,
  783.         BOOL bIncludeLink = FALSE,
  784.         DWORD dwEffects = DROPEFFECT_COPY|DROPEFFECT_MOVE,
  785.         LPCRECT lpRectStartDrag = NULL);
  786.     void GetClipboardData(COleDataSource* pDataSource,
  787.         BOOL bIncludeLink = FALSE, LPPOINT lpOffset = NULL,
  788.         LPSIZE lpSize = NULL);
  789.  
  790. // Overridables
  791.     // overridables you must implement for yourself
  792.     virtual BOOL OnDraw(CDC* pDC, CSize& rSize) = 0;
  793.         // drawing for metafile format (return FALSE if not supported or error)
  794.         //  (called for DVASPECT_CONTENT only)
  795.  
  796.     // overridables you may want to implement yourself
  797.     virtual void OnUpdate(COleServerItem* pSender,
  798.         LPARAM lHint, CObject* pHint, DVASPECT nDrawAspect);
  799.         // the default implementation always calls NotifyChanged
  800.  
  801.     virtual BOOL OnDrawEx(CDC* pDC, DVASPECT nDrawAspect, CSize& rSize);
  802.         // advanced drawing -- called for DVASPECT other than DVASPECT_CONTENT
  803.     virtual BOOL OnSetExtent(DVASPECT nDrawAspect, const CSize& size);
  804.     virtual BOOL OnGetExtent(DVASPECT nDrawAspect, CSize& rSize);
  805.         // default implementation uses m_sizeExtent
  806.  
  807.     // overridables you do not have to implement
  808.     virtual void OnDoVerb(LONG iVerb);
  809.         // default routes to OnShow &/or OnOpen
  810.     virtual BOOL OnSetColorScheme(const LOGPALETTE* lpLogPalette);
  811.         // default does nothing
  812.     virtual COleDataSource* OnGetClipboardData(BOOL bIncludeLink,
  813.         LPPOINT lpOffset, LPSIZE lpSize);
  814.         // called for access to clipboard data
  815.     virtual BOOL OnQueryUpdateItems();
  816.         // called to determine if there are any contained out-of-date links
  817.     virtual void OnUpdateItems();
  818.         // called to update any out-of-date links
  819.  
  820. protected:
  821.     virtual void OnShow();
  822.         // show item in the user interface (may edit in-place)
  823.     virtual void OnOpen();
  824.         // show item in the user interface (must open fully)
  825.     virtual void OnHide();
  826.         // hide document (and sometimes application)
  827.  
  828.     // very advanced overridables
  829. public:
  830.     virtual BOOL OnInitFromData(COleDataObject* pDataObject, BOOL bCreation);
  831.         // initialize object from IDataObject
  832.  
  833.     // see COleDataSource for a description of these overridables
  834.     virtual BOOL OnRenderGlobalData(LPFORMATETC lpFormatEtc, HGLOBAL* phGlobal);
  835.     virtual BOOL OnRenderFileData(LPFORMATETC lpFormatEtc, CFile* pFile);
  836.     virtual BOOL OnRenderData(LPFORMATETC lpFormatEtc, LPSTGMEDIUM lpStgMedium);
  837.         // HGLOBAL version will be called first, then CFile* version
  838.  
  839.     virtual BOOL OnSetData(LPFORMATETC lpFormatEtc, LPSTGMEDIUM lpStgMedium,
  840.         BOOL bRelease);
  841.         // Rare -- only if you support SetData (programmatic paste)
  842.  
  843.     // advanced helpers for CopyToClipboard
  844.     void GetEmbedSourceData(LPSTGMEDIUM lpStgMedium);
  845.     void AddOtherClipboardData(COleDataSource* pDataSource);
  846.     BOOL GetLinkSourceData(LPSTGMEDIUM lpStgMedium);
  847.     void GetObjectDescriptorData(LPPOINT lpOffset, LPSIZE lpSize,
  848.         LPSTGMEDIUM lpStgMedium);
  849.  
  850. // Implementation
  851. public:
  852.     BOOL m_bNeedUnlock;             // if TRUE need to pDoc->LockExternal(FALSE)
  853.     BOOL m_bAutoDelete;             // if TRUE will OnRelease will 'delete this'
  854.  
  855.     // special version of OnFinalRelease to implement document locking
  856.     virtual void OnFinalRelease();
  857.  
  858. protected:
  859.     CString m_strItemName;          // simple item name
  860.  
  861. public:
  862.     LPOLEADVISEHOLDER m_lpOleAdviseHolder;  // may be NULL
  863.     LPDATAADVISEHOLDER m_lpDataAdviseHolder;    // may be NULL
  864.  
  865.     virtual ~COleServerItem();
  866. #ifdef _DEBUG
  867.     virtual void AssertValid() const;
  868.     virtual void Dump(CDumpContext& dc) const;
  869. #endif
  870.  
  871.     // implementation helpers
  872.     void NotifyClient(OLE_NOTIFICATION wNotification, DWORD dwParam);
  873.     LPDATAOBJECT GetDataObject();
  874.     LPOLEOBJECT GetOleObject();
  875.     LPMONIKER GetMoniker(OLEGETMONIKER nAssign);
  876.  
  877. protected:
  878.     virtual BOOL GetMetafileData(LPFORMATETC lpFormatEtc, LPSTGMEDIUM pmedium);
  879.         // calls OnDraw or OnDrawEx
  880.     virtual void OnSaveEmbedding(LPSTORAGE lpStorage);
  881.     virtual BOOL IsBlank() const;
  882.  
  883.     // CItemDataSource implements OnRender reflections to COleServerItem
  884.     class CItemDataSource : public COleDataSource
  885.     {
  886.     protected:
  887.         // the GetData and SetData interfaces forward to m_pItem
  888.         virtual BOOL OnRenderGlobalData(LPFORMATETC lpFormatEtc, HGLOBAL* phGlobal);
  889.         virtual BOOL OnRenderFileData(LPFORMATETC lpFormatEtc, CFile* pFile);
  890.         virtual BOOL OnRenderData(LPFORMATETC lpFormatEtc, LPSTGMEDIUM lpStgMedium);
  891.             // HGLOBAL version will be called first, then CFile* version
  892.  
  893.         virtual BOOL OnSetData(LPFORMATETC lpFormatEtc, LPSTGMEDIUM lpStgMedium,
  894.             BOOL bRelease);
  895.     };
  896.     CItemDataSource m_dataSource;
  897.         // data source used to implement IDataObject
  898.  
  899. // Interface Maps
  900. //  (Note: these interface maps are used just for link implementation)
  901. public:
  902.     BEGIN_INTERFACE_PART(OleObject, IOleObject)
  903.         INIT_INTERFACE_PART(COleServerItem, OleObject)
  904.         STDMETHOD(SetClientSite)(LPOLECLIENTSITE);
  905.         STDMETHOD(GetClientSite)(LPOLECLIENTSITE*);
  906.         STDMETHOD(SetHostNames)(LPCOLESTR, LPCOLESTR);
  907.         STDMETHOD(Close)(DWORD);
  908.         STDMETHOD(SetMoniker)(DWORD, LPMONIKER);
  909.         STDMETHOD(GetMoniker)(DWORD, DWORD, LPMONIKER*);
  910.         STDMETHOD(InitFromData)(LPDATAOBJECT, BOOL, DWORD);
  911.         STDMETHOD(GetClipboardData)(DWORD, LPDATAOBJECT*);
  912.         STDMETHOD(DoVerb)(LONG, LPMSG, LPOLECLIENTSITE, LONG, HWND, LPCRECT);
  913.         STDMETHOD(EnumVerbs)(LPENUMOLEVERB*);
  914.         STDMETHOD(Update)();
  915.         STDMETHOD(IsUpToDate)();
  916.         STDMETHOD(GetUserClassID)(LPCLSID);
  917.         STDMETHOD(GetUserType)(DWORD, LPOLESTR*);
  918.         STDMETHOD(SetExtent)(DWORD, LPSIZEL);
  919.         STDMETHOD(GetExtent)(DWORD, LPSIZEL);
  920.         STDMETHOD(Advise)(LPADVISESINK, LPDWORD);
  921.         STDMETHOD(Unadvise)(DWORD);
  922.         STDMETHOD(EnumAdvise)(LPENUMSTATDATA*);
  923.         STDMETHOD(GetMiscStatus)(DWORD, LPDWORD);
  924.         STDMETHOD(SetColorScheme)(LPLOGPALETTE);
  925.     END_INTERFACE_PART(OleObject)
  926.  
  927.     BEGIN_INTERFACE_PART(DataObject, IDataObject)
  928.         INIT_INTERFACE_PART(COleServerItem, DataObject)
  929.         STDMETHOD(GetData)(LPFORMATETC, LPSTGMEDIUM);
  930.         STDMETHOD(GetDataHere)(LPFORMATETC, LPSTGMEDIUM);
  931.         STDMETHOD(QueryGetData)(LPFORMATETC);
  932.         STDMETHOD(GetCanonicalFormatEtc)(LPFORMATETC, LPFORMATETC);
  933.         STDMETHOD(SetData)(LPFORMATETC, LPSTGMEDIUM, BOOL);
  934.         STDMETHOD(EnumFormatEtc)(DWORD, LPENUMFORMATETC*);
  935.         STDMETHOD(DAdvise)(LPFORMATETC, DWORD, LPADVISESINK, LPDWORD);
  936.         STDMETHOD(DUnadvise)(DWORD);
  937.         STDMETHOD(EnumDAdvise)(LPENUMSTATDATA*);
  938.     END_INTERFACE_PART(DataObject)
  939.  
  940.     DECLARE_INTERFACE_MAP()
  941.  
  942.     friend class CItemDataSource;
  943.     friend class COleServerDoc;
  944.     friend class COleLinkingDoc;
  945. };
  946.  
  947. /////////////////////////////////////////////////////////////////////////////
  948. // COleLinkingDoc -
  949. //  (enables linking to embeddings - beginnings of server fuctionality)
  950.  
  951. class COleLinkingDoc : public COleDocument
  952. {
  953.     DECLARE_DYNAMIC(COleLinkingDoc)
  954.  
  955. // Constructors
  956. public:
  957.     COleLinkingDoc();
  958.  
  959. // Operations
  960.     BOOL Register(COleObjectFactory* pFactory, LPCTSTR lpszPathName);
  961.         // notify the running object table and connect to pServer
  962.     void Revoke();
  963.         // revoke from running object table
  964.  
  965. // Overridables
  966. protected:
  967.     virtual COleServerItem* OnGetLinkedItem(LPCTSTR lpszItemName);
  968.         // return item for the named linked item (for supporting links)
  969.     virtual COleClientItem* OnFindEmbeddedItem(LPCTSTR lpszItemName);
  970.         // return item for the named embedded item (for links to embeddings)
  971.  
  972. // Implementation
  973. public:
  974.     COleObjectFactory* m_pFactory;  // back-pointer to server
  975.  
  976. #ifdef _DEBUG
  977.     virtual void AssertValid() const;
  978.     virtual void Dump(CDumpContext& dc) const;
  979. #endif
  980.     virtual ~COleLinkingDoc();
  981.  
  982.     // overrides for updating of monikers & running object table registration
  983.     virtual BOOL OnNewDocument();
  984.     virtual BOOL OnOpenDocument(LPCTSTR lpszPathName);
  985.     virtual BOOL OnSaveDocument(LPCTSTR lpszPathName);
  986.     virtual void OnCloseDocument();
  987.     virtual LPOLEITEMCONTAINER GetContainer();
  988.     virtual LPMONIKER GetMoniker(OLEGETMONIKER nAssign);
  989.  
  990.     // special handling of error messages during save/load
  991.     virtual void ReportSaveLoadException(LPCTSTR lpszPathName,
  992.         CException* e, BOOL bSaving, UINT nIDPDefault);
  993.     void BeginDeferErrors();
  994.     SCODE EndDeferErrors(SCODE sc);
  995.  
  996. protected:
  997.     BOOL m_bDeferErrors;    // TRUE if in non-interactive OLE mode
  998.     CException* m_pLastException;
  999.  
  1000.     DWORD m_dwRegister;     // file moniker's registration in the ROT
  1001.     LPMONIKER m_lpMonikerROT; // file moniker that is registered
  1002.     CString m_strMoniker;   // filename used to create moniker
  1003.     BOOL m_bVisibleLock;    // TRUE if user is holding lock on document
  1004.  
  1005.     // implementation helpers
  1006.     virtual BOOL RegisterIfServerAttached(LPCTSTR lpszPathName, BOOL bMessage);
  1007.     void LockExternal(BOOL bLock, BOOL bRemoveRefs);
  1008.     void UpdateVisibleLock(BOOL bVisible, BOOL bRemoveRefs);
  1009.     virtual void OnShowViews(BOOL bVisible);
  1010.  
  1011.     virtual void SaveToStorage(CObject* pObject = NULL);
  1012.  
  1013. // Interface Maps
  1014. public:
  1015.     BEGIN_INTERFACE_PART(PersistFile, IPersistFile)
  1016.         INIT_INTERFACE_PART(COleLinkingDoc, PersistFile)
  1017.         STDMETHOD(GetClassID)(LPCLSID);
  1018.         STDMETHOD(IsDirty)();
  1019.         STDMETHOD(Load)(LPCOLESTR, DWORD);
  1020.         STDMETHOD(Save)(LPCOLESTR, BOOL);
  1021.         STDMETHOD(SaveCompleted)(LPCOLESTR);
  1022.         STDMETHOD(GetCurFile)(LPOLESTR*);
  1023.     END_INTERFACE_PART(PersistFile)
  1024.  
  1025.     BEGIN_INTERFACE_PART(OleItemContainer, IOleItemContainer)
  1026.         INIT_INTERFACE_PART(COleLinkingDoc, OleItemContainer)
  1027.         STDMETHOD(ParseDisplayName)(LPBC, LPOLESTR, ULONG*, LPMONIKER*);
  1028.         STDMETHOD(EnumObjects)(DWORD, LPENUMUNKNOWN*);
  1029.         STDMETHOD(LockContainer)(BOOL);
  1030.         STDMETHOD(GetObject)(LPOLESTR, DWORD, LPBINDCTX, REFIID, LPVOID*);
  1031.         STDMETHOD(GetObjectStorage)(LPOLESTR, LPBINDCTX, REFIID, LPVOID*);
  1032.         STDMETHOD(IsRunning)(LPOLESTR);
  1033.     END_INTERFACE_PART(OleItemContainer)
  1034.  
  1035.     DECLARE_INTERFACE_MAP()
  1036.  
  1037.     friend class COleClientItem;
  1038.     friend class COleClientItem::XOleClientSite;
  1039.     friend class COleServerItem::XOleObject;
  1040. };
  1041.  
  1042. //////////////////////////////////////////////////////////////////////////////
  1043. // COleServerDoc - registered server document containing COleServerItems
  1044.  
  1045. class COleServerDoc : public COleLinkingDoc
  1046. {
  1047.     DECLARE_DYNAMIC(COleServerDoc)
  1048.  
  1049. // Constructors and Destructors
  1050. public:
  1051.     COleServerDoc();
  1052.  
  1053. // Attributes
  1054.     BOOL IsEmbedded() const;    // TRUE if document is an embedding
  1055.     COleServerItem* GetEmbeddedItem();
  1056.         // return embedded item for document (will allocate if necessary)
  1057.  
  1058.     // attributes specific to in-place activation
  1059.     BOOL IsInPlaceActive() const;
  1060.     void GetItemPosition(LPRECT lpPosRect) const;
  1061.         // get current position rectangle of in-place edit
  1062.     void GetItemClipRect(LPRECT lpClipRect) const;
  1063.         // get current clipping rectangle of in-place edit
  1064.     BOOL GetZoomFactor(LPSIZE lpSizeNum = NULL, LPSIZE lpSizeDenom = NULL,
  1065.         LPCRECT lpPosRect = NULL) const;
  1066.         // returns the zoom factor in pixels
  1067.  
  1068. // Operations
  1069.     void NotifyChanged();
  1070.         // call this after you change some global attribute like
  1071.         //  document dimensions
  1072.     void UpdateAllItems(COleServerItem* pSender,
  1073.         LPARAM lHint = 0L, CObject* pHint = NULL,
  1074.         DVASPECT nDrawAspect = DVASPECT_CONTENT);
  1075.  
  1076.     // changes to the entire document (automatically notifies clients)
  1077.     void NotifyRename(LPCTSTR lpszNewName);
  1078.     void NotifySaved();
  1079.     void NotifyClosed();        // call this after you close document
  1080.  
  1081.     // specific operations for embedded documents
  1082.     void SaveEmbedding();       // call this to save embedded (before closing)
  1083.  
  1084.     // specific to in-place activation
  1085.     BOOL ActivateInPlace();
  1086.     void RequestPositionChange(LPCRECT lpPosRect);
  1087.     BOOL ScrollContainerBy(CSize sizeScroll);
  1088.     BOOL DeactivateAndUndo();
  1089.     BOOL DiscardUndoState();
  1090.  
  1091. public:
  1092. // Overridables for standard user interface (full server)
  1093.     virtual BOOL OnUpdateDocument(); // implementation of embedded update
  1094.  
  1095. protected:
  1096. // Overridables you must implement for yourself
  1097.     virtual COleServerItem* OnGetEmbeddedItem() = 0;
  1098.         // return item representing entire (embedded) document
  1099.  
  1100. // Overridables you do not have to implement
  1101.     virtual void OnClose(OLECLOSE dwCloseOption);
  1102.     virtual void OnSetHostNames(LPCTSTR lpszHost, LPCTSTR lpszHostObj);
  1103.  
  1104. // Advanced overridables
  1105.     virtual void OnShowDocument(BOOL bShow);
  1106.         // show first frame for document or hide all frames for document
  1107.  
  1108. // Advanced overridables for in-place activation
  1109. public:
  1110.     virtual void OnDeactivate();
  1111.     virtual void OnDeactivateUI(BOOL bUndoable);
  1112.  
  1113. protected:
  1114.     virtual void OnSetItemRects(LPCRECT lpPosRect, LPCRECT lpClipRect);
  1115.     virtual BOOL OnReactivateAndUndo();
  1116.  
  1117.     virtual void OnFrameWindowActivate(BOOL bActivate);
  1118.     virtual void OnDocWindowActivate(BOOL bActivate);
  1119.     virtual void OnShowControlBars(CFrameWnd* pFrameWnd, BOOL bShow);
  1120.     virtual COleIPFrameWnd* CreateInPlaceFrame(CWnd* pParentWnd);
  1121.     virtual void DestroyInPlaceFrame(COleIPFrameWnd* pFrameWnd);
  1122. public:
  1123.     virtual void OnResizeBorder(LPCRECT lpRectBorder,
  1124.         LPOLEINPLACEUIWINDOW lpUIWindow, BOOL bFrame);
  1125.  
  1126. // Implementation
  1127. protected:
  1128.     LPOLECLIENTSITE m_lpClientSite;     // for embedded item
  1129.     CString m_strHostObj;               // name of document in container
  1130.     BOOL m_bCntrVisible;                // TRUE if OnShowWindow(TRUE) called
  1131.     BOOL m_bClosing;                    // TRUE if shutting down
  1132.     COleServerItem* m_pEmbeddedItem;    // pointer to embedded item for document
  1133.  
  1134.     COleIPFrameWnd* m_pInPlaceFrame;    // not NULL if in-place activated
  1135.     CWnd* m_pOrigParent;                // not NULL if existing view used
  1136.     DWORD m_dwOrigStyle;                // original style of in-place view
  1137.     DWORD m_dwOrigStyleEx;              // original extended style
  1138.  
  1139. public:
  1140.     virtual ~COleServerDoc();
  1141. #ifdef _DEBUG
  1142.     virtual void AssertValid() const;
  1143.     virtual void Dump(CDumpContext& dc) const;
  1144. #endif
  1145.  
  1146.     // overridables for implementation
  1147.     virtual BOOL OnSaveDocument(LPCTSTR lpszPathName);
  1148.     virtual void OnCloseDocument();
  1149.     virtual void DeleteContents(); // delete auto-delete server items
  1150.     virtual LPMONIKER GetMoniker(OLEGETMONIKER nAssign);
  1151.     virtual COleServerItem* OnGetLinkedItem(LPCTSTR lpszItemName);
  1152.         // return item for the named linked item (only if supporting links)
  1153.     virtual BOOL CanCloseFrame(CFrameWnd* pFrame);
  1154.  
  1155. protected:
  1156.     // overrides to handle server user-interface
  1157.     virtual BOOL SaveModified();        // return TRUE if ok to continue
  1158.     virtual HMENU GetDefaultMenu();     // return menu based on doc type
  1159.     virtual HACCEL GetDefaultAccelerator(); // return accel table based on doc type
  1160.     virtual BOOL GetFileTypeString(CString& rString);
  1161.  
  1162.     // IPersistStorage implementation
  1163.     virtual void OnNewEmbedding(LPSTORAGE lpStorage);
  1164.     virtual void OnOpenEmbedding(LPSTORAGE lpStorage);
  1165.     virtual void OnSaveEmbedding(LPSTORAGE lpStorage);
  1166.  
  1167.     // Implementation helpers
  1168.     void NotifyAllItems(OLE_NOTIFICATION wNotification, DWORD dwParam);
  1169.     BOOL SaveModifiedPrompt();
  1170.     void ConnectView(CWnd* pParentWnd, CView* pView);
  1171.     void UpdateUsingHostObj(UINT nIDS, CCmdUI* pCmdUI);
  1172.  
  1173. // Message Maps
  1174.     //{{AFX_MSG(COleServerDoc)
  1175.     afx_msg void OnFileUpdate();
  1176.     afx_msg void OnFileSaveCopyAs();
  1177.     afx_msg void OnUpdateFileUpdate(CCmdUI* pCmdUI);
  1178.     afx_msg void OnUpdateFileExit(CCmdUI* pCmdUI);
  1179.     //}}AFX_MSG
  1180.     DECLARE_MESSAGE_MAP()
  1181.  
  1182. // Interface Maps
  1183. public:
  1184.     BEGIN_INTERFACE_PART(PersistStorage, IPersistStorage)
  1185.         INIT_INTERFACE_PART(COleServerDoc, PersistStorage)
  1186.         STDMETHOD(GetClassID)(LPCLSID);
  1187.         STDMETHOD(IsDirty)();
  1188.         STDMETHOD(InitNew)(LPSTORAGE);
  1189.         STDMETHOD(Load)(LPSTORAGE);
  1190.         STDMETHOD(Save)(LPSTORAGE, BOOL);
  1191.         STDMETHOD(SaveCompleted)(LPSTORAGE);
  1192.         STDMETHOD(HandsOffStorage)();
  1193.     END_INTERFACE_PART(PersistStorage)
  1194.  
  1195.     BEGIN_INTERFACE_PART(OleObject, IOleObject)
  1196.         INIT_INTERFACE_PART(COleServerDoc, OleObject)
  1197.         STDMETHOD(SetClientSite)(LPOLECLIENTSITE);
  1198.         STDMETHOD(GetClientSite)(LPOLECLIENTSITE*);
  1199.         STDMETHOD(SetHostNames)(LPCOLESTR, LPCOLESTR);
  1200.         STDMETHOD(Close)(DWORD);
  1201.         STDMETHOD(SetMoniker)(DWORD, LPMONIKER);
  1202.         STDMETHOD(GetMoniker)(DWORD, DWORD, LPMONIKER*);
  1203.         STDMETHOD(InitFromData)(LPDATAOBJECT, BOOL, DWORD);
  1204.         STDMETHOD(GetClipboardData)(DWORD, LPDATAOBJECT*);
  1205.         STDMETHOD(DoVerb)(LONG, LPMSG, LPOLECLIENTSITE, LONG, HWND, LPCRECT);
  1206.         STDMETHOD(EnumVerbs)(IEnumOLEVERB**);
  1207.         STDMETHOD(Update)();
  1208.         STDMETHOD(IsUpToDate)();
  1209.         STDMETHOD(GetUserClassID)(CLSID*);
  1210.         STDMETHOD(GetUserType)(DWORD, LPOLESTR*);
  1211.         STDMETHOD(SetExtent)(DWORD, LPSIZEL);
  1212.         STDMETHOD(GetExtent)(DWORD, LPSIZEL);
  1213.         STDMETHOD(Advise)(LPADVISESINK, LPDWORD);
  1214.         STDMETHOD(Unadvise)(DWORD);
  1215.         STDMETHOD(EnumAdvise)(LPENUMSTATDATA*);
  1216.         STDMETHOD(GetMiscStatus)(DWORD, LPDWORD);
  1217.         STDMETHOD(SetColorScheme)(LPLOGPALETTE);
  1218.     END_INTERFACE_PART(OleObject)
  1219.  
  1220.     BEGIN_INTERFACE_PART(DataObject, IDataObject)
  1221.         INIT_INTERFACE_PART(COleServerDoc, DataObject)
  1222.         STDMETHOD(GetData)(LPFORMATETC, LPSTGMEDIUM);
  1223.         STDMETHOD(GetDataHere)(LPFORMATETC, LPSTGMEDIUM);
  1224.         STDMETHOD(QueryGetData)(LPFORMATETC);
  1225.         STDMETHOD(GetCanonicalFormatEtc)(LPFORMATETC, LPFORMATETC);
  1226.         STDMETHOD(SetData)(LPFORMATETC, LPSTGMEDIUM, BOOL);
  1227.         STDMETHOD(EnumFormatEtc)(DWORD, LPENUMFORMATETC*);
  1228.         STDMETHOD(DAdvise)(LPFORMATETC, DWORD, LPADVISESINK, LPDWORD);
  1229.         STDMETHOD(DUnadvise)(DWORD);
  1230.         STDMETHOD(EnumDAdvise)(LPENUMSTATDATA*);
  1231.     END_INTERFACE_PART(DataObject)
  1232.  
  1233.     BEGIN_INTERFACE_PART(OleInPlaceObject, IOleInPlaceObject)
  1234.         INIT_INTERFACE_PART(COleServerDoc, OleInPlaceObject)
  1235.         STDMETHOD(GetWindow)(HWND*);
  1236.         STDMETHOD(ContextSensitiveHelp)(BOOL);
  1237.         STDMETHOD(InPlaceDeactivate)();
  1238.         STDMETHOD(UIDeactivate)();
  1239.         STDMETHOD(SetObjectRects)(LPCRECT, LPCRECT);
  1240.         STDMETHOD(ReactivateAndUndo)();
  1241.     END_INTERFACE_PART(OleInPlaceObject)
  1242.  
  1243.     BEGIN_INTERFACE_PART(OleInPlaceActiveObject, IOleInPlaceActiveObject)
  1244.         INIT_INTERFACE_PART(COleServerDoc, OleInPlaceActiveObject)
  1245.         STDMETHOD(GetWindow)(HWND*);
  1246.         STDMETHOD(ContextSensitiveHelp)(BOOL);
  1247.         STDMETHOD(TranslateAccelerator)(LPMSG);
  1248.         STDMETHOD(OnFrameWindowActivate)(BOOL);
  1249.         STDMETHOD(OnDocWindowActivate)(BOOL);
  1250.         STDMETHOD(ResizeBorder)(LPCRECT, LPOLEINPLACEUIWINDOW, BOOL);
  1251.         STDMETHOD(EnableModeless)(BOOL);
  1252.     END_INTERFACE_PART(OleInPlaceActiveObject)
  1253.  
  1254.     DECLARE_INTERFACE_MAP()
  1255.  
  1256.     friend class COleServer;
  1257.     friend class COleServerItem;
  1258. };
  1259.  
  1260. //////////////////////////////////////////////////////////////////////////////
  1261. // COleIPFrameWnd
  1262.  
  1263. class COleCntrFrameWnd;
  1264.  
  1265. class COleIPFrameWnd : public CFrameWnd
  1266. {
  1267.     DECLARE_DYNCREATE(COleIPFrameWnd)
  1268.  
  1269. // Constructors
  1270. public:
  1271.     COleIPFrameWnd();
  1272.  
  1273. // Overridables
  1274. public:
  1275.     virtual BOOL OnCreateControlBars(CWnd* pWndFrame, CWnd* pWndDoc);
  1276.         // create control bars on container windows (pWndDoc can be NULL)
  1277.     virtual BOOL OnCreateControlBars(CFrameWnd* pWndFrame, CFrameWnd* pWndDoc);
  1278.         // create control bars on container windows (pWndDoc can be NULL)
  1279.  
  1280.     virtual void RepositionFrame(LPCRECT lpPosRect, LPCRECT lpClipRect);
  1281.         // Advanced: reposition frame to wrap around new lpPosRect
  1282.  
  1283. // Implementation
  1284. public:
  1285.     BOOL m_bUIActive;   // TRUE if currently in uiacitve state
  1286.  
  1287.     virtual BOOL LoadFrame(UINT nIDResource,
  1288.         DWORD dwDefaultStyle = WS_CHILD|WS_BORDER|WS_CLIPSIBLINGS,
  1289.         CWnd* pParentWnd = NULL,
  1290.         CCreateContext* pContext = NULL);
  1291.     virtual void RecalcLayout(BOOL bNotify = TRUE);
  1292.     virtual BOOL PreTranslateMessage(MSG* pMsg);
  1293.     virtual LRESULT OnSetMessageString(WPARAM wParam, LPARAM lParam);
  1294.     virtual ~COleIPFrameWnd();
  1295. #ifdef _DEBUG
  1296.     virtual void AssertValid() const;
  1297.     virtual void Dump(CDumpContext& dc) const;
  1298. #endif
  1299.  
  1300. protected:
  1301.     // in-place state
  1302.     OLEINPLACEFRAMEINFO m_frameInfo;
  1303.     LPOLEINPLACEFRAME m_lpFrame;
  1304.     LPOLEINPLACEUIWINDOW m_lpDocFrame;
  1305.     COleCntrFrameWnd* m_pMainFrame;
  1306.     COleCntrFrameWnd* m_pDocFrame;
  1307.  
  1308.     HMENU m_hSharedMenu;
  1309.     OLEMENUGROUPWIDTHS m_menuWidths;
  1310.     HOLEMENU m_hOleMenu;
  1311.     CRect m_rectPos;            // client area rect of the item
  1312.     CRect m_rectClip;           // area to which frame should be clipped
  1313.     BOOL m_bInsideRecalc;
  1314.  
  1315.     // Advanced: in-place activation virtual implementation
  1316.     virtual BOOL BuildSharedMenu();
  1317.     virtual void DestroySharedMenu();
  1318.     virtual HMENU GetInPlaceMenu();
  1319.  
  1320.     // Advanced: possible override to change in-place sizing behavior
  1321.     virtual void OnRequestPositionChange(LPCRECT lpRect);
  1322.  
  1323. protected:
  1324.     //{{AFX_MSG(COleIPFrameWnd)
  1325.     afx_msg void OnSize(UINT nType, int cx, int cy);
  1326.     afx_msg LRESULT OnRecalcParent(WPARAM wParam, LPARAM lParam);
  1327.     afx_msg void OnIdleUpdateCmdUI();
  1328.     afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct);
  1329.     afx_msg void OnDestroy();
  1330.     afx_msg LRESULT OnResizeChild(WPARAM wParam, LPARAM lParam);
  1331.     afx_msg void OnContextHelp();
  1332.     afx_msg void OnUpdateControlBarMenu(CCmdUI* pCmdUI);
  1333.     afx_msg BOOL OnBarCheck(UINT nID);
  1334.     afx_msg void OnWindowPosChanging(LPWINDOWPOS lpWndPos);
  1335.     //}}AFX_MSG
  1336.     DECLARE_MESSAGE_MAP()
  1337.  
  1338.     friend class COleServerDoc;
  1339.     friend class COleCntrFrameWnd;
  1340. };
  1341.  
  1342. /////////////////////////////////////////////////////////////////////////////
  1343. // COleResizeBar - supports in-place resizing in server applications
  1344.  
  1345. class COleResizeBar : public CControlBar
  1346. {
  1347.     DECLARE_DYNAMIC(COleResizeBar)
  1348.  
  1349. // Constructors
  1350. public:
  1351.     COleResizeBar();
  1352.     BOOL Create(CWnd* pParentWnd, DWORD dwStyle = WS_CHILD | WS_VISIBLE,
  1353.         UINT nID = AFX_IDW_RESIZE_BAR);
  1354.  
  1355. // Implementation
  1356. public:
  1357.     virtual ~COleResizeBar();
  1358.     virtual void OnUpdateCmdUI(CFrameWnd* pTarget, BOOL bDisableIfNoHndler);
  1359.  
  1360. protected:
  1361.     CRectTracker m_tracker;     // implemented with a tracker
  1362.  
  1363. protected:
  1364.     //{{AFX_MSG(COleResizeBar)
  1365.     afx_msg BOOL OnEraseBkgnd(CDC* pDC);
  1366.     afx_msg void OnPaint();
  1367.     afx_msg void OnSize(UINT nType, int cx, int cy);
  1368.     afx_msg BOOL OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message);
  1369.     afx_msg void OnLButtonDown(UINT, CPoint point);
  1370.     afx_msg LRESULT OnSizeParent(WPARAM wParam, LPARAM lParam);
  1371.     //}}AFX_MSG
  1372.     DECLARE_MESSAGE_MAP()
  1373. };
  1374.  
  1375. /////////////////////////////////////////////////////////////////////////////
  1376. // COleStreamFile - implementation of CFile which uses an IStream
  1377.  
  1378. class COleStreamFile : public CFile
  1379. {
  1380.     DECLARE_DYNAMIC(COleStreamFile)
  1381.  
  1382. // Constructors and Destructors
  1383. public:
  1384.     COleStreamFile(LPSTREAM lpStream = NULL);
  1385.  
  1386. // Operations
  1387.     // Note: OpenStream and CreateStream can accept eith STGM_ flags or
  1388.     //  CFile::OpenFlags bits since common values are guaranteed to have
  1389.     //  the same semantics.
  1390.     BOOL OpenStream(LPSTORAGE lpStorage, LPCTSTR lpszStreamName,
  1391.         DWORD nOpenFlags = modeReadWrite|shareExclusive,
  1392.         CFileException* pError = NULL);
  1393.     BOOL CreateStream(LPSTORAGE lpStorage, LPCTSTR lpszStreamName,
  1394.         DWORD nOpenFlags = modeReadWrite|shareExclusive|modeCreate,
  1395.         CFileException* pError = NULL);
  1396.  
  1397.     BOOL CreateMemoryStream(CFileException* pError = NULL);
  1398.  
  1399.     // attach & detach can be used when Open/Create functions aren't adequate
  1400.     void Attach(LPSTREAM lpStream);
  1401.     LPSTREAM Detach();
  1402.  
  1403. // Implementation
  1404. public:
  1405.     LPSTREAM m_lpStream;
  1406. #ifdef _DEBUG
  1407.     virtual void AssertValid() const;
  1408.     virtual void Dump(CDumpContext& dc) const;
  1409. #endif
  1410.     virtual ~COleStreamFile();
  1411.  
  1412.     // attributes for implementation
  1413.     BOOL GetStatus(CFileStatus& rStatus) const;
  1414.     virtual DWORD GetPosition() const;
  1415.  
  1416.     virtual const CString GetStorageName() const;
  1417.  
  1418.     // overrides for implementation
  1419.     virtual CFile* Duplicate() const;
  1420.     virtual LONG Seek(LONG lOff, UINT nFrom);
  1421.     virtual void SetLength(DWORD dwNewLen);
  1422.     virtual DWORD GetLength() const;
  1423.     virtual UINT Read(void* lpBuf, UINT nCount);
  1424.     virtual void Write(const void* lpBuf, UINT nCount);
  1425.     virtual void LockRange(DWORD dwPos, DWORD dwCount);
  1426.     virtual void UnlockRange(DWORD dwPos, DWORD dwCount);
  1427.     virtual void Abort();
  1428.     virtual void Flush();
  1429.     virtual void Close();
  1430.  
  1431. protected:
  1432.     CString m_strStorageName;
  1433. };
  1434.  
  1435. /////////////////////////////////////////////////////////////////////////////
  1436. // COleDropSource (advanced drop source support)
  1437.  
  1438. class COleDropSource : public CCmdTarget
  1439. {
  1440. // Constructors
  1441. public:
  1442.     COleDropSource();
  1443.  
  1444. // Overridables
  1445.     virtual SCODE QueryContinueDrag(BOOL bEscapePressed, DWORD dwKeyState);
  1446.     virtual SCODE GiveFeedback(DROPEFFECT dropEffect);
  1447.     virtual BOOL OnBeginDrag(CWnd* pWnd);
  1448.  
  1449. // Implementation
  1450. public:
  1451. #ifdef _DEBUG
  1452.     virtual void Dump(CDumpContext& dc) const;
  1453. #endif
  1454.  
  1455. public:
  1456.     BEGIN_INTERFACE_PART(DropSource, IDropSource)
  1457.         INIT_INTERFACE_PART(COleDropSource, DropSource)
  1458.         STDMETHOD(QueryContinueDrag)(BOOL, DWORD);
  1459.         STDMETHOD(GiveFeedback)(DWORD);
  1460.     END_INTERFACE_PART(DropSource)
  1461.  
  1462.     DECLARE_INTERFACE_MAP()
  1463.  
  1464.     CRect m_rectStartDrag;  // when mouse leaves this rect, drag drop starts
  1465.     BOOL m_bDragStarted;    // has drag really started yet?
  1466.     DWORD m_dwButtonCancel; // which button will cancel (going down)
  1467.     DWORD m_dwButtonDrop;   // which button will confirm (going up)
  1468.  
  1469.     // metrics for drag start determination
  1470.     static AFX_DATA UINT nDragMinDist;  // min. amount mouse must move for drag
  1471.     static AFX_DATA UINT nDragDelay;    // delay before drag starts
  1472.  
  1473.     friend class COleDataSource;
  1474. };
  1475.  
  1476. /////////////////////////////////////////////////////////////////////////////
  1477. // COleDropTarget (advanced drop target support)
  1478.  
  1479. class COleDropTarget : public CCmdTarget
  1480. {
  1481. // Constructors
  1482. public:
  1483.     COleDropTarget();
  1484.  
  1485. // Operations
  1486.     BOOL Register(CWnd* pWnd);
  1487.     virtual void Revoke();  // virtual for implementation
  1488.  
  1489. // Overridables
  1490.     virtual DROPEFFECT OnDragEnter(CWnd* pWnd, COleDataObject* pDataObject,
  1491.         DWORD dwKeyState, CPoint point);
  1492.     virtual DROPEFFECT OnDragOver(CWnd* pWnd, COleDataObject* pDataObject,
  1493.         DWORD dwKeyState, CPoint point);
  1494.     virtual BOOL OnDrop(CWnd* pWnd, COleDataObject* pDataObject,
  1495.         DROPEFFECT dropEffect, CPoint point);
  1496.     virtual DROPEFFECT OnDropEx(CWnd* pWnd, COleDataObject* pDataObject,
  1497.         DROPEFFECT dropDefault, DROPEFFECT dropList, CPoint point);
  1498.     virtual void OnDragLeave(CWnd* pWnd);
  1499.     virtual DROPEFFECT OnDragScroll(CWnd* pWnd, DWORD dwKeyState,
  1500.         CPoint point);
  1501.  
  1502. // Implementation
  1503. public:
  1504.     virtual ~COleDropTarget();
  1505. #ifdef _DEBUG
  1506.     virtual void AssertValid() const;
  1507.     virtual void Dump(CDumpContext& dc) const;
  1508. #endif
  1509.  
  1510. protected:
  1511.     HWND m_hWnd;            // HWND this IDropTarget is attached to
  1512.     LPDATAOBJECT m_lpDataObject;    // != NULL between OnDragEnter, OnDragLeave
  1513.     UINT m_nTimerID;        // != MAKEWORD(-1, -1) when in scroll area
  1514.     DWORD m_dwLastTick;     // only valid when m_nTimerID valid
  1515.     UINT m_nScrollDelay;    // time to next scroll
  1516.  
  1517.     // metrics for drag-scrolling
  1518.     static AFX_DATA int nScrollInset;
  1519.     static AFX_DATA UINT nScrollDelay;
  1520.     static AFX_DATA UINT nScrollInterval;
  1521.  
  1522.     // implementation helpers
  1523.     void SetupTimer(CView* pView, UINT nTimerID);
  1524.     void CancelTimer(CWnd* pWnd);
  1525.  
  1526. // Interface Maps
  1527. public:
  1528.     BEGIN_INTERFACE_PART(DropTarget, IDropTarget)
  1529.         INIT_INTERFACE_PART(COleDropTarget, DropTarget)
  1530.         STDMETHOD(DragEnter)(LPDATAOBJECT, DWORD, POINTL, LPDWORD);
  1531.         STDMETHOD(DragOver)(DWORD, POINTL, LPDWORD);
  1532.         STDMETHOD(DragLeave)();
  1533.         STDMETHOD(Drop)(LPDATAOBJECT, DWORD, POINTL pt, LPDWORD);
  1534.     END_INTERFACE_PART(DropTarget)
  1535.  
  1536.     DECLARE_INTERFACE_MAP()
  1537. };
  1538.  
  1539. /////////////////////////////////////////////////////////////////////////////
  1540. // COleMessageFilter (implements IMessageFilter)
  1541.  
  1542. class COleMessageFilter : public CCmdTarget
  1543. {
  1544. // Constructors
  1545. public:
  1546.     COleMessageFilter();
  1547.  
  1548. // Operations
  1549.     BOOL Register();
  1550.     void Revoke();
  1551.  
  1552.     // for controlling the busy state of the server application (called app)
  1553.     virtual void BeginBusyState();
  1554.     virtual void EndBusyState();
  1555.     void SetBusyReply(SERVERCALL nBusyReply);
  1556.  
  1557.     // for controlling actions taken against rejected/retried calls
  1558.     void SetRetryReply(DWORD nRetryReply = 0);
  1559.         // only used when the "not responding" dialog is disabled
  1560.     void SetMessagePendingDelay(DWORD nTimeout = 5000);
  1561.         // used to determine amount of time before significant message
  1562.     void EnableBusyDialog(BOOL bEnableBusy = TRUE);
  1563.     void EnableNotRespondingDialog(BOOL bEnableNotResponding = TRUE);
  1564.         // used to enable/disable the two types of busy dialogs
  1565.  
  1566. // Overridables
  1567.     virtual BOOL OnMessagePending(const MSG* pMsg);
  1568.         // return TRUE to eat the message (usually only if processed)
  1569.  
  1570. // Implementation
  1571. public:
  1572. #ifdef _DEBUG
  1573.     virtual void AssertValid() const;
  1574.     virtual void Dump(CDumpContext& dc) const;
  1575. #endif
  1576.     virtual ~COleMessageFilter();
  1577.     virtual BOOL IsSignificantMessage(MSG* pMsg);
  1578.         // determine if any significant messages are present in the queue
  1579.     virtual int OnBusyDialog(HTASK htaskBusy);
  1580.     virtual int OnNotRespondingDialog(HTASK htaskBusy);
  1581.         // these functions display the busy dialog
  1582.  
  1583. protected:
  1584.     BOOL m_bRegistered;
  1585.     LONG m_nBusyCount;  // for BeginBusyState & EndBusyState
  1586.     BOOL m_bEnableBusy;
  1587.     BOOL m_bEnableNotResponding;
  1588.     BOOL m_bUnblocking;
  1589.     DWORD m_nRetryReply;    // only used if m_bEnableNotResponding == FALSE
  1590.     DWORD m_nBusyReply;
  1591.     DWORD m_nTimeout;
  1592.  
  1593. // Interface Maps
  1594. public:
  1595.     BEGIN_INTERFACE_PART(MessageFilter, IMessageFilter)
  1596.         INIT_INTERFACE_PART(COleMessageFilter, MessageFilter)
  1597.         STDMETHOD_(DWORD, HandleInComingCall)(DWORD, HTASK, DWORD,
  1598.             LPINTERFACEINFO);
  1599.         STDMETHOD_(DWORD, RetryRejectedCall)(HTASK, DWORD, DWORD);
  1600.         STDMETHOD_(DWORD, MessagePending)(HTASK, DWORD, DWORD);
  1601.     END_INTERFACE_PART(MessageFilter)
  1602.  
  1603.     DECLARE_INTERFACE_MAP()
  1604. };
  1605.  
  1606. /////////////////////////////////////////////////////////////////////////////
  1607. // message map entries for OLE verbs
  1608.  
  1609. #define ON_STDOLEVERB(iVerb, memberFxn) \
  1610.     { 0xC002, 0, (UINT)iVerb, (UINT)iVerb, (UINT)-1, \
  1611.         (AFX_PMSG)(BOOL (AFX_MSG_CALL CCmdTarget::*)(LPMSG, HWND, LPCRECT))memberFxn },
  1612.  
  1613. #define ON_OLEVERB(idsVerbName, memberFxn) \
  1614.     { 0xC002, 0, 1, 1, idsVerbName, \
  1615.         (AFX_PMSG)(BOOL (AFX_MSG_CALL CCmdTarget::*)(LPMSG, HWND, LPCRECT))memberFxn },
  1616.  
  1617. /////////////////////////////////////////////////////////////////////////////
  1618. // global helpers and debugging
  1619.  
  1620. void AFXAPI AfxOleSetEditMenu(COleClientItem* pClient, CMenu* pMenu,
  1621.     UINT iMenuItem, UINT nIDVerbMin, UINT nIDVerbMax = 0, UINT nIDConvert = 0);
  1622.  
  1623. #ifdef _DEBUG
  1624. // Mapping SCODEs to readable text
  1625. LPCTSTR AFXAPI AfxGetFullScodeString(SCODE sc);
  1626. LPCTSTR AFXAPI AfxGetScodeString(SCODE sc);
  1627. LPCTSTR AFXAPI AfxGetScodeRangeString(SCODE sc);
  1628. LPCTSTR AFXAPI AfxGetSeverityString(SCODE sc);
  1629. LPCTSTR AFXAPI AfxGetFacilityString(SCODE sc);
  1630.  
  1631. // Mapping IIDs to readable text
  1632. LPCTSTR AFXAPI AfxGetIIDString(REFIID iid);
  1633. #endif
  1634.  
  1635. /////////////////////////////////////////////////////////////////////////////
  1636. // Inline function declarations
  1637.  
  1638. #ifdef _AFX_PACKING
  1639. #pragma pack(pop)
  1640. #endif
  1641.  
  1642. #ifdef _AFX_ENABLE_INLINES
  1643. #define _AFXOLE_INLINE inline
  1644. #define _AFXOLECLI_INLINE inline
  1645. #define _AFXOLESVR_INLINE inline
  1646. #define _AFXOLEDOBJ_INLINE inline
  1647. #include <afxole.inl>
  1648. #undef _AFXOLE_INLINE
  1649. #undef _AFXOLECLI_INLINE
  1650. #undef _AFXOLEDOBJ_INLINE
  1651. #undef _AFXOLESVR_INLINE
  1652. #endif
  1653.  
  1654. #undef AFX_DATA
  1655. #define AFX_DATA
  1656.  
  1657. #ifdef _AFX_MINREBUILD
  1658. #pragma component(minrebuild, on)
  1659. #endif
  1660. #ifndef _AFX_FULLTYPEINFO
  1661. #pragma component(mintypeinfo, off)
  1662. #endif
  1663.  
  1664. #endif //__AFXOLE_H__
  1665.  
  1666. /////////////////////////////////////////////////////////////////////////////
  1667.