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

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

Windows编程

开发平台：

Visual C++

PATRON.H：源码内容
  1. /*
  2.  * PATRON.H
  3.  * Patron Chapter 24
  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. //CHAPTER24MOD
  22. #define INC_AUTOMATION
  23. #define INC_CONTROLS
  24. #define CHAPTER24
  25. //End CHAPTER24MOD
  26. #include <inole.h>
  27. #include "resource.h"
  29. //Get editor window information
  30. #include "pages.h"
  33. /*
  34.  * UINT value such that adding one produces zero.  Portable to Win32.
  35.  * This is used to represent a non-existent zero-based UINT value
  36.  */
  37. #define NOVALUE                     ((UINT)-1)
  40. //PATRON.CPP:  Frame object that creates a main window
  42. class CPatronFrame : public CFrame, public IOleInPlaceFrame
  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.         DWORD           m_cRef;
  56.         HMENU           m_hMenuOrg;         //Original menu
  57.         HMENU           m_hMenuTop;
  58.         HWND            m_hWndObj;          //Object window
  59.         BOOL            m_fOurToolsShowing; //Our tools up?
  61.         int             m_cyTop;            //In-place tool allocations
  62.         int             m_cyBottom;
  63.         int             m_cxLeft;
  64.         int             m_cxRight;
  66.         BOOL            m_fInContextHelp;   //In context help mode?
  68.         LPOLEINPLACEACTIVEOBJECT    m_pIOleIPActiveObject;
  70.     //This is for access from IOleInPlaceSite::GetWindowContext
  71.     public:
  72.         HACCEL          m_hAccelIP;         //Accelerators for in-place
  74.     protected:
  75.         //Overridable for creating a CPatronClient
  76.         virtual PCClient    CreateCClient(void);
  78.         virtual BOOL        FMessageHook(HWND, UINT, WPARAM, LPARAM
  79.                                 , LRESULT *);
  81.         virtual BOOL        PreShowInit(void);
  82.         virtual BOOL        RegisterAllClasses(void);
  83.         virtual UINT        CreateToolbar(void);
  84.         virtual LRESULT     OnCommand(HWND, WPARAM, LPARAM);
  86.     public:
  87.         CPatronFrame(HINSTANCE, HINSTANCE, LPSTR, int);
  88.         virtual ~CPatronFrame(void);
  90.         //Overrides
  91.         virtual BOOL        Init(PFRAMEINIT);
  92.         virtual WPARAM      MessageLoop(void);
  93.         virtual void        UpdateMenus(HMENU, UINT);
  94.         virtual void        UpdateToolbar(void);
  96.         void                ShowUIAndTools(BOOL, BOOL);
  97.         void                ReinstateUI(void);
  99.         //IOleInPlaceFrame implementation
  100.         STDMETHODIMP         QueryInterface(REFIID, PPVOID);
  101.         STDMETHODIMP_(ULONG) AddRef(void);
  102.         STDMETHODIMP_(ULONG) Release(void);
  104.         STDMETHODIMP         GetWindow(HWND *);
  105.         STDMETHODIMP         ContextSensitiveHelp(BOOL);
  106.         STDMETHODIMP         GetBorder(LPRECT);
  107.         STDMETHODIMP         RequestBorderSpace(LPCBORDERWIDTHS);
  108.         STDMETHODIMP         SetBorderSpace(LPCBORDERWIDTHS);
  109.         STDMETHODIMP         SetActiveObject(LPOLEINPLACEACTIVEOBJECT
  110.                                  , LPCOLESTR);
  111.         STDMETHODIMP         InsertMenus(HMENU, LPOLEMENUGROUPWIDTHS);
  112.         STDMETHODIMP         SetMenu(HMENU, HOLEMENU, HWND);
  113.         STDMETHODIMP         RemoveMenus(HMENU);
  114.         STDMETHODIMP         SetStatusText(LPCOLESTR);
  115.         STDMETHODIMP         EnableModeless(BOOL);
  116.         STDMETHODIMP         TranslateAccelerator(LPMSG, WORD);
  117.     };
  120. typedef CPatronFrame *PCPatronFrame;
  123. //These are global for simplification of object implementation.
  124. extern ULONG g_cObj;
  125. extern ULONG g_cLock;
  126. extern HWND  g_hWnd;
  128. extern PCPatronFrame  g_pFR;
  130. //Function for the object to notify on destruction.
  131. void ObjectDestroyed(void);
  134. //ICLASSF.CPP
  136. class CLinkClassFactory : public IClassFactory
  137.     {
  138.     protected:
  139.         ULONG           m_cRef;
  140.         PCPatronFrame   m_pFR;          //For document creation.
  142.     public:
  143.         CLinkClassFactory(PCPatronFrame);
  144.         ~CLinkClassFactory(void);
  146.         //IUnknown members
  147.         STDMETHODIMP         QueryInterface(REFIID, PPVOID);
  148.         STDMETHODIMP_(ULONG) AddRef(void);
  149.         STDMETHODIMP_(ULONG) Release(void);
  151.         //IClassFactory members
  152.         STDMETHODIMP         CreateInstance(LPUNKNOWN, REFIID
  153.                                  , PPVOID);
  154.         STDMETHODIMP         LockServer(BOOL);
  155.     };
  157. typedef CLinkClassFactory *PCLinkClassFactory;
  162. //CLIENT.CPP
  164. /*
  165.  * The only reason we have a derived class here is to override
  166.  * CreateCDocument so we can create our own type as well as
  167.  * overriding NewDocument to perform one other piece of work once
  168.  * the document's been created.
  169.  */
  171. class CPatronClient : public CClient
  172.     {
  173.     protected:
  174.         //Overridable for creating a new CDocument
  175.         virtual PCDocument CreateCDocument(void);
  177.     public:
  178.         CPatronClient(HINSTANCE, PCFrame);
  179.         virtual ~CPatronClient(void);
  181.         //This is added to handle IOleInPlaceFrame::SetMenu
  182.         void         SetMenu(HWND, HMENU, HMENU);
  183.         void         MoveWithoutFamily(LPRECT, int, int);
  184.         void         CallContextHelpOnDocuments(BOOL);
  185.     };
  188. typedef CPatronClient *PCPatronClient;
  193. //DOCUMENT.CPP
  195. //Constant ID for the pages window that lives in a document window
  196. #define ID_PAGES            723
  199. class CImpIPersistFile;
  200. typedef class CImpIPersistFile *PCImpIPersistFile;
  201. class CImpIOleItemContainer;
  202. typedef class CImpIOleItemContainer *PCImpIOleItemContainer;
  203. class CImpIOleInPlaceUIWindow;
  204. typedef class CImpIOleInPlaceUIWindow *PCImpIOleInPlaceUIWindow;
  206. /*
  207.  * To support linking to embeddings, the document needs to have
  208.  * IPersistFile and IOleItemContainer interfaces, so we multiply
  209.  * inherit from IUnknown and provide two interface implementations.
  210.  */
  212. class CPatronDoc : public CDocument, public IUnknown
  213.     {
  214.     //These need access to FQueryPasteFromData, PasteFromData
  215.     friend class CDropTarget;
  216.     friend class CDropSource;
  217.     friend class CImpIPersistFile;
  218.     friend class CImpIOleItemContainer;
  219.     friend class CImpIOleInPlaceUIWindow;
  221.     protected:
  222.         LONG            m_lVer;         //Loaded data version
  223.         PCPages         m_pPG;          //Pages window in us
  224.         LPSTORAGE       m_pIStorage;    //Root storage for document
  225.         BOOL            m_fPrintSetup;
  227.         class CDropTarget *m_pDropTarget;   //Registered target
  229.         UINT            m_cfEmbeddedObject; //Clipboard formats
  230.         UINT            m_cfObjectDescriptor;
  231.         UINT            m_cfLinkSource;
  232.         UINT            m_cfLinkSrcDescriptor;
  233.         BOOL            m_fShowTypes;       //Show Objects active?
  235.         ULONG               m_cRef;
  236.         BOOL                m_fRename;          //Rename on Save?
  237.         DWORD               m_dwRegROT;
  238.         DWORD               m_dwRegROTWild;
  240.         PCImpIPersistFile       m_pImpIPersistFile;
  241.         PCImpIOleItemContainer  m_pImpIOleItemContainer;
  243.         PCImpIOleInPlaceUIWindow m_pImpIOleIPUIWindow;  //Ours
  244.         LPOLEINPLACEACTIVEOBJECT m_pIOleIPActiveObject; //Object's
  245.         BOOL                     m_fNoObjectFrameTools;
  247.         //CHAPTER24MOD
  248.         BOOL                     m_fDesignMode;
  249.         BOOL                     m_fUIDead;
  250.         BOOL                     m_fHatchHandles;
  251.         //End CHAPTER24MOD
  253.     protected:
  254.         virtual BOOL    FMessageHook(HWND, UINT, WPARAM, LPARAM
  255.             , LRESULT *);
  257.         BOOL            FQueryPasteFromData(LPDATAOBJECT
  258.                             , LPFORMATETC, PTENANTTYPE);
  259.         BOOL            FQueryPasteLinkFromData(LPDATAOBJECT
  260.                             , LPFORMATETC, PTENANTTYPE);
  261.         BOOL            PasteFromData(LPDATAOBJECT, LPFORMATETC
  262.                             , TENANTTYPE, PPATRONOBJECT, DWORD
  263.                             , BOOL);
  265.     public:
  266.         CPatronDoc(HINSTANCE, PCFrame, PCDocumentAdviseSink);
  267.         virtual ~CPatronDoc(void);
  269.         //We now need our ubiquitous set of IUnknown members.
  270.         STDMETHODIMP         QueryInterface(REFIID, PPVOID);
  271.         STDMETHODIMP_(ULONG) AddRef(void);
  272.         STDMETHODIMP_(ULONG) Release(void);
  274.         virtual BOOL    Init(PDOCUMENTINIT);
  275.         virtual void    Clear(void);
  277.         virtual BOOL    FDirtySet(BOOL);
  278.         virtual BOOL    FDirtyGet(void);
  279.         virtual void    Delete(void);
  280.         virtual BOOL    FQueryPrinterSetup(void);
  281.         virtual BOOL    FQueryObjectSelected(HMENU);
  283.         virtual UINT    Load(BOOL, LPTSTR);
  284.         virtual UINT    Save(UINT, LPTSTR);
  286.         virtual BOOL    Print(HWND);
  287.         virtual UINT    PrinterSetup(HWND, BOOL);
  289.         virtual BOOL    Clip(HWND, BOOL);
  290.         virtual BOOL    FQueryPaste(void);
  291.         virtual BOOL    Paste(HWND);
  292.         virtual BOOL    PasteSpecial(HWND);
  293.         virtual BOOL    FQueryEnableEditLinks(void);
  294.         virtual BOOL    EditLinks(HWND);
  295.         virtual BOOL    ShowOrQueryObjectTypes(BOOL, BOOL);
  297.         virtual UINT    NewPage(void);
  298.         virtual UINT    DeletePage(void);
  299.         virtual UINT    NextPage(void);
  300.         virtual UINT    PreviousPage(void);
  301.         virtual UINT    FirstPage(void);
  302.         virtual UINT    LastPage(void);
  304.         virtual void    Rename(LPTSTR);
  305.         virtual BOOL    InsertObject(HWND);
  306.         virtual void    ActivateObject(LONG, LPMSG);
  307.         virtual BOOL    NoObjectFrameTools(BOOL, BOOL);
  308.         virtual BOOL    ConvertObject(HWND);
  310.         //CHAPTER24MOD
  311.         virtual BOOL    FToggleOrQueryDesignMode(BOOL, BOOL);
  312.         virtual BOOL    FToggleOrQueryUIDead(BOOL, BOOL);
  313.         virtual BOOL    FToggleOrQueryHatchHandles(BOOL, BOOL);
  314.         virtual BOOL    FQueryEnableEvents(void);
  315.         virtual void    AssignEvents(HWND);
  316.         virtual BOOL    TryMnemonic(LPMSG);
  317.         //End CHAPTER24MOD
  318.     };
  320. typedef CPatronDoc *PCPatronDoc;
  322. //Hook for Print Dialog to hide Setup... button
  323. UINT CALLBACK PrintDlgHook(HWND, UINT, WPARAM, LPARAM);
  326. //IPersistFile implementation for CPatronDoc
  328. class CImpIPersistFile : public IPersistFile
  329.     {
  330.     protected:
  331.         ULONG               m_cRef;      //Interface reference count
  332.         PCPatronDoc         m_pDoc;      //Back pointer to the object
  333.         LPUNKNOWN           m_pUnkOuter; //Controlling unknown
  335.     public:
  336.         CImpIPersistFile(PCPatronDoc, LPUNKNOWN);
  337.         ~CImpIPersistFile(void);
  339.         STDMETHODIMP QueryInterface(REFIID, PPVOID);
  340.         STDMETHODIMP_(ULONG) AddRef(void);
  341.         STDMETHODIMP_(ULONG) Release(void);
  343.         STDMETHODIMP GetClassID(LPCLSID);
  345.         STDMETHODIMP IsDirty(void);
  346.         STDMETHODIMP Load(LPCOLESTR, DWORD);
  347.         STDMETHODIMP Save(LPCOLESTR, BOOL);
  348.         STDMETHODIMP SaveCompleted(LPCOLESTR);
  349.         STDMETHODIMP GetCurFile(LPOLESTR *);
  350.     };
  354. /*
  355.  * IOleItemContainer implementation for both CPatronDoc and CPage,
  356.  * therefore have two back pointers.
  357.  */
  359. class CImpIOleItemContainer : public IOleItemContainer
  360.     {
  361.     protected:
  362.         ULONG               m_cRef;
  363.         class CPage        *m_pPage;
  364.         PCPatronDoc         m_pDoc;      //Convenient naming & types
  365.         LPUNKNOWN           m_pUnkOuter;
  366.         BOOL                m_fDoc;      //Document or page?
  368.     private:
  369.         BOOL         TenantFromName(LPOLESTR, PCTenant *);
  371.     public:
  372.         CImpIOleItemContainer(LPVOID, LPUNKNOWN, BOOL);
  373.         ~CImpIOleItemContainer(void);
  375.         STDMETHODIMP QueryInterface(REFIID, PPVOID);
  376.         STDMETHODIMP_(ULONG) AddRef(void);
  377.         STDMETHODIMP_(ULONG) Release(void);
  379.         STDMETHODIMP ParseDisplayName(LPBC, LPOLESTR, ULONG *
  380.             , LPMONIKER *);
  381.         STDMETHODIMP EnumObjects(DWORD, LPENUMUNKNOWN *);
  382.         STDMETHODIMP LockContainer(BOOL);
  383.         STDMETHODIMP GetObject(LPOLESTR, DWORD, LPBINDCTX, REFIID
  384.             , PPVOID);
  385.         STDMETHODIMP GetObjectStorage(LPOLESTR, LPBINDCTX, REFIID
  386.             , PPVOID);
  387.         STDMETHODIMP IsRunning(LPOLESTR);
  388.     };
  392. //This goes on the document.
  394. class CImpIOleInPlaceUIWindow : public IOleInPlaceUIWindow
  395.     {
  396.     protected:
  397.         ULONG               m_cRef;
  398.         PCPatronDoc         m_pDoc;
  399.         LPUNKNOWN           m_pUnkOuter;
  401.     public:
  402.         CImpIOleInPlaceUIWindow(PCPatronDoc, LPUNKNOWN);
  403.         ~CImpIOleInPlaceUIWindow(void);
  405.         STDMETHODIMP QueryInterface(REFIID, PPVOID);
  406.         STDMETHODIMP_(ULONG) AddRef(void);
  407.         STDMETHODIMP_(ULONG) Release(void);
  409.         STDMETHODIMP GetWindow(HWND *);
  410.         STDMETHODIMP ContextSensitiveHelp(BOOL);
  411.         STDMETHODIMP GetBorder(LPRECT);
  412.         STDMETHODIMP RequestBorderSpace(LPCBORDERWIDTHS);
  413.         STDMETHODIMP SetBorderSpace(LPCBORDERWIDTHS);
  414.         STDMETHODIMP SetActiveObject(LPOLEINPLACEACTIVEOBJECT
  415.                          , LPCOLESTR);
  416.     };
  423. //Drag-drop objects we need in the document
  425. class CDropTarget : public IDropTarget
  426.     {
  427.     protected:
  428.         ULONG               m_cRef;
  429.         PCPatronDoc         m_pDoc;
  431.         LPDATAOBJECT        m_pIDataObject;  //From DragEnter
  432.         BOOL                m_fPendingRepaint;
  433.         POINTL              m_ptPick;        //Pick-up offsets
  434.         POINTL              m_ptLast;        //Last drag point
  435.         SIZEL               m_szl;           //Object size
  436.         BOOL                m_fFeedback;     //Draw feedback?
  437.         FORMATETC           m_fe;            //Real dropping format
  439.     public:
  440.         CDropTarget(PCPatronDoc);
  441.         ~CDropTarget(void);
  443.         //IDropTarget interface members
  444.         STDMETHODIMP QueryInterface(REFIID, PPVOID);
  445.         STDMETHODIMP_(ULONG) AddRef(void);
  446.         STDMETHODIMP_(ULONG) Release(void);
  448.         STDMETHODIMP DragEnter(LPDATAOBJECT, DWORD, POINTL,LPDWORD);
  449.         STDMETHODIMP DragOver(DWORD, POINTL, LPDWORD);
  450.         STDMETHODIMP DragLeave(void);
  451.         STDMETHODIMP Drop(LPDATAOBJECT, DWORD, POINTL, LPDWORD);
  452.     };
  455. typedef CDropTarget *PCDropTarget;
  458. class CDropSource : public IDropSource
  459.     {
  460.     protected:
  461.         ULONG               m_cRef;
  463.     public:
  464.         CDropSource(void);
  465.         ~CDropSource(void);
  467.         //IDropSource interface members
  468.         STDMETHODIMP QueryInterface(REFIID, PPVOID);
  469.         STDMETHODIMP_(ULONG) AddRef(void);
  470.         STDMETHODIMP_(ULONG) Release(void);
  472.         STDMETHODIMP QueryContinueDrag(BOOL, DWORD);
  473.         STDMETHODIMP GiveFeedback(DWORD);
  474.     };
  476. typedef CDropSource *PCDropSource;
  479. #endif //_PATRON_H_