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