开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 查看源码
PATRON.H
资源名称：MSDN_VC98.zip　[点击查看]
上传用户：bangxh
上传日期：2007-01-31
资源大小：42235k
文件大小：15k
源码类别：

Windows编程

开发平台：

Visual C++

PATRON.H：源码内容
  1. /*
  2.  * PATRON.H
  3.  * Patron Chapter 22
  4.  *
  5.  * Single include file that pulls in everything needed for other
  6.  * source files in the application.
  7.  *
  8.  * Copyright (c)1993-1995 Microsoft Corporation, All Rights Reserved
  9.  *
  10.  * Kraig Brockschmidt, Microsoft
  11.  * Internet  :  kraigb@microsoft.com
  12.  * Compuserve:  >INTERNET:kraigb@microsoft.com
  13.  */
  16. #ifndef _PATRON_H_
  17. #define _PATRON_H_
  19. #define INC_CLASSLIB
  20. #define INC_OLEUI
  21. //CHAPTER22MOD
  22. #define CHAPTER22
  23. //End CHAPTER22MOD
  24. #include <inole.h>
  25. #include "resource.h"
  27. //Get editor window information
  28. #include "pages.h"
  31. /*
  32.  * UINT value such that adding one produces zero.  Portable to Win32.
  33.  * This is used to represent a non-existent zero-based UINT value
  34.  */
  35. #define NOVALUE                     ((UINT)-1)
  38. //PATRON.CPP:  Frame object that creates a main window
  40. //CHAPTER22MOD
  41. class CPatronFrame : public CFrame, public IOleInPlaceFrame
  42. //End CHAPTER22MOD
  43.     {
  44.     //For access to m_pCL for document creation
  45.     friend class CLinkClassFactory;
  47.     private:
  48.         BOOL            m_fInitialized;     //OleInitialize worked
  49.         LPCLASSFACTORY  m_pIClassDataTran;  //For locking.
  50.         PCDocument      m_pDocCreated;      //What class factory makes
  51.         BOOL            m_fEmbedding;       //-Embedding on command line?
  52.         DWORD           m_dwRegCO;          //From CoRegisterClassObject
  53.         LPCLASSFACTORY  m_pIClassFactory;
  55.         //CHAPTER22MOD
  56.         DWORD           m_cRef;
  57.         HMENU           m_hMenuOrg;         //Original menu
  58.         HMENU           m_hMenuTop;
  59.         HWND            m_hWndObj;          //Object window
  60.         BOOL            m_fOurToolsShowing; //Our tools up?
  62.         int             m_cyTop;            //In-place tool allocations
  63.         int             m_cyBottom;
  64.         int             m_cxLeft;
  65.         int             m_cxRight;
  67.         BOOL            m_fInContextHelp;   //In context help mode?
  69.         LPOLEINPLACEACTIVEOBJECT    m_pIOleIPActiveObject;
  70.         //End CHAPTER22MOD
  72.     //CHAPTER22MOD
  73.     //This is for access from IOleInPlaceSite::GetWindowContext
  74.     public:
  75.         HACCEL          m_hAccelIP;         //Accelerators for in-place
  76.     //End CHAPTER22MOD
  78.     protected:
  79.         //Overridable for creating a CPatronClient
  80.         virtual PCClient    CreateCClient(void);
  82.         virtual BOOL        FMessageHook(HWND, UINT, WPARAM, LPARAM
  83.                                 , LRESULT *);
  85.         virtual BOOL        PreShowInit(void);
  86.         virtual BOOL        RegisterAllClasses(void);
  87.         virtual UINT        CreateToolbar(void);
  88.         virtual LRESULT     OnCommand(HWND, WPARAM, LPARAM);
  90.     public:
  91.         CPatronFrame(HINSTANCE, HINSTANCE, LPSTR, int);
  92.         virtual ~CPatronFrame(void);
  94.         //Overrides
  95.         virtual BOOL        Init(PFRAMEINIT);
  97.         //CHAPTER22MOD
  98.         virtual WPARAM      MessageLoop(void);
  99.         //End CHAPTER22MOD
  101.         virtual void        UpdateMenus(HMENU, UINT);
  102.         virtual void        UpdateToolbar(void);
  104.         //CHAPTER22MOD
  105.         void                ShowUIAndTools(BOOL, BOOL);
  106.         void                ReinstateUI(void);
  108.         //IOleInPlaceFrame implementation
  109.         STDMETHODIMP         QueryInterface(REFIID, PPVOID);
  110.         STDMETHODIMP_(ULONG) AddRef(void);
  111.         STDMETHODIMP_(ULONG) Release(void);
  113.         STDMETHODIMP         GetWindow(HWND *);
  114.         STDMETHODIMP         ContextSensitiveHelp(BOOL);
  115.         STDMETHODIMP         GetBorder(LPRECT);
  116.         STDMETHODIMP         RequestBorderSpace(LPCBORDERWIDTHS);
  117.         STDMETHODIMP         SetBorderSpace(LPCBORDERWIDTHS);
  118.         STDMETHODIMP         SetActiveObject(LPOLEINPLACEACTIVEOBJECT
  119.                                  , LPCOLESTR);
  120.         STDMETHODIMP         InsertMenus(HMENU, LPOLEMENUGROUPWIDTHS);
  121.         STDMETHODIMP         SetMenu(HMENU, HOLEMENU, HWND);
  122.         STDMETHODIMP         RemoveMenus(HMENU);
  123.         STDMETHODIMP         SetStatusText(LPCOLESTR);
  124.         STDMETHODIMP         EnableModeless(BOOL);
  125.         STDMETHODIMP         TranslateAccelerator(LPMSG, WORD);
  126.         //End CHAPTER22MOD
  127.     };
  130. typedef CPatronFrame *PCPatronFrame;
  133. //These are global for simplification of object implementation.
  134. extern ULONG g_cObj;
  135. extern ULONG g_cLock;
  136. extern HWND  g_hWnd;
  138. //CHAPTER22MOD
  139. extern PCPatronFrame  g_pFR;
  140. //End CHAPTER22MOD
  142. //Function for the object to notify on destruction.
  143. void ObjectDestroyed(void);
  146. //ICLASSF.CPP
  148. class CLinkClassFactory : public IClassFactory
  149.     {
  150.     protected:
  151.         ULONG           m_cRef;
  152.         PCPatronFrame   m_pFR;          //For document creation.
  154.     public:
  155.         CLinkClassFactory(PCPatronFrame);
  156.         ~CLinkClassFactory(void);
  158.         //IUnknown members
  159.         STDMETHODIMP         QueryInterface(REFIID, PPVOID);
  160.         STDMETHODIMP_(ULONG) AddRef(void);
  161.         STDMETHODIMP_(ULONG) Release(void);
  163.         //IClassFactory members
  164.         STDMETHODIMP         CreateInstance(LPUNKNOWN, REFIID
  165.                                  , PPVOID);
  166.         STDMETHODIMP         LockServer(BOOL);
  167.     };
  169. typedef CLinkClassFactory *PCLinkClassFactory;
  174. //CLIENT.CPP
  176. /*
  177.  * The only reason we have a derived class here is to override
  178.  * CreateCDocument so we can create our own type as well as
  179.  * overriding NewDocument to perform one other piece of work once
  180.  * the document's been created.
  181.  */
  183. class CPatronClient : public CClient
  184.     {
  185.     protected:
  186.         //Overridable for creating a new CDocument
  187.         virtual PCDocument CreateCDocument(void);
  189.     public:
  190.         CPatronClient(HINSTANCE, PCFrame);
  191.         virtual ~CPatronClient(void);
  193.         //CHAPTER22MOD
  194.         //This is added to handle IOleInPlaceFrame::SetMenu
  195.         void         SetMenu(HWND, HMENU, HMENU);
  196.         void         MoveWithoutFamily(LPRECT, int, int);
  197.         void         CallContextHelpOnDocuments(BOOL);
  198.         //End CHAPTER22MOD
  199.     };
  202. typedef CPatronClient *PCPatronClient;
  207. //DOCUMENT.CPP
  209. //Constant ID for the pages window that lives in a document window
  210. #define ID_PAGES            723
  213. class CImpIPersistFile;
  214. typedef class CImpIPersistFile *PCImpIPersistFile;
  215. class CImpIOleItemContainer;
  216. typedef class CImpIOleItemContainer *PCImpIOleItemContainer;
  217. //CHAPTER22MOD
  218. class CImpIOleInPlaceUIWindow;
  219. typedef class CImpIOleInPlaceUIWindow *PCImpIOleInPlaceUIWindow;
  220. //End CHAPTER22MOD
  222. /*
  223.  * To support linking to embeddings, the document needs to have
  224.  * IPersistFile and IOleItemContainer interfaces, so we multiply
  225.  * inherit from IUnknown and provide two interface implementations.
  226.  */
  228. class CPatronDoc : public CDocument, public IUnknown
  229.     {
  230.     //These need access to FQueryPasteFromData, PasteFromData
  231.     friend class CDropTarget;
  232.     friend class CDropSource;
  233.     friend class CImpIPersistFile;
  234.     friend class CImpIOleItemContainer;
  235.     //CHAPTER22MOD
  236.     friend class CImpIOleInPlaceUIWindow;
  237.     //End CHAPTER22MOD
  239.     protected:
  240.         LONG            m_lVer;         //Loaded data version
  241.         PCPages         m_pPG;          //Pages window in us
  242.         LPSTORAGE       m_pIStorage;    //Root storage for document
  243.         BOOL            m_fPrintSetup;
  245.         class CDropTarget *m_pDropTarget;   //Registered target
  247.         UINT            m_cfEmbeddedObject; //Clipboard formats
  248.         UINT            m_cfObjectDescriptor;
  249.         UINT            m_cfLinkSource;
  250.         UINT            m_cfLinkSrcDescriptor;
  251.         BOOL            m_fShowTypes;       //Show Objects active?
  253.         ULONG               m_cRef;
  254.         BOOL                m_fRename;          //Rename on Save?
  255.         DWORD               m_dwRegROT;
  256.         DWORD               m_dwRegROTWild;
  258.         PCImpIPersistFile       m_pImpIPersistFile;
  259.         PCImpIOleItemContainer  m_pImpIOleItemContainer;
  261.         //CHAPTER22MOD
  262.         PCImpIOleInPlaceUIWindow m_pImpIOleIPUIWindow;  //Ours
  263.         LPOLEINPLACEACTIVEOBJECT m_pIOleIPActiveObject; //Object's
  264.         BOOL                     m_fNoObjectFrameTools;
  265.         //End CHAPTER22MOD
  267.     protected:
  268.         virtual BOOL    FMessageHook(HWND, UINT, WPARAM, LPARAM
  269.             , LRESULT *);
  271.         BOOL            FQueryPasteFromData(LPDATAOBJECT
  272.                             , LPFORMATETC, PTENANTTYPE);
  273.         BOOL            FQueryPasteLinkFromData(LPDATAOBJECT
  274.                             , LPFORMATETC, PTENANTTYPE);
  275.         BOOL            PasteFromData(LPDATAOBJECT, LPFORMATETC
  276.                             , TENANTTYPE, PPATRONOBJECT, DWORD
  277.                             , BOOL);
  279.     public:
  280.         CPatronDoc(HINSTANCE, PCFrame, PCDocumentAdviseSink);
  281.         virtual ~CPatronDoc(void);
  283.         //We now need our ubiquitous set of IUnknown members.
  284.         STDMETHODIMP         QueryInterface(REFIID, PPVOID);
  285.         STDMETHODIMP_(ULONG) AddRef(void);
  286.         STDMETHODIMP_(ULONG) Release(void);
  288.         virtual BOOL    Init(PDOCUMENTINIT);
  289.         virtual void    Clear(void);
  291.         virtual BOOL    FDirtySet(BOOL);
  292.         virtual BOOL    FDirtyGet(void);
  293.         virtual void    Delete(void);
  294.         virtual BOOL    FQueryPrinterSetup(void);
  295.         virtual BOOL    FQueryObjectSelected(HMENU);
  297.         virtual UINT    Load(BOOL, LPTSTR);
  298.         virtual UINT    Save(UINT, LPTSTR);
  300.         virtual BOOL    Print(HWND);
  301.         virtual UINT    PrinterSetup(HWND, BOOL);
  303.         virtual BOOL    Clip(HWND, BOOL);
  304.         virtual BOOL    FQueryPaste(void);
  305.         virtual BOOL    Paste(HWND);
  306.         virtual BOOL    PasteSpecial(HWND);
  307.         virtual BOOL    FQueryEnableEditLinks(void);
  308.         virtual BOOL    EditLinks(HWND);
  309.         virtual BOOL    ShowOrQueryObjectTypes(BOOL, BOOL);
  311.         virtual UINT    NewPage(void);
  312.         virtual UINT    DeletePage(void);
  313.         virtual UINT    NextPage(void);
  314.         virtual UINT    PreviousPage(void);
  315.         virtual UINT    FirstPage(void);
  316.         virtual UINT    LastPage(void);
  318.         virtual void    Rename(LPTSTR);
  319.         virtual BOOL    InsertObject(HWND);
  320.         //CHAPTER22MOD
  321.         virtual void    ActivateObject(LONG, LPMSG);
  322.         virtual BOOL    NoObjectFrameTools(BOOL, BOOL);
  323.         //End CHAPTER22MOD
  324.         virtual BOOL    ConvertObject(HWND);
  326.     };
  328. typedef CPatronDoc *PCPatronDoc;
  330. //Hook for Print Dialog to hide Setup... button
  331. UINT CALLBACK PrintDlgHook(HWND, UINT, WPARAM, LPARAM);
  334. //IPersistFile implementation for CPatronDoc
  336. class CImpIPersistFile : public IPersistFile
  337.     {
  338.     protected:
  339.         ULONG               m_cRef;      //Interface reference count
  340.         PCPatronDoc         m_pDoc;      //Back pointer to the object
  341.         LPUNKNOWN           m_pUnkOuter; //Controlling unknown
  343.     public:
  344.         CImpIPersistFile(PCPatronDoc, LPUNKNOWN);
  345.         ~CImpIPersistFile(void);
  347.         STDMETHODIMP QueryInterface(REFIID, PPVOID);
  348.         STDMETHODIMP_(ULONG) AddRef(void);
  349.         STDMETHODIMP_(ULONG) Release(void);
  351.         STDMETHODIMP GetClassID(LPCLSID);
  353.         STDMETHODIMP IsDirty(void);
  354.         STDMETHODIMP Load(LPCOLESTR, DWORD);
  355.         STDMETHODIMP Save(LPCOLESTR, BOOL);
  356.         STDMETHODIMP SaveCompleted(LPCOLESTR);
  357.         STDMETHODIMP GetCurFile(LPOLESTR *);
  358.     };
  362. /*
  363.  * IOleItemContainer implementation for both CPatronDoc and CPage,
  364.  * therefore have two back pointers.
  365.  */
  367. class CImpIOleItemContainer : public IOleItemContainer
  368.     {
  369.     protected:
  370.         ULONG               m_cRef;
  371.         class CPage        *m_pPage;
  372.         PCPatronDoc         m_pDoc;      //Convenient naming & types
  373.         LPUNKNOWN           m_pUnkOuter;
  374.         BOOL                m_fDoc;      //Document or page?
  376.     private:
  377.         BOOL         TenantFromName(LPOLESTR, PCTenant *);
  379.     public:
  380.         CImpIOleItemContainer(LPVOID, LPUNKNOWN, BOOL);
  381.         ~CImpIOleItemContainer(void);
  383.         STDMETHODIMP QueryInterface(REFIID, PPVOID);
  384.         STDMETHODIMP_(ULONG) AddRef(void);
  385.         STDMETHODIMP_(ULONG) Release(void);
  387.         STDMETHODIMP ParseDisplayName(LPBC, LPOLESTR, ULONG *
  388.             , LPMONIKER *);
  389.         STDMETHODIMP EnumObjects(DWORD, LPENUMUNKNOWN *);
  390.         STDMETHODIMP LockContainer(BOOL);
  391.         STDMETHODIMP GetObject(LPOLESTR, DWORD, LPBINDCTX, REFIID
  392.             , PPVOID);
  393.         STDMETHODIMP GetObjectStorage(LPOLESTR, LPBINDCTX, REFIID
  394.             , PPVOID);
  395.         STDMETHODIMP IsRunning(LPOLESTR);
  396.     };
  400. //CHAPTER22MOD
  401. //This goes on the document.
  403. class CImpIOleInPlaceUIWindow : public IOleInPlaceUIWindow
  404.     {
  405.     protected:
  406.         ULONG               m_cRef;
  407.         PCPatronDoc         m_pDoc;
  408.         LPUNKNOWN           m_pUnkOuter;
  410.     public:
  411.         CImpIOleInPlaceUIWindow(PCPatronDoc, LPUNKNOWN);
  412.         ~CImpIOleInPlaceUIWindow(void);
  414.         STDMETHODIMP QueryInterface(REFIID, PPVOID);
  415.         STDMETHODIMP_(ULONG) AddRef(void);
  416.         STDMETHODIMP_(ULONG) Release(void);
  418.         STDMETHODIMP GetWindow(HWND *);
  419.         STDMETHODIMP ContextSensitiveHelp(BOOL);
  420.         STDMETHODIMP GetBorder(LPRECT);
  421.         STDMETHODIMP RequestBorderSpace(LPCBORDERWIDTHS);
  422.         STDMETHODIMP SetBorderSpace(LPCBORDERWIDTHS);
  423.         STDMETHODIMP SetActiveObject(LPOLEINPLACEACTIVEOBJECT
  424.                          , LPCOLESTR);
  425.     };
  426. //End CHAPTER22MOD
  433. //Drag-drop objects we need in the document
  435. class CDropTarget : public IDropTarget
  436.     {
  437.     protected:
  438.         ULONG               m_cRef;
  439.         PCPatronDoc         m_pDoc;
  441.         LPDATAOBJECT        m_pIDataObject;  //From DragEnter
  442.         BOOL                m_fPendingRepaint;
  443.         POINTL              m_ptPick;        //Pick-up offsets
  444.         POINTL              m_ptLast;        //Last drag point
  445.         SIZEL               m_szl;           //Object size
  446.         BOOL                m_fFeedback;     //Draw feedback?
  447.         FORMATETC           m_fe;            //Real dropping format
  449.     public:
  450.         CDropTarget(PCPatronDoc);
  451.         ~CDropTarget(void);
  453.         //IDropTarget interface members
  454.         STDMETHODIMP QueryInterface(REFIID, PPVOID);
  455.         STDMETHODIMP_(ULONG) AddRef(void);
  456.         STDMETHODIMP_(ULONG) Release(void);
  458.         STDMETHODIMP DragEnter(LPDATAOBJECT, DWORD, POINTL,LPDWORD);
  459.         STDMETHODIMP DragOver(DWORD, POINTL, LPDWORD);
  460.         STDMETHODIMP DragLeave(void);
  461.         STDMETHODIMP Drop(LPDATAOBJECT, DWORD, POINTL, LPDWORD);
  462.     };
  465. typedef CDropTarget *PCDropTarget;
  468. class CDropSource : public IDropSource
  469.     {
  470.     protected:
  471.         ULONG               m_cRef;
  473.     public:
  474.         CDropSource(void);
  475.         ~CDropSource(void);
  477.         //IDropSource interface members
  478.         STDMETHODIMP QueryInterface(REFIID, PPVOID);
  479.         STDMETHODIMP_(ULONG) AddRef(void);
  480.         STDMETHODIMP_(ULONG) Release(void);
  482.         STDMETHODIMP QueryContinueDrag(BOOL, DWORD);
  483.         STDMETHODIMP GiveFeedback(DWORD);
  484.     };
  486. typedef CDropSource *PCDropSource;
  489. #endif //_PATRON_H_