home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Windows Gam…ming Gurus (2nd Edition) / Disc2.iso / msdn_vcb / samples / vc98 / sdk / com / inole2 / chap22 / patron / patron.h < prev    next >
C/C++ Source or Header  |  1995-05-03  |  15KB  |  490 lines
  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.  */
  14.  
  15.  
  16. #ifndef _PATRON_H_
  17. #define _PATRON_H_
  18.  
  19. #define INC_CLASSLIB
  20. #define INC_OLEUI
  21. //CHAPTER22MOD
  22. #define CHAPTER22
  23. //End CHAPTER22MOD
  24. #include <inole.h>
  25. #include "resource.h"
  26.  
  27. //Get editor window information
  28. #include "pages.h"
  29.  
  30.  
  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)
  36.  
  37.  
  38. //PATRON.CPP:  Frame object that creates a main window
  39.  
  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;
  46.  
  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;
  54.  
  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?
  61.  
  62.         int             m_cyTop;            //In-place tool allocations
  63.         int             m_cyBottom;
  64.         int             m_cxLeft;
  65.         int             m_cxRight;
  66.  
  67.         BOOL            m_fInContextHelp;   //In context help mode?
  68.  
  69.         LPOLEINPLACEACTIVEOBJECT    m_pIOleIPActiveObject;
  70.         //End CHAPTER22MOD
  71.  
  72.     //CHAPTER22MOD
  73.     //This is for access from IOleInPlaceSite::GetWindowContext
  74.     public:
  75.         HACCEL          m_hAccelIP;         //Accelerators for in-place
  76.     //End CHAPTER22MOD
  77.  
  78.     protected:
  79.         //Overridable for creating a CPatronClient
  80.         virtual PCClient    CreateCClient(void);
  81.  
  82.         virtual BOOL        FMessageHook(HWND, UINT, WPARAM, LPARAM
  83.                                 , LRESULT *);
  84.  
  85.         virtual BOOL        PreShowInit(void);
  86.         virtual BOOL        RegisterAllClasses(void);
  87.         virtual UINT        CreateToolbar(void);
  88.         virtual LRESULT     OnCommand(HWND, WPARAM, LPARAM);
  89.  
  90.     public:
  91.         CPatronFrame(HINSTANCE, HINSTANCE, LPSTR, int);
  92.         virtual ~CPatronFrame(void);
  93.  
  94.         //Overrides
  95.         virtual BOOL        Init(PFRAMEINIT);
  96.  
  97.         //CHAPTER22MOD
  98.         virtual WPARAM      MessageLoop(void);
  99.         //End CHAPTER22MOD
  100.  
  101.         virtual void        UpdateMenus(HMENU, UINT);
  102.         virtual void        UpdateToolbar(void);
  103.  
  104.         //CHAPTER22MOD
  105.         void                ShowUIAndTools(BOOL, BOOL);
  106.         void                ReinstateUI(void);
  107.  
  108.         //IOleInPlaceFrame implementation
  109.         STDMETHODIMP         QueryInterface(REFIID, PPVOID);
  110.         STDMETHODIMP_(ULONG) AddRef(void);
  111.         STDMETHODIMP_(ULONG) Release(void);
  112.  
  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.     };
  128.  
  129.  
  130. typedef CPatronFrame *PCPatronFrame;
  131.  
  132.  
  133. //These are global for simplification of object implementation.
  134. extern ULONG g_cObj;
  135. extern ULONG g_cLock;
  136. extern HWND  g_hWnd;
  137.  
  138. //CHAPTER22MOD
  139. extern PCPatronFrame  g_pFR;
  140. //End CHAPTER22MOD
  141.  
  142. //Function for the object to notify on destruction.
  143. void ObjectDestroyed(void);
  144.  
  145.  
  146. //ICLASSF.CPP
  147.  
  148. class CLinkClassFactory : public IClassFactory
  149.     {
  150.     protected:
  151.         ULONG           m_cRef;
  152.         PCPatronFrame   m_pFR;          //For document creation.
  153.  
  154.     public:
  155.         CLinkClassFactory(PCPatronFrame);
  156.         ~CLinkClassFactory(void);
  157.  
  158.         //IUnknown members
  159.         STDMETHODIMP         QueryInterface(REFIID, PPVOID);
  160.         STDMETHODIMP_(ULONG) AddRef(void);
  161.         STDMETHODIMP_(ULONG) Release(void);
  162.  
  163.         //IClassFactory members
  164.         STDMETHODIMP         CreateInstance(LPUNKNOWN, REFIID
  165.                                  , PPVOID);
  166.         STDMETHODIMP         LockServer(BOOL);
  167.     };
  168.  
  169. typedef CLinkClassFactory *PCLinkClassFactory;
  170.  
  171.  
  172.  
  173.  
  174. //CLIENT.CPP
  175.  
  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.  */
  182.  
  183. class CPatronClient : public CClient
  184.     {
  185.     protected:
  186.         //Overridable for creating a new CDocument
  187.         virtual PCDocument CreateCDocument(void);
  188.  
  189.     public:
  190.         CPatronClient(HINSTANCE, PCFrame);
  191.         virtual ~CPatronClient(void);
  192.  
  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.     };
  200.  
  201.  
  202. typedef CPatronClient *PCPatronClient;
  203.  
  204.  
  205.  
  206.  
  207. //DOCUMENT.CPP
  208.  
  209. //Constant ID for the pages window that lives in a document window
  210. #define ID_PAGES            723
  211.  
  212.  
  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
  221.  
  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.  */
  227.  
  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
  238.  
  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;
  244.  
  245.         class CDropTarget *m_pDropTarget;   //Registered target
  246.  
  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?
  252.  
  253.         ULONG               m_cRef;
  254.         BOOL                m_fRename;          //Rename on Save?
  255.         DWORD               m_dwRegROT;
  256.         DWORD               m_dwRegROTWild;
  257.  
  258.         PCImpIPersistFile       m_pImpIPersistFile;
  259.         PCImpIOleItemContainer  m_pImpIOleItemContainer;
  260.  
  261.         //CHAPTER22MOD
  262.         PCImpIOleInPlaceUIWindow m_pImpIOleIPUIWindow;  //Ours
  263.         LPOLEINPLACEACTIVEOBJECT m_pIOleIPActiveObject; //Object's
  264.         BOOL                     m_fNoObjectFrameTools;
  265.         //End CHAPTER22MOD
  266.  
  267.     protected:
  268.         virtual BOOL    FMessageHook(HWND, UINT, WPARAM, LPARAM
  269.             , LRESULT *);
  270.  
  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);
  278.  
  279.     public:
  280.         CPatronDoc(HINSTANCE, PCFrame, PCDocumentAdviseSink);
  281.         virtual ~CPatronDoc(void);
  282.  
  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);
  287.  
  288.         virtual BOOL    Init(PDOCUMENTINIT);
  289.         virtual void    Clear(void);
  290.  
  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);
  296.  
  297.         virtual UINT    Load(BOOL, LPTSTR);
  298.         virtual UINT    Save(UINT, LPTSTR);
  299.  
  300.         virtual BOOL    Print(HWND);
  301.         virtual UINT    PrinterSetup(HWND, BOOL);
  302.  
  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);
  310.  
  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);
  317.  
  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);
  325.  
  326.     };
  327.  
  328. typedef CPatronDoc *PCPatronDoc;
  329.  
  330. //Hook for Print Dialog to hide Setup... button
  331. UINT CALLBACK PrintDlgHook(HWND, UINT, WPARAM, LPARAM);
  332.  
  333.  
  334. //IPersistFile implementation for CPatronDoc
  335.  
  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
  342.  
  343.     public:
  344.         CImpIPersistFile(PCPatronDoc, LPUNKNOWN);
  345.         ~CImpIPersistFile(void);
  346.  
  347.         STDMETHODIMP QueryInterface(REFIID, PPVOID);
  348.         STDMETHODIMP_(ULONG) AddRef(void);
  349.         STDMETHODIMP_(ULONG) Release(void);
  350.  
  351.         STDMETHODIMP GetClassID(LPCLSID);
  352.  
  353.         STDMETHODIMP IsDirty(void);
  354.         STDMETHODIMP Load(LPCOLESTR, DWORD);
  355.         STDMETHODIMP Save(LPCOLESTR, BOOL);
  356.         STDMETHODIMP SaveCompleted(LPCOLESTR);
  357.         STDMETHODIMP GetCurFile(LPOLESTR *);
  358.     };
  359.  
  360.  
  361.  
  362. /*
  363.  * IOleItemContainer implementation for both CPatronDoc and CPage,
  364.  * therefore have two back pointers.
  365.  */
  366.  
  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?
  375.  
  376.     private:
  377.         BOOL         TenantFromName(LPOLESTR, PCTenant *);
  378.  
  379.     public:
  380.         CImpIOleItemContainer(LPVOID, LPUNKNOWN, BOOL);
  381.         ~CImpIOleItemContainer(void);
  382.  
  383.         STDMETHODIMP QueryInterface(REFIID, PPVOID);
  384.         STDMETHODIMP_(ULONG) AddRef(void);
  385.         STDMETHODIMP_(ULONG) Release(void);
  386.  
  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.     };
  397.  
  398.  
  399.  
  400. //CHAPTER22MOD
  401. //This goes on the document.
  402.  
  403. class CImpIOleInPlaceUIWindow : public IOleInPlaceUIWindow
  404.     {
  405.     protected:
  406.         ULONG               m_cRef;
  407.         PCPatronDoc         m_pDoc;
  408.         LPUNKNOWN           m_pUnkOuter;
  409.  
  410.     public:
  411.         CImpIOleInPlaceUIWindow(PCPatronDoc, LPUNKNOWN);
  412.         ~CImpIOleInPlaceUIWindow(void);
  413.  
  414.         STDMETHODIMP QueryInterface(REFIID, PPVOID);
  415.         STDMETHODIMP_(ULONG) AddRef(void);
  416.         STDMETHODIMP_(ULONG) Release(void);
  417.  
  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
  427.  
  428.  
  429.  
  430.  
  431.  
  432.  
  433. //Drag-drop objects we need in the document
  434.  
  435. class CDropTarget : public IDropTarget
  436.     {
  437.     protected:
  438.         ULONG               m_cRef;
  439.         PCPatronDoc         m_pDoc;
  440.  
  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
  448.  
  449.     public:
  450.         CDropTarget(PCPatronDoc);
  451.         ~CDropTarget(void);
  452.  
  453.         //IDropTarget interface members
  454.         STDMETHODIMP QueryInterface(REFIID, PPVOID);
  455.         STDMETHODIMP_(ULONG) AddRef(void);
  456.         STDMETHODIMP_(ULONG) Release(void);
  457.  
  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.     };
  463.  
  464.  
  465. typedef CDropTarget *PCDropTarget;
  466.  
  467.  
  468. class CDropSource : public IDropSource
  469.     {
  470.     protected:
  471.         ULONG               m_cRef;
  472.  
  473.     public:
  474.         CDropSource(void);
  475.         ~CDropSource(void);
  476.  
  477.         //IDropSource interface members
  478.         STDMETHODIMP QueryInterface(REFIID, PPVOID);
  479.         STDMETHODIMP_(ULONG) AddRef(void);
  480.         STDMETHODIMP_(ULONG) Release(void);
  481.  
  482.         STDMETHODIMP QueryContinueDrag(BOOL, DWORD);
  483.         STDMETHODIMP GiveFeedback(DWORD);
  484.     };
  485.  
  486. typedef CDropSource *PCDropSource;
  487.  
  488.  
  489. #endif //_PATRON_H_
  490.