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 / chap23 / polyline / polyline.h < prev    next >
Encoding:
C/C++ Source or Header  |  1995-05-03  |  21.3 KB  |  684 lines
  1. /*
  2.  * POLYLINE.H
  3.  * Polyline Component Chapter 23
  4.  *
  5.  * Definitions and function prototypes
  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 _POLYLINE_H_
  16. #define _POLYLINE_H_
  17.  
  18. #define INC_CLASSLIB
  19. #define INC_CONTROLS
  20. //CHAPTER23MOD
  21. #define INC_OLEUI
  22. #define CHAPTER23
  23. //CHAPTER23MOD
  24. #include <inole.h>
  25. #include <ipoly10.h>
  26. #include "resource.h"
  27.  
  28.  
  29. //Classname
  30. #define SZCLASSPOLYLINE             TEXT("polyline")
  31.  
  32. //Stream Name that holds the data
  33. #define SZSTREAM                    OLETEXT("CONTENTS")
  34.  
  35. #define SZPOLYFRAMETITLE            TEXT("Polyline Figure in %s")
  36.  
  37. //Magic number to add to aspects returned from IViewObject::Freeze
  38. #define FREEZE_KEY_OFFSET           0x0723
  39.  
  40. #define HIMETRIC_PER_INCH           2540
  41. #define CCHPATHMAX                  256
  42.  
  43. //Window extra bytes and offsets
  44. #define CBPOLYLINEWNDEXTRA          (sizeof(LONG))
  45. #define PLWL_STRUCTURE              0
  46.  
  47. //CHAPTER23MOD
  48. #define ID_HATCHWINDOW              2000
  49. //End CHAPTER23MOD
  50.  
  51.  
  52. //DLLPOLY.CPP
  53. int PASCAL LibMain(HINSTANCE, WORD, WORD, LPSTR);
  54.  
  55. //This class factory object creates Polyline objects.
  56.  
  57. class CPolylineClassFactory : public IClassFactory
  58.     {
  59.     protected:
  60.         ULONG           m_cRef;
  61.  
  62.     public:
  63.         CPolylineClassFactory(void);
  64.         ~CPolylineClassFactory(void);
  65.  
  66.         //IUnknown members
  67.         STDMETHODIMP QueryInterface(REFIID, PPVOID);
  68.         STDMETHODIMP_(ULONG) AddRef(void);
  69.         STDMETHODIMP_(ULONG) Release(void);
  70.  
  71.         //IClassFactory members
  72.         STDMETHODIMP         CreateInstance(LPUNKNOWN, REFIID
  73.                                  , PPVOID);
  74.         STDMETHODIMP         LockServer(BOOL);
  75.     };
  76.  
  77. typedef CPolylineClassFactory *PCPolylineClassFactory;
  78.  
  79.  
  80.  
  81. //POLYWIN.CPP
  82. LRESULT APIENTRY PolylineWndProc(HWND, UINT, WPARAM, LPARAM);
  83.  
  84.  
  85. #ifdef WIN32
  86. #define PROP_POINTER    TEXT("Pointer")
  87. #else
  88. #define PROP_SELECTOR   "Selector"
  89. #define PROP_OFFSET     "Offset"
  90. #endif
  91.  
  92. BOOL APIENTRY PolyDlgProc(HWND, UINT, WPARAM, LPARAM);
  93.  
  94. //CHAPTER23MOD
  95. void CalcPolyRectInDialog(HWND, LPRECT);
  96. //End CHAPTER23MOD
  97.  
  98.  
  99. //Forward class references
  100. class CImpIPolyline;
  101. typedef class CImpIPolyline *PCImpIPolyline;
  102.  
  103. class CImpIConnPtCont;
  104. typedef CImpIConnPtCont *PCImpIConnPtCont;
  105.  
  106. class CConnectionPoint;
  107. typedef CConnectionPoint *PCConnectionPoint;
  108.  
  109. class CImpIPersistStorage;
  110. typedef class CImpIPersistStorage *PCImpIPersistStorage;
  111.  
  112. class CImpIPersistStreamInit;
  113. typedef class CImpIPersistStreamInit *PCImpIPersistStreamInit;
  114.  
  115. class CImpIDataObject;
  116. typedef class CImpIDataObject *PCImpIDataObject;
  117.  
  118. class CImpIOleObject;
  119. typedef class CImpIOleObject *PCImpIOleObject;
  120.  
  121. class CImpIViewObject;
  122. typedef class CImpIViewObject *PCImpIViewObject;
  123.  
  124. class CImpIRunnableObject;
  125. typedef class CImpIRunnableObject *PCImpIRunnableObject;
  126.  
  127. class CImpIExternalConnection;
  128. typedef class CImpIExternalConnection *PCImpIExternalConnection;
  129.  
  130. //CHAPTER23MOD
  131. class CImpIOleInPlaceObject;
  132. typedef class CImpIOleInPlaceObject *PCImpIOleInPlaceObject;
  133. class CImpIOleInPlaceActiveObject;
  134. typedef class CImpIOleInPlaceActiveObject *PCImpIOleInPlaceActiveObject;
  135. //End CHAPTER23MOD
  136.  
  137.  
  138.  
  139. //POLYLINE.CPP
  140. class CPolyline : public IUnknown
  141.     {
  142.     friend LRESULT APIENTRY PolylineWndProc(HWND, UINT, WPARAM
  143.         , LPARAM);
  144.  
  145.     friend class CImpIPolyline;
  146.     friend class CImpIConnPtCont;
  147.     friend class CConnectionPoint;
  148.     friend class CImpIPersistStorage;
  149.     friend class CImpIPersistStreamInit;
  150.     friend class CImpIDataObject;
  151.  
  152.     friend BOOL APIENTRY PolyDlgProc(HWND, UINT, WPARAM, LPARAM);
  153.     friend class CImpIOleObject;
  154.     friend class CImpIViewObject;
  155.     friend class CImpIRunnableObject;
  156.     friend class CImpIExternalConnection;
  157.  
  158.     //CHAPTER23MOD
  159.     friend class CImpIOleInPlaceObject;
  160.     friend class CImpIOleInPlaceActiveObject;
  161.     //End CHAPTER23MOD
  162.  
  163.     protected:
  164.         HWND            m_hWnd;
  165.         HINSTANCE       m_hInst;
  166.  
  167.         ULONG           m_cRef;         //Object reference count
  168.         LPUNKNOWN       m_pUnkOuter;    //Controlling Unknown
  169.         PFNDESTROYED    m_pfnDestroy;   //Function called on closure
  170.         BOOL            m_fDirty;       //Have we changed?
  171.         POLYLINEDATA    m_pl;           //Our actual data
  172.  
  173.         //Contained interfaces
  174.         PCImpIPolyline          m_pImpIPolyline;
  175.         PCImpIConnPtCont        m_pImpIConnPtCont;
  176.         PCImpIPersistStorage    m_pImpIPersistStorage;
  177.         PCImpIPersistStreamInit m_pImpIPersistStreamInit;
  178.         PCImpIDataObject        m_pImpIDataObject;
  179.  
  180.         /*
  181.          * Connected sink:  only one per object.  We get this
  182.          * through our connection point.
  183.          */
  184.         IPolylineAdviseSink10  *m_pAdv;
  185.         PCConnectionPoint       m_pConnPt;
  186.  
  187.         PCStringTable   m_pST;          //Object strings
  188.         UINT            m_cf;           //Object clipboard format
  189.         CLSID           m_clsID;        //Current CLSID
  190.  
  191.         //We have to hold these for IPersistStorage::Save
  192.         LPSTORAGE       m_pIStorage;
  193.         LPSTREAM        m_pIStream;
  194.  
  195.         LPDATAADVISEHOLDER  m_pIDataAdviseHolder;
  196.  
  197.         //These are default handler interfaces we use
  198.         LPUNKNOWN           m_pDefIUnknown;
  199.         LPVIEWOBJECT2       m_pDefIViewObject;
  200.         LPPERSISTSTORAGE    m_pDefIPersistStorage;
  201.         LPDATAOBJECT        m_pDefIDataObject;
  202.  
  203.         //Implemented and used interfaces
  204.         PCImpIOleObject     m_pImpIOleObject;       //Implemented
  205.         LPOLEADVISEHOLDER   m_pIOleAdviseHolder;    //Used
  206.  
  207.         LPOLECLIENTSITE     m_pIOleClientSite;      //Used
  208.  
  209.         PCImpIViewObject    m_pImpIViewObject;      //Implemented
  210.         LPADVISESINK        m_pIAdviseSink;         //Used
  211.         DWORD               m_dwFrozenAspects;      //Freeze
  212.         DWORD               m_dwAdviseAspects;      //SetAdvise
  213.         DWORD               m_dwAdviseFlags;        //SetAdvise
  214.  
  215.         POLYLINEDATA        m_plContent;            //For freezing
  216.         POLYLINEDATA        m_plThumbnail;          //For freezing
  217.  
  218.         PCImpIRunnableObject m_pImpIRunnableObject; //Implemented
  219.         HWND                m_hDlg;                 //Editing window
  220.  
  221.         PCImpIExternalConnection m_pImpIExternalConnection; //Implemented
  222.         BOOL                     m_fLockContainer;
  223.         DWORD                    m_dwRegROT;
  224.  
  225.  
  226.         //CHAPTER23MOD
  227.         LPOLEINPLACESITE            m_pIOleIPSite;
  228.         LPOLEINPLACEFRAME           m_pIOleIPFrame;
  229.         LPOLEINPLACEUIWINDOW        m_pIOleIPUIWindow;
  230.  
  231.         PCImpIOleInPlaceObject       m_pImpIOleIPObject;
  232.         PCImpIOleInPlaceActiveObject m_pImpIOleIPActiveObject;
  233.  
  234.         HMENU                       m_hMenuShared;
  235.         HOLEMENU                    m_hOLEMenu;
  236.  
  237.         PCHatchWin                  m_pHW;
  238.         BOOL                        m_fAllowInPlace;
  239.         BOOL                        m_fUIActive;
  240.         BOOL                        m_fContainerKnowsInsideOut;
  241.         //End CHAPTER23MOD
  242.  
  243.     protected:
  244.         void      PointScale(LPRECT, LPPOINTS, BOOL);
  245.         void      Draw(HDC, BOOL, BOOL, LPRECT, PPOLYLINEDATA);
  246.         HINSTANCE Instance(void);
  247.         LPTSTR    String(UINT);
  248.         void      SendAdvise(UINT);
  249.         void      RectConvertMappings(LPRECT, BOOL);
  250.  
  251.         /*
  252.          * These members pulled from IPolyline now serve as a
  253.          * central store for this functionality to be used from
  254.          * other interfaces like IPersistStorage and IDataObject.
  255.          * Other interfaces later may also use them.
  256.          */
  257.         STDMETHODIMP DataSet(PPOLYLINEDATA, BOOL, BOOL);
  258.         STDMETHODIMP DataGet(PPOLYLINEDATA);
  259.  
  260.         STDMETHODIMP RenderNative(HGLOBAL *);
  261.         STDMETHODIMP RenderBitmap(HBITMAP *);
  262.         STDMETHODIMP RenderMetafilePict(HGLOBAL *);
  263.  
  264.  
  265.     public:
  266.         CPolyline(LPUNKNOWN, PFNDESTROYED, HINSTANCE);
  267.         ~CPolyline(void);
  268.  
  269.         BOOL      Init(void);
  270.  
  271.         //Non-delegating object IUnknown
  272.         STDMETHODIMP QueryInterface(REFIID, PPVOID);
  273.         STDMETHODIMP_(ULONG) AddRef(void);
  274.         STDMETHODIMP_(ULONG) Release(void);
  275.  
  276.         //CHAPTER23MOD
  277.         HRESULT  InPlaceActivate(LPOLECLIENTSITE, BOOL);
  278.         void     InPlaceDeactivate(void);
  279.         HRESULT  UIActivate(void);
  280.         void     UIDeactivate(void);
  281.         //End CHAPTER23MOD
  282.     };
  283.  
  284. typedef CPolyline *PCPolyline;
  285.  
  286.  
  287. //Codes for CPolyline::SendAdvise
  288. //......Code.....................Method called in CPolyline::SendAdvise
  289. #define OBJECTCODE_SAVED       0 //IOleAdviseHolder::SendOnSave
  290. #define OBJECTCODE_CLOSED      1 //IOleAdviseHolder::SendOnClose
  291. #define OBJECTCODE_RENAMED     2 //IOleAdviseHolder::SendOnRename
  292. #define OBJECTCODE_SAVEOBJECT  3 //IOleClientSite::SaveObject
  293. #define OBJECTCODE_DATACHANGED 4 //IDataAdviseHolder::SendOnDataChange
  294. #define OBJECTCODE_SHOWWINDOW  5 //IOleClientSite::OnShowWindow(TRUE)
  295. #define OBJECTCODE_HIDEWINDOW  6 //IOleClientSite::OnShowWindow(FALSE)
  296. #define OBJECTCODE_SHOWOBJECT  7 //IOleClientSite::ShowObject
  297.  
  298.  
  299.  
  300. //Interface implementation contained in the Polyline.
  301.  
  302. class CImpIPolyline : public IPolyline10
  303.     {
  304.     protected:
  305.         ULONG               m_cRef;      //Interface reference count
  306.         PCPolyline          m_pObj;      //Back pointer to object
  307.         LPUNKNOWN           m_pUnkOuter; //Controlling unknown
  308.  
  309.     public:
  310.         CImpIPolyline(PCPolyline, LPUNKNOWN);
  311.         ~CImpIPolyline(void);
  312.  
  313.         //IUnknown members.
  314.         STDMETHODIMP QueryInterface(REFIID, PPVOID);
  315.         STDMETHODIMP_(ULONG) AddRef(void);
  316.         STDMETHODIMP_(ULONG) Release(void);
  317.  
  318.         //Manipulation members:
  319.         STDMETHODIMP Init(HWND, LPRECT, DWORD, UINT);
  320.         STDMETHODIMP New(void);
  321.         STDMETHODIMP Undo(void);
  322.         STDMETHODIMP Window(HWND *);
  323.  
  324.         STDMETHODIMP RectGet(LPRECT);
  325.         STDMETHODIMP SizeGet(LPRECT);
  326.         STDMETHODIMP RectSet(LPRECT, BOOL);
  327.         STDMETHODIMP SizeSet(LPRECT, BOOL);
  328.  
  329.         STDMETHODIMP ColorSet(UINT, COLORREF, COLORREF *);
  330.         STDMETHODIMP ColorGet(UINT, COLORREF *);
  331.  
  332.         STDMETHODIMP LineStyleSet(UINT, UINT *);
  333.         STDMETHODIMP LineStyleGet(UINT *);
  334.     };
  335.  
  336.  
  337. class CImpIConnPtCont : public IConnectionPointContainer
  338.     {
  339.     private:
  340.         ULONG               m_cRef;      //Interface ref count
  341.         PCPolyline          m_pObj;      //Back pointer to object
  342.         LPUNKNOWN           m_pUnkOuter; //Controlling unknown
  343.  
  344.     public:
  345.         CImpIConnPtCont(PCPolyline, LPUNKNOWN);
  346.         ~CImpIConnPtCont(void);
  347.  
  348.         //IUnknown members
  349.         STDMETHODIMP         QueryInterface(REFIID, PPVOID);
  350.         STDMETHODIMP_(DWORD) AddRef(void);
  351.         STDMETHODIMP_(DWORD) Release(void);
  352.  
  353.         //IConnectionPointContainer members
  354.         STDMETHODIMP EnumConnectionPoints(IEnumConnectionPoints **);
  355.         STDMETHODIMP FindConnectionPoint(REFIID, IConnectionPoint **);
  356.     };
  357.  
  358.  
  359. /*
  360.  * This connection point will only allow one connection,
  361.  * so it always returns the same connection key.  It also
  362.  * doesn't bother to implement enumerations.
  363.  */
  364.  
  365. #define CCONNMAX    1
  366. #define ADVISEKEY   72388       //Arbitrary
  367.  
  368. class CConnectionPoint : public IConnectionPoint
  369.     {
  370.     private:
  371.         ULONG           m_cRef;     //Object reference count
  372.         PCPolyline      m_pObj;     //Containing object.
  373.  
  374.     public:
  375.         CConnectionPoint(PCPolyline);
  376.         ~CConnectionPoint(void);
  377.  
  378.         //IUnknown members
  379.         STDMETHODIMP         QueryInterface(REFIID, LPVOID *);
  380.         STDMETHODIMP_(ULONG) AddRef(void);
  381.         STDMETHODIMP_(ULONG) Release(void);
  382.  
  383.         //IConnectionPoint members
  384.         STDMETHODIMP GetConnectionInterface(IID *);
  385.         STDMETHODIMP GetConnectionPointContainer
  386.             (IConnectionPointContainer **);
  387.         STDMETHODIMP Advise(LPUNKNOWN, DWORD *);
  388.         STDMETHODIMP Unadvise(DWORD);
  389.         STDMETHODIMP EnumConnections(IEnumConnections **);
  390.     };
  391.  
  392.  
  393.  
  394. class CImpIPersistStorage : public IPersistStorage
  395.     {
  396.     protected:
  397.         ULONG               m_cRef;      //Interface reference count
  398.         PCPolyline          m_pObj;      //Back pointer to object
  399.         LPUNKNOWN           m_pUnkOuter; //Controlling unknown
  400.         PSSTATE             m_psState;   //Storage state
  401.  
  402.     public:
  403.         CImpIPersistStorage(PCPolyline, LPUNKNOWN);
  404.         ~CImpIPersistStorage(void);
  405.  
  406.         STDMETHODIMP QueryInterface(REFIID, PPVOID);
  407.         STDMETHODIMP_(ULONG) AddRef(void);
  408.         STDMETHODIMP_(ULONG) Release(void);
  409.  
  410.         STDMETHODIMP GetClassID(LPCLSID);
  411.  
  412.         STDMETHODIMP IsDirty(void);
  413.         STDMETHODIMP InitNew(LPSTORAGE);
  414.         STDMETHODIMP Load(LPSTORAGE);
  415.         STDMETHODIMP Save(LPSTORAGE, BOOL);
  416.         STDMETHODIMP SaveCompleted(LPSTORAGE);
  417.         STDMETHODIMP HandsOffStorage(void);
  418.     };
  419.  
  420.  
  421. class CImpIPersistStreamInit : public IPersistStreamInit
  422.     {
  423.     protected:
  424.         ULONG               m_cRef;      //Interface reference count
  425.         PCPolyline          m_pObj;      //Back pointer to object
  426.         LPUNKNOWN           m_pUnkOuter; //Controlling unknown
  427.  
  428.     public:
  429.         CImpIPersistStreamInit(PCPolyline, LPUNKNOWN);
  430.         ~CImpIPersistStreamInit(void);
  431.  
  432.         STDMETHODIMP QueryInterface(REFIID, PPVOID);
  433.         STDMETHODIMP_(ULONG) AddRef(void);
  434.         STDMETHODIMP_(ULONG) Release(void);
  435.  
  436.         STDMETHODIMP GetClassID(LPCLSID);
  437.  
  438.         STDMETHODIMP IsDirty(void);
  439.         STDMETHODIMP Load(LPSTREAM);
  440.         STDMETHODIMP Save(LPSTREAM, BOOL);
  441.         STDMETHODIMP GetSizeMax(ULARGE_INTEGER *);
  442.         STDMETHODIMP InitNew(void);
  443.     };
  444.  
  445.  
  446. //IDATAOBJ.CPP
  447. class CImpIDataObject : public IDataObject
  448.     {
  449.     private:
  450.         ULONG               m_cRef;      //Interface reference count
  451.         PCPolyline          m_pObj;      //Back pointer to object
  452.         LPUNKNOWN           m_pUnkOuter; //Controlling unknown
  453.  
  454.     public:
  455.         CImpIDataObject(PCPolyline, LPUNKNOWN);
  456.         ~CImpIDataObject(void);
  457.  
  458.         //IUnknown members that delegate to m_pUnkOuter.
  459.         STDMETHODIMP         QueryInterface(REFIID, PPVOID);
  460.         STDMETHODIMP_(ULONG) AddRef(void);
  461.         STDMETHODIMP_(ULONG) Release(void);
  462.  
  463.         //IDataObject members
  464.         STDMETHODIMP GetData(LPFORMATETC, LPSTGMEDIUM);
  465.         STDMETHODIMP GetDataHere(LPFORMATETC, LPSTGMEDIUM);
  466.         STDMETHODIMP QueryGetData(LPFORMATETC);
  467.         STDMETHODIMP GetCanonicalFormatEtc(LPFORMATETC,LPFORMATETC);
  468.         STDMETHODIMP SetData(LPFORMATETC, LPSTGMEDIUM, BOOL);
  469.         STDMETHODIMP EnumFormatEtc(DWORD, LPENUMFORMATETC *);
  470.         STDMETHODIMP DAdvise(LPFORMATETC, DWORD, LPADVISESINK
  471.             , DWORD *);
  472.         STDMETHODIMP DUnadvise(DWORD);
  473.         STDMETHODIMP EnumDAdvise(LPENUMSTATDATA *);
  474.     };
  475.  
  476.  
  477.  
  478. //IENUMFE.CPP
  479. class CEnumFormatEtc : public IEnumFORMATETC
  480.     {
  481.     private:
  482.         ULONG           m_cRef;
  483.         LPUNKNOWN       m_pUnkRef;
  484.         ULONG           m_iCur;
  485.         ULONG           m_cfe;
  486.         LPFORMATETC     m_prgfe;
  487.  
  488.     public:
  489.         CEnumFormatEtc(LPUNKNOWN, ULONG, LPFORMATETC);
  490.         ~CEnumFormatEtc(void);
  491.  
  492.         //IUnknown members that delegate to m_pUnkRef.
  493.         STDMETHODIMP         QueryInterface(REFIID, PPVOID);
  494.         STDMETHODIMP_(ULONG) AddRef(void);
  495.         STDMETHODIMP_(ULONG) Release(void);
  496.  
  497.         //IEnumFORMATETC members
  498.         STDMETHODIMP Next(ULONG, LPFORMATETC, ULONG *);
  499.         STDMETHODIMP Skip(ULONG);
  500.         STDMETHODIMP Reset(void);
  501.         STDMETHODIMP Clone(IEnumFORMATETC **);
  502.     };
  503.  
  504.  
  505. typedef CEnumFormatEtc *PCEnumFormatEtc;
  506.  
  507.  
  508.  
  509. class CImpIOleObject : public IOleObject
  510.     {
  511.     private:
  512.         ULONG           m_cRef;
  513.         PCPolyline      m_pObj;
  514.         LPUNKNOWN       m_pUnkOuter;
  515.  
  516.     public:
  517.         CImpIOleObject(PCPolyline, LPUNKNOWN);
  518.         ~CImpIOleObject(void);
  519.  
  520.         //IUnknown members that delegate to m_pUnkOuter.
  521.         STDMETHODIMP         QueryInterface(REFIID, PPVOID);
  522.         STDMETHODIMP_(ULONG) AddRef(void);
  523.         STDMETHODIMP_(ULONG) Release(void);
  524.  
  525.         //IOleObject members
  526.         STDMETHODIMP SetClientSite(LPOLECLIENTSITE);
  527.         STDMETHODIMP GetClientSite(LPOLECLIENTSITE *);
  528.         STDMETHODIMP SetHostNames(LPCOLESTR, LPCOLESTR);
  529.         STDMETHODIMP Close(DWORD);
  530.         STDMETHODIMP SetMoniker(DWORD, LPMONIKER);
  531.         STDMETHODIMP GetMoniker(DWORD, DWORD, LPMONIKER *);
  532.         STDMETHODIMP InitFromData(LPDATAOBJECT, BOOL, DWORD);
  533.         STDMETHODIMP GetClipboardData(DWORD, LPDATAOBJECT *);
  534.         STDMETHODIMP DoVerb(LONG, LPMSG, LPOLECLIENTSITE, LONG
  535.                          , HWND, LPCRECT);
  536.         STDMETHODIMP EnumVerbs(LPENUMOLEVERB *);
  537.         STDMETHODIMP Update(void);
  538.         STDMETHODIMP IsUpToDate(void);
  539.         STDMETHODIMP GetUserClassID(CLSID *);
  540.         STDMETHODIMP GetUserType(DWORD, LPOLESTR *);
  541.         STDMETHODIMP SetExtent(DWORD, LPSIZEL);
  542.         STDMETHODIMP GetExtent(DWORD, LPSIZEL);
  543.         STDMETHODIMP Advise(LPADVISESINK, DWORD *);
  544.         STDMETHODIMP Unadvise(DWORD);
  545.         STDMETHODIMP EnumAdvise(LPENUMSTATDATA *);
  546.         STDMETHODIMP GetMiscStatus(DWORD, DWORD *);
  547.         STDMETHODIMP SetColorScheme(LPLOGPALETTE);
  548.     };
  549.  
  550.  
  551. //IVIEWOBJ.CPP
  552. class CImpIViewObject : public IViewObject2
  553.     {
  554.     private:
  555.         ULONG           m_cRef;
  556.         PCPolyline      m_pObj;
  557.         LPUNKNOWN       m_pUnkOuter;
  558.  
  559.     public:
  560.         CImpIViewObject(PCPolyline, LPUNKNOWN);
  561.         ~CImpIViewObject(void);
  562.  
  563.         //IUnknown members that delegate to m_pUnkOuter.
  564.         STDMETHODIMP         QueryInterface(REFIID, PPVOID);
  565.         STDMETHODIMP_(ULONG) AddRef(void);
  566.         STDMETHODIMP_(ULONG) Release(void);
  567.  
  568.         //IViewObject members
  569.         STDMETHODIMP Draw(DWORD, LONG, LPVOID
  570.             , DVTARGETDEVICE *, HDC, HDC, LPCRECTL
  571.             , LPCRECTL, BOOL (CALLBACK *)(DWORD), DWORD);
  572.         STDMETHODIMP GetColorSet(DWORD, LONG, LPVOID
  573.             , DVTARGETDEVICE *, HDC, LPLOGPALETTE *);
  574.         STDMETHODIMP Freeze(DWORD, LONG, LPVOID, LPDWORD);
  575.         STDMETHODIMP Unfreeze(DWORD);
  576.         STDMETHODIMP SetAdvise(DWORD, DWORD, LPADVISESINK);
  577.         STDMETHODIMP GetAdvise(LPDWORD, LPDWORD, LPADVISESINK *);
  578.         STDMETHODIMP GetExtent(DWORD, LONG, DVTARGETDEVICE *
  579.             , LPSIZEL);
  580.     };
  581.  
  582.  
  583. class CImpIRunnableObject : public IRunnableObject
  584.     {
  585.     protected:
  586.         ULONG           m_cRef;
  587.         PCPolyline      m_pObj;
  588.         LPUNKNOWN       m_pUnkOuter;
  589.  
  590.     public:
  591.         CImpIRunnableObject(PCPolyline, LPUNKNOWN);
  592.         ~CImpIRunnableObject(void);
  593.  
  594.         STDMETHODIMP QueryInterface(REFIID, LPVOID *);
  595.         STDMETHODIMP_(ULONG) AddRef(void);
  596.         STDMETHODIMP_(ULONG) Release(void);
  597.  
  598.         STDMETHODIMP GetRunningClass(LPCLSID);
  599.         STDMETHODIMP Run(LPBINDCTX);
  600.         STDMETHODIMP_(BOOL) IsRunning(void);
  601.         STDMETHODIMP LockRunning(BOOL, BOOL);
  602.         STDMETHODIMP SetContainedObject(BOOL);
  603.     };
  604.  
  605.  
  606. class CImpIExternalConnection : public IExternalConnection
  607.     {
  608.     protected:
  609.         ULONG           m_cRef;
  610.         PCPolyline      m_pObj;
  611.         LPUNKNOWN       m_pUnkOuter;
  612.         DWORD           m_cLockStrong;
  613.  
  614.     public:
  615.         CImpIExternalConnection(PCPolyline, LPUNKNOWN);
  616.         ~CImpIExternalConnection(void);
  617.  
  618.         STDMETHODIMP QueryInterface(REFIID, LPVOID *);
  619.         STDMETHODIMP_(ULONG) AddRef(void);
  620.         STDMETHODIMP_(ULONG) Release(void);
  621.  
  622.         STDMETHODIMP_(DWORD) AddConnection(DWORD, DWORD);
  623.         STDMETHODIMP_(DWORD) ReleaseConnection(DWORD, DWORD, BOOL);
  624.     };
  625.  
  626.  
  627.  
  628. //CHAPTER23MOD
  629. class CImpIOleInPlaceObject : public IOleInPlaceObject
  630.     {
  631.     protected:
  632.         ULONG               m_cRef;
  633.         PCPolyline          m_pObj;
  634.         LPUNKNOWN           m_pUnkOuter;
  635.  
  636.     public:
  637.         CImpIOleInPlaceObject(PCPolyline, LPUNKNOWN);
  638.         ~CImpIOleInPlaceObject(void);
  639.  
  640.         STDMETHODIMP QueryInterface(REFIID, PPVOID);
  641.         STDMETHODIMP_(ULONG) AddRef(void);
  642.         STDMETHODIMP_(ULONG) Release(void);
  643.  
  644.         STDMETHODIMP GetWindow(HWND *);
  645.         STDMETHODIMP ContextSensitiveHelp(BOOL);
  646.         STDMETHODIMP InPlaceDeactivate(void);
  647.         STDMETHODIMP UIDeactivate(void);
  648.         STDMETHODIMP SetObjectRects(LPCRECT, LPCRECT);
  649.         STDMETHODIMP ReactivateAndUndo(void);
  650.     };
  651.  
  652.  
  653.  
  654. class CImpIOleInPlaceActiveObject
  655.     : public IOleInPlaceActiveObject
  656.     {
  657.     protected:
  658.         ULONG               m_cRef;
  659.         PCPolyline          m_pObj;
  660.         LPUNKNOWN           m_pUnkOuter;
  661.  
  662.     public:
  663.         CImpIOleInPlaceActiveObject(PCPolyline, LPUNKNOWN);
  664.         ~CImpIOleInPlaceActiveObject(void);
  665.  
  666.         STDMETHODIMP QueryInterface(REFIID, PPVOID);
  667.         STDMETHODIMP_(ULONG) AddRef(void);
  668.         STDMETHODIMP_(ULONG) Release(void);
  669.  
  670.         STDMETHODIMP GetWindow(HWND *);
  671.         STDMETHODIMP ContextSensitiveHelp(BOOL);
  672.         STDMETHODIMP TranslateAccelerator(LPMSG);
  673.         STDMETHODIMP OnFrameWindowActivate(BOOL);
  674.         STDMETHODIMP OnDocWindowActivate(BOOL);
  675.         STDMETHODIMP ResizeBorder(LPCRECT, LPOLEINPLACEUIWINDOW
  676.                          , BOOL);
  677.         STDMETHODIMP EnableModeless(BOOL);
  678.     };
  679.  
  680.  
  681. //End CHAPTER23MOD
  682.  
  683. #endif  //_POLYLINE_H_
  684.