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 / chap24 / patron / tenant.h < prev    next >
Encoding:
C/C++ Source or Header  |  1995-05-03  |  15.5 KB  |  506 lines
  1. /*
  2.  * TENANT.H
  3.  * Patron Chapter 24
  4.  *
  5.  * Definitions and function prototypes for the CTenant class
  6.  *
  7.  * Copyright (c)1993-1995 Microsoft Corporation, All Rights Reserved
  8.  *
  9.  * Kraig Brockschmidt, Microsoft
  10.  * Internet  :  kraigb@microsoft.com
  11.  * Compuserve:  >INTERNET:kraigb@microsoft.com
  12.  */
  13.  
  14.  
  15. #ifndef _TENANT_H_
  16. #define _TENANT_H_
  17.  
  18.  
  19. class CImpIOleClientSite : public IOleClientSite
  20.     {
  21.     protected:
  22.         ULONG               m_cRef;
  23.         class CTenant      *m_pTen;
  24.         LPUNKNOWN           m_pUnkOuter;
  25.  
  26.     public:
  27.         CImpIOleClientSite(class CTenant *, LPUNKNOWN);
  28.         ~CImpIOleClientSite(void);
  29.  
  30.         STDMETHODIMP QueryInterface(REFIID, PPVOID);
  31.         STDMETHODIMP_(ULONG) AddRef(void);
  32.         STDMETHODIMP_(ULONG) Release(void);
  33.  
  34.         STDMETHODIMP SaveObject(void);
  35.         STDMETHODIMP GetMoniker(DWORD, DWORD, LPMONIKER *);
  36.         STDMETHODIMP GetContainer(LPOLECONTAINER *);
  37.         STDMETHODIMP ShowObject(void);
  38.         STDMETHODIMP OnShowWindow(BOOL);
  39.         STDMETHODIMP RequestNewObjectLayout(void);
  40.     };
  41.  
  42. typedef CImpIOleClientSite *PCImpIOleClientSite;
  43.  
  44.  
  45.  
  46. class CImpIAdviseSink : public IAdviseSink
  47.     {
  48.     protected:
  49.         ULONG               m_cRef;
  50.         class CTenant      *m_pTen;
  51.         LPUNKNOWN           m_pUnkOuter;
  52.  
  53.     public:
  54.         CImpIAdviseSink(class CTenant *, LPUNKNOWN);
  55.         ~CImpIAdviseSink(void);
  56.  
  57.         STDMETHODIMP QueryInterface(REFIID, PPVOID);
  58.         STDMETHODIMP_(ULONG) AddRef(void);
  59.         STDMETHODIMP_(ULONG) Release(void);
  60.  
  61.         STDMETHODIMP_(void)  OnDataChange(LPFORMATETC, LPSTGMEDIUM);
  62.         STDMETHODIMP_(void)  OnViewChange(DWORD, LONG);
  63.         STDMETHODIMP_(void)  OnRename(LPMONIKER);
  64.         STDMETHODIMP_(void)  OnSave(void);
  65.         STDMETHODIMP_(void)  OnClose(void);
  66.     };
  67.  
  68.  
  69. typedef CImpIAdviseSink *PCImpIAdviseSink;
  70.  
  71.  
  72. class CImpIOleInPlaceSite : public IOleInPlaceSite
  73.     {
  74.     protected:
  75.         ULONG               m_cRef;
  76.         class CTenant      *m_pTen;
  77.         LPUNKNOWN           m_pUnkOuter;
  78.  
  79.     public:
  80.         CImpIOleInPlaceSite(class CTenant *, LPUNKNOWN);
  81.         ~CImpIOleInPlaceSite(void);
  82.  
  83.         STDMETHODIMP QueryInterface(REFIID, PPVOID);
  84.         STDMETHODIMP_(ULONG) AddRef(void);
  85.         STDMETHODIMP_(ULONG) Release(void);
  86.  
  87.         STDMETHODIMP GetWindow(HWND *);
  88.         STDMETHODIMP ContextSensitiveHelp(BOOL);
  89.         STDMETHODIMP CanInPlaceActivate(void);
  90.         STDMETHODIMP OnInPlaceActivate(void);
  91.         STDMETHODIMP OnUIActivate(void);
  92.         STDMETHODIMP GetWindowContext(LPOLEINPLACEFRAME *
  93.                         , LPOLEINPLACEUIWINDOW *, LPRECT, LPRECT
  94.                         , LPOLEINPLACEFRAMEINFO);
  95.         STDMETHODIMP Scroll(SIZE);
  96.         STDMETHODIMP OnUIDeactivate(BOOL);
  97.         STDMETHODIMP OnInPlaceDeactivate(void);
  98.         STDMETHODIMP DiscardUndoState(void);
  99.         STDMETHODIMP DeactivateAndUndo(void);
  100.         STDMETHODIMP OnPosRectChange(LPCRECT);
  101.     };
  102.  
  103. typedef CImpIOleInPlaceSite *PCImpIOleInPlaceSite;
  104.  
  105.  
  106. //CHAPTER24MOD
  107. class CImpIOleControlSite : public IOleControlSite
  108.     {
  109.     protected:
  110.         ULONG           m_cRef;
  111.         class CTenant  *m_pTen;
  112.         LPUNKNOWN       m_pUnkOuter;
  113.  
  114.     public:
  115.         CImpIOleControlSite(class CTenant *, LPUNKNOWN);
  116.         ~CImpIOleControlSite(void);
  117.  
  118.         STDMETHODIMP QueryInterface(REFIID, LPVOID *);
  119.         STDMETHODIMP_(ULONG) AddRef(void);
  120.         STDMETHODIMP_(ULONG) Release(void);
  121.  
  122.         STDMETHODIMP OnControlInfoChanged(void);
  123.         STDMETHODIMP LockInPlaceActive(BOOL);
  124.         STDMETHODIMP GetExtendedControl(LPDISPATCH *);
  125.         STDMETHODIMP TransformCoords(POINTL *, POINTF *, DWORD);
  126.         STDMETHODIMP TranslateAccelerator(LPMSG, DWORD);
  127.         STDMETHODIMP OnFocus(BOOL);
  128.         STDMETHODIMP ShowPropertyFrame(void);
  129.     };
  130.  
  131. typedef class CImpIOleControlSite *PCImpIOleControlSite;
  132.  
  133.  
  134. //This IDispatch implements Ambient properties
  135. class CImpIDispatch : public IDispatch
  136.     {
  137.     protected:
  138.         ULONG           m_cRef;
  139.         class CTenant  *m_pTen;
  140.         LPUNKNOWN       m_pUnkOuter;
  141.  
  142.     public:
  143.         CImpIDispatch(class CTenant *, LPUNKNOWN);
  144.         ~CImpIDispatch(void);
  145.  
  146.         STDMETHODIMP QueryInterface(REFIID, LPVOID *);
  147.         STDMETHODIMP_(ULONG) AddRef(void);
  148.         STDMETHODIMP_(ULONG) Release(void);
  149.  
  150.         STDMETHODIMP GetTypeInfoCount(UINT *);
  151.         STDMETHODIMP GetTypeInfo(UINT, LCID, ITypeInfo **);
  152.         STDMETHODIMP GetIDsOfNames(REFIID, OLECHAR **, UINT
  153.             , LCID, DISPID *);
  154.         STDMETHODIMP Invoke(DISPID, REFIID, LCID, USHORT
  155.             , DISPPARAMS *, VARIANT *, EXCEPINFO *, UINT *);
  156.     };
  157.  
  158. typedef class CImpIDispatch *PCImpIDispatch;
  159.  
  160.  
  161. //Events IDispatch created once for each outgoing event set.
  162. class CDispatchEvents : public IDispatch
  163.     {
  164.     protected:
  165.         ULONG           m_cRef;
  166.         class CTenant  *m_pTen;
  167.  
  168.     public:
  169.         CDispatchEvents(class CTenant *);
  170.         ~CDispatchEvents(void);
  171.  
  172.         STDMETHODIMP QueryInterface(REFIID, LPVOID *);
  173.         STDMETHODIMP_(ULONG) AddRef(void);
  174.         STDMETHODIMP_(ULONG) Release(void);
  175.  
  176.         STDMETHODIMP GetTypeInfoCount(UINT *);
  177.         STDMETHODIMP GetTypeInfo(UINT, LCID, ITypeInfo **);
  178.         STDMETHODIMP GetIDsOfNames(REFIID, OLECHAR **, UINT
  179.             , LCID, DISPID *);
  180.         STDMETHODIMP Invoke(DISPID, REFIID, LCID, USHORT
  181.             , DISPPARAMS *, VARIANT *, EXCEPINFO *, UINT *);
  182.     };
  183.  
  184. typedef class CDispatchEvents *PCDispatchEvents;
  185.  
  186.  
  187. //End CHAPTER24MOD
  188.  
  189.  
  190.  
  191. /*
  192.  * Tenant class describing an individual piece of data in a page.
  193.  * It knows where it sits, what object is inside of it, and what
  194.  * its idenitifer is such that it can find it's storage within a
  195.  * page.
  196.  */
  197.  
  198. //Patron Objects clipboard format
  199. typedef struct tagPATRONOBJECT
  200.     {
  201.     POINTL      ptl;        //Location of object
  202.     POINTL      ptlPick;    //Pick point from drag-drop operation
  203.     SIZEL       szl;        //Extents of object (absolute)
  204.     FORMATETC   fe;         //Actual object format
  205.     } PATRONOBJECT, *PPATRONOBJECT;
  206.  
  207.  
  208.  
  209. //Values for hit-testing, drawing, and resize-tracking tenants
  210. #define CXYHANDLE       5
  211.  
  212. //Tenant types (not persistent, but determined at load time)
  213. typedef enum
  214.     {
  215.     TENANTTYPE_NULL=0,
  216.     TENANTTYPE_STATIC,
  217.     TENANTTYPE_EMBEDDEDOBJECT,
  218.     TENANTTYPE_EMBEDDEDFILE,
  219.     TENANTTYPE_EMBEDDEDOBJECTFROMDATA,
  220.     TENANTTYPE_LINKEDOBJECT,
  221.     TENANTTYPE_LINKEDFILE,
  222.     TENANTTYPE_LINKEDOBJECTFROMDATA
  223.     } TENANTTYPE, *PTENANTTYPE;
  224.  
  225.  
  226. //State flags
  227. //CHAPTER24MOD
  228. //Switched #defines to an enum
  229. enum
  230.     {
  231.     TENANTSTATE_DEFAULT =0x00000000,
  232.     TENANTSTATE_SELECTED=0x00000001,
  233.     TENANTSTATE_OPEN    =0x00000002,
  234.     TENANTSTATE_SHOWTYPE=0x00000004,
  235.  
  236.     //New ones for controls.
  237.     TENANTSTATE_CONTROL     =0x00000100,
  238.     TENANTSTATE_EVENTS      =0x00000200,
  239.     TENANTSTATE_BUTTON      =0x00000400,
  240.     TENANTSTATE_LABEL       =0x00000800,
  241.     TENANTSTATE_DEFBUTTON   =0x00001000,
  242.     TENANTSTATE_CANCELBUTTON=0x00002000
  243.     };
  244.  
  245. //To mask off non-control flags
  246. #define STATEMASK_CONTROLS 0xFFFFFF00
  247.  
  248. //End CHAPTER24MOD
  249.  
  250. /*
  251.  * Persistent information we need to save for each tenant, which is
  252.  * done in the tenant list instead of with each tenant.  Since this
  253.  * is a small structure it's best not to blow another stream for it
  254.  * (overhead).
  255.  */
  256. typedef struct tagTENANTINFO
  257.     {
  258.     DWORD       dwID;
  259.     RECTL       rcl;
  260.     FORMATETC   fe;             //Excludes ptd
  261.     short       fSetExtent;     //Call IOleObject::SetExtent on Run
  262.     } TENANTINFO, *PTENANTINFO;
  263.  
  264.  
  265. //CHAPTER24MOD
  266. /*
  267.  * Event handling constructs:  EVENTACTION is the type of
  268.  * action to execute on an event.  EVENTMAP is an element of
  269.  * an array to hold event mappings.
  270.  */
  271.  
  272. typedef enum
  273.     {
  274.     ACTION_NONE=-1,
  275.     ACTION_BEEPDEFAULT=MB_OK,
  276.     ACTION_BEEPASTERISK=MB_ICONASTERISK,
  277.     ACTION_BEEPEXCLAMATION=MB_ICONEXCLAMATION,
  278.     ACTION_BEEPHAND=MB_ICONHAND,
  279.     ACTION_BEEPQUESTION=MB_ICONQUESTION,
  280.     ACTION_TAILING=-2
  281.     } EVENTACTION;
  282.  
  283.  
  284. typedef struct tagEVENTMAP
  285.     {
  286.     DISPID      id;             //Event ID
  287.     EVENTACTION iAction;        //Action to take
  288.     BSTR        bstrName;       //Event name (function only)
  289.     } EVENTMAP, *PEVENTMAP;
  290.  
  291.  
  292. class CEventMap
  293.     {
  294.     public:
  295.         UINT            m_cEvents;
  296.         LPTYPEINFO      m_pITypeInfo;
  297.         PEVENTMAP       m_pEventMap;
  298.  
  299.     public:
  300.         CEventMap(LPTYPEINFO);
  301.         ~CEventMap(void);
  302.  
  303.         BOOL            Init(void);
  304.         BOOL            Set(DISPID, EVENTACTION);
  305.         EVENTACTION     Get(DISPID);
  306.         void            Serialize(LPSTREAM);
  307.         void            Deserialize(LPSTREAM);
  308.     };
  309.  
  310. typedef CEventMap *PCEventMap;
  311.  
  312. //Events stream in the object storage
  313. #define SZEVENTSSTREAM  OLETEXT("\003Event Mappings")
  314.  
  315. //End CHAPTER24MOD
  316.  
  317.  
  318.  
  319. class CTenant : public IUnknown
  320.     {
  321.     friend CImpIOleClientSite;
  322.     friend CImpIAdviseSink;
  323.     friend CImpIOleInPlaceSite;
  324.  
  325.     //CHAPTER24MOD
  326.     friend CImpIOleControlSite;
  327.     friend CImpIDispatch;
  328.  
  329.     friend CDispatchEvents;
  330.     //End CHAPTER24MOD
  331.  
  332.     private:
  333.         HWND            m_hWnd;         //Pages window
  334.         DWORD           m_dwID;         //Persistent DWORD ID
  335.         DWORD           m_cOpens;       //Count calls to Open
  336.  
  337.         BOOL            m_fInitialized; //Something here?
  338.         LPUNKNOWN       m_pObj;         //The object here
  339.         LPSTORAGE       m_pIStorage;    //Sub-storage for tenant
  340.  
  341.         FORMATETC       m_fe;           //Used to create the object
  342.         DWORD           m_dwState;      //State flags
  343.         RECTL           m_rcl;          //Space of this object
  344.         CLSID           m_clsID;        //Object class (for statics)
  345.         BOOL            m_fSetExtent;   //Call SetExtent on next run
  346.  
  347.         class CPages   *m_pPG;          //Pages window
  348.  
  349.         TENANTTYPE      m_tType;            //Type identifier
  350.         ULONG           m_cRef;             //We're an object now
  351.         LPOLEOBJECT     m_pIOleObject;      //IOleObject on m_pObj
  352.         LPVIEWOBJECT2   m_pIViewObject2;    //IViewObject2 on m_pObj
  353.         ULONG           m_grfMisc;          //OLEMISC flags
  354.         BOOL            m_fRepaintEnabled;  //No redundant paints
  355.  
  356.         //Our interfaces
  357.         PCImpIOleClientSite m_pImpIOleClientSite;
  358.         PCImpIAdviseSink    m_pImpIAdviseSink;
  359.  
  360.         LPMONIKER       m_pmk;          //Relative moniker
  361.         LPMONIKER       m_pmkFile;      //Container document moniker
  362.  
  363.         PCImpIOleInPlaceSite m_pImpIOleIPSite; //Our interface
  364.         LPOLEINPLACEOBJECT   m_pIOleIPObject;  //The object
  365.         RECT                 m_rcPos;          //Last object rect
  366.         BOOL                 m_fInRectSet;     //Prevent reentrancy
  367.  
  368.         //CHAPTER24MOD
  369.         PCImpIOleControlSite    m_pImpIOleControlSite; //Implemented
  370.         PCImpIDispatch          m_pImpIDispatch;       //Implemented
  371.  
  372.         PCDispatchEvents        m_pDispEvents;      //Event Sink
  373.         DWORD                   m_dwConnEvents;
  374.         IID                     m_iidEvents;
  375.         PCEventMap              m_pEventMap;
  376.  
  377.         //Control interfaces
  378.         LPOLECONTROL        m_pIOleControl;      //Used
  379.         LPDISPATCH          m_pIDispatchControl; //Used
  380.  
  381.         //Ambient properties
  382.         OLE_COLOR           m_clrBack;
  383.         OLE_COLOR           m_clrFore;
  384.         IFontDisp          *m_pIFont;       //Copy from CPages
  385.         LCID                m_lcid;
  386.         BOOL                m_fDesignMode;
  387.         BOOL                m_fUIDead;
  388.         BOOL                m_fHatchHandles;
  389.  
  390.         //Other state information
  391.         BOOL                m_fHaveControlInfo;
  392.         CONTROLINFO         m_ctrlInfo;
  393.         ULONG               m_cLockInPlace;
  394.         BOOL                m_fPendingDeactivate;
  395.         //End CHAPTER24MOD
  396.  
  397.  
  398.     /*
  399.      * This flag is used exculsively by the implementation of
  400.      * IOleUILinkContainer on the page we're in for the Links
  401.      * Dialog. Since we never use it ourselves, public here
  402.      * is no big deal.
  403.      */
  404.     public:
  405.         BOOL            m_fLinkAvail;
  406.  
  407.     protected:
  408.         BOOL    ObjectInitialize(LPUNKNOWN, LPFORMATETC, DWORD);
  409.         HRESULT CreateStatic(LPDATAOBJECT, LPFORMATETC
  410.             , LPUNKNOWN *);
  411.  
  412.         //CHAPTER24MOD
  413.         BOOL    ControlInitialize(void);
  414.         //End CHAPTER24MOD
  415.  
  416.     public:
  417.         CTenant(DWORD, HWND, CPages *);
  418.         ~CTenant(void);
  419.  
  420.         //Gotta have an IUnknown for delegation
  421.         STDMETHODIMP QueryInterface(REFIID, PPVOID);
  422.         STDMETHODIMP_(ULONG) AddRef(void);
  423.         STDMETHODIMP_(ULONG) Release(void);
  424.  
  425.         DWORD       GetID(void);
  426.         UINT        GetStorageName(LPOLESTR);
  427.         void        StorageGet(LPSTORAGE *);
  428.         UINT        Create(TENANTTYPE, LPVOID, LPFORMATETC, PPOINTL
  429.                         , LPSIZEL, LPSTORAGE, PPATRONOBJECT, DWORD);
  430.         BOOL        Load(LPSTORAGE, PTENANTINFO);
  431.         void        GetInfo(PTENANTINFO);
  432.         BOOL        Open(LPSTORAGE);
  433.         void        Close(BOOL);
  434.         BOOL        Update(void);
  435.         void        Destroy(LPSTORAGE);
  436.  
  437.         void        Select(BOOL, BOOL);
  438.         void        ShowAsOpen(BOOL);
  439.         void        ShowYourself(void);
  440.         void        AddVerbMenu(HMENU, UINT);
  441.         TENANTTYPE  TypeGet(void);
  442.         void        CopyEmbeddedObject(LPDATAOBJECT, LPFORMATETC
  443.                         , PPOINTL);
  444.         void        ShowObjectType(BOOL);
  445.         void        CopyLinkedObject(LPDATAOBJECT, LPFORMATETC
  446.                         , PPOINTL);
  447.         void        NotifyOfRename(LPTSTR, LPMONIKER, LPMONIKER);
  448.         BOOL        Activate(LONG, LPMSG);
  449.  
  450.         void        Draw(HDC, DVTARGETDEVICE *, HDC, int, int
  451.                         , BOOL, BOOL);
  452.         void        Repaint(void);
  453.         void        Invalidate(void);
  454.  
  455.         void        ObjectClassFormatAndIcon(LPCLSID, LPWORD
  456.                         , LPTSTR *, HGLOBAL *, LPTSTR *);
  457.         BOOL        SwitchOrUpdateAspect(HGLOBAL, BOOL);
  458.         void        EnableRepaint(BOOL);
  459.  
  460.         BOOL        FIsSelected(void);
  461.         BOOL        ConvertToStatic(void);
  462.  
  463.         void        ObjectGet(LPUNKNOWN *);
  464.         void        FormatEtcGet(LPFORMATETC, BOOL);
  465.         void        SizeGet(LPSIZEL, BOOL);
  466.         void        SizeSet(LPSIZEL, BOOL, BOOL);
  467.         void        RectGet(LPRECTL, BOOL);
  468.         void        RectSet(LPRECTL, BOOL, BOOL);
  469.  
  470.         void        DeactivateInPlaceObject(BOOL);
  471.         void        UpdateInPlaceObjectRects(LPCRECT, BOOL);
  472.         HWND        ObjectWindow(void);
  473.  
  474.         //CHAPTER24MOD
  475.         void        ToggleDesignMode(BOOL);
  476.         void        ToggleUIDead(BOOL);
  477.         void        ToggleHatchHandles(BOOL);
  478.         PCEventMap  EventMap(void);
  479.         DWORD       GetControlFlags();
  480.         BOOL        TryMnemonic(LPMSG);
  481.         void        AmbientChange(DISPID);
  482.         //End CHAPTER24MOD
  483.     };
  484.  
  485.  
  486. typedef CTenant *PCTenant;
  487.  
  488. //Return codes for Create
  489. #define CREATE_FAILED               0
  490. #define CREATE_GRAPHICONLY          1
  491. #define CREATE_PLACEDOBJECT         2
  492.  
  493.  
  494. //CHAPTER24MOD
  495. //Helper functions in CONNECT.CPP
  496.  
  497. BOOL InterfaceConnect(LPUNKNOWN, REFIID, LPUNKNOWN, LPDWORD);
  498. BOOL InterfaceDisconnect(LPUNKNOWN, REFIID, LPDWORD);
  499. BOOL ObjectTypeInfo(LPUNKNOWN, LPTYPEINFO *);
  500. BOOL ObjectTypeInfoEvents(LPUNKNOWN, LPTYPEINFO *);
  501. BOOL ObjectEventsIID(LPUNKNOWN, IID *);
  502.  
  503. //End CHAPTER24MOD
  504.  
  505. #endif //_TENANT_H_
  506.