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