POLYLINE.H

/* 
 * POLYLINE.H 
 * Polyline Component Chapter 23 
 * 
 * Definitions and function prototypes 
 * 
 * Copyright (c)1993-1995 Microsoft Corporation, All Rights Reserved 
 * 
 * Kraig Brockschmidt, Microsoft 
 * Internet  :  kraigb@microsoft.com 
 * Compuserve:  >INTERNET:kraigb@microsoft.com 
 */ 
 
 
#ifndef _POLYLINE_H_ 
#define _POLYLINE_H_ 
 
#define INC_CLASSLIB 
#define INC_CONTROLS 
//CHAPTER23MOD 
#define INC_OLEUI 
#define CHAPTER23 
//CHAPTER23MOD 
#include <inole.h> 
#include <ipoly10.h> 
#include "resource.h" 
 
 
//Classname 
#define SZCLASSPOLYLINE             TEXT("polyline") 
 
//Stream Name that holds the data 
#define SZSTREAM                    OLETEXT("CONTENTS") 
 
#define SZPOLYFRAMETITLE            TEXT("Polyline Figure in %s") 
 
//Magic number to add to aspects returned from IViewObject::Freeze 
#define FREEZE_KEY_OFFSET           0x0723 
 
#define HIMETRIC_PER_INCH           2540 
#define CCHPATHMAX                  256 
 
//Window extra bytes and offsets 
#define CBPOLYLINEWNDEXTRA          (sizeof(LONG)) 
#define PLWL_STRUCTURE              0 
 
//CHAPTER23MOD 
#define ID_HATCHWINDOW              2000 
//End CHAPTER23MOD 
 
 
//DLLPOLY.CPP 
int PASCAL LibMain(HINSTANCE, WORD, WORD, LPSTR); 
 
//This class factory object creates Polyline objects. 
 
class CPolylineClassFactory : public IClassFactory 
    { 
    protected: 
        ULONG           m_cRef; 
 
    public: 
        CPolylineClassFactory(void); 
        ~CPolylineClassFactory(void); 
 
        //IUnknown members 
        STDMETHODIMP QueryInterface(REFIID, PPVOID); 
        STDMETHODIMP_(ULONG) AddRef(void); 
        STDMETHODIMP_(ULONG) Release(void); 
 
        //IClassFactory members 
        STDMETHODIMP         CreateInstance(LPUNKNOWN, REFIID 
                                 , PPVOID); 
        STDMETHODIMP         LockServer(BOOL); 
    }; 
 
typedef CPolylineClassFactory *PCPolylineClassFactory; 
 
 
 
//POLYWIN.CPP 
LRESULT APIENTRY PolylineWndProc(HWND, UINT, WPARAM, LPARAM); 
 
 
#ifdef WIN32 
#define PROP_POINTER    TEXT("Pointer") 
#else 
#define PROP_SELECTOR   "Selector" 
#define PROP_OFFSET     "Offset" 
#endif 
 
BOOL APIENTRY PolyDlgProc(HWND, UINT, WPARAM, LPARAM); 
 
//CHAPTER23MOD 
void CalcPolyRectInDialog(HWND, LPRECT); 
//End CHAPTER23MOD 
 
 
//Forward class references 
class CImpIPolyline; 
typedef class CImpIPolyline *PCImpIPolyline; 
 
class CImpIConnPtCont; 
typedef CImpIConnPtCont *PCImpIConnPtCont; 
 
class CConnectionPoint; 
typedef CConnectionPoint *PCConnectionPoint; 
 
class CImpIPersistStorage; 
typedef class CImpIPersistStorage *PCImpIPersistStorage; 
 
class CImpIPersistStreamInit; 
typedef class CImpIPersistStreamInit *PCImpIPersistStreamInit; 
 
class CImpIDataObject; 
typedef class CImpIDataObject *PCImpIDataObject; 
 
class CImpIOleObject; 
typedef class CImpIOleObject *PCImpIOleObject; 
 
class CImpIViewObject; 
typedef class CImpIViewObject *PCImpIViewObject; 
 
class CImpIRunnableObject; 
typedef class CImpIRunnableObject *PCImpIRunnableObject; 
 
class CImpIExternalConnection; 
typedef class CImpIExternalConnection *PCImpIExternalConnection; 
 
//CHAPTER23MOD 
class CImpIOleInPlaceObject; 
typedef class CImpIOleInPlaceObject *PCImpIOleInPlaceObject; 
class CImpIOleInPlaceActiveObject; 
typedef class CImpIOleInPlaceActiveObject *PCImpIOleInPlaceActiveObject; 
//End CHAPTER23MOD 
 
 
 
//POLYLINE.CPP 
class CPolyline : public IUnknown 
    { 
    friend LRESULT APIENTRY PolylineWndProc(HWND, UINT, WPARAM 
        , LPARAM); 
 
    friend class CImpIPolyline; 
    friend class CImpIConnPtCont; 
    friend class CConnectionPoint; 
    friend class CImpIPersistStorage; 
    friend class CImpIPersistStreamInit; 
    friend class CImpIDataObject; 
 
    friend BOOL APIENTRY PolyDlgProc(HWND, UINT, WPARAM, LPARAM); 
    friend class CImpIOleObject; 
    friend class CImpIViewObject; 
    friend class CImpIRunnableObject; 
    friend class CImpIExternalConnection; 
 
    //CHAPTER23MOD 
    friend class CImpIOleInPlaceObject; 
    friend class CImpIOleInPlaceActiveObject; 
    //End CHAPTER23MOD 
 
    protected: 
        HWND            m_hWnd; 
        HINSTANCE       m_hInst; 
 
        ULONG           m_cRef;         //Object reference count 
        LPUNKNOWN       m_pUnkOuter;    //Controlling Unknown 
        PFNDESTROYED    m_pfnDestroy;   //Function called on closure 
        BOOL            m_fDirty;       //Have we changed? 
        POLYLINEDATA    m_pl;           //Our actual data 
 
        //Contained interfaces 
        PCImpIPolyline          m_pImpIPolyline; 
        PCImpIConnPtCont        m_pImpIConnPtCont; 
        PCImpIPersistStorage    m_pImpIPersistStorage; 
        PCImpIPersistStreamInit m_pImpIPersistStreamInit; 
        PCImpIDataObject        m_pImpIDataObject; 
 
        /* 
         * Connected sink:  only one per object.  We get this 
         * through our connection point. 
         */ 
        IPolylineAdviseSink10  *m_pAdv; 
        PCConnectionPoint       m_pConnPt; 
 
        PCStringTable   m_pST;          //Object strings 
        UINT            m_cf;           //Object clipboard format 
        CLSID           m_clsID;        //Current CLSID 
 
        //We have to hold these for IPersistStorage::Save 
        LPSTORAGE       m_pIStorage; 
        LPSTREAM        m_pIStream; 
 
        LPDATAADVISEHOLDER  m_pIDataAdviseHolder; 
 
        //These are default handler interfaces we use 
        LPUNKNOWN           m_pDefIUnknown; 
        LPVIEWOBJECT2       m_pDefIViewObject; 
        LPPERSISTSTORAGE    m_pDefIPersistStorage; 
        LPDATAOBJECT        m_pDefIDataObject; 
 
        //Implemented and used interfaces 
        PCImpIOleObject     m_pImpIOleObject;       //Implemented 
        LPOLEADVISEHOLDER   m_pIOleAdviseHolder;    //Used 
 
        LPOLECLIENTSITE     m_pIOleClientSite;      //Used 
 
        PCImpIViewObject    m_pImpIViewObject;      //Implemented 
        LPADVISESINK        m_pIAdviseSink;         //Used 
        DWORD               m_dwFrozenAspects;      //Freeze 
        DWORD               m_dwAdviseAspects;      //SetAdvise 
        DWORD               m_dwAdviseFlags;        //SetAdvise 
 
        POLYLINEDATA        m_plContent;            //For freezing 
        POLYLINEDATA        m_plThumbnail;          //For freezing 
 
        PCImpIRunnableObject m_pImpIRunnableObject; //Implemented 
        HWND                m_hDlg;                 //Editing window 
 
        PCImpIExternalConnection m_pImpIExternalConnection; //Implemented 
        BOOL                     m_fLockContainer; 
        DWORD                    m_dwRegROT; 
 
 
        //CHAPTER23MOD 
        LPOLEINPLACESITE            m_pIOleIPSite; 
        LPOLEINPLACEFRAME           m_pIOleIPFrame; 
        LPOLEINPLACEUIWINDOW        m_pIOleIPUIWindow; 
 
        PCImpIOleInPlaceObject       m_pImpIOleIPObject; 
        PCImpIOleInPlaceActiveObject m_pImpIOleIPActiveObject; 
 
        HMENU                       m_hMenuShared; 
        HOLEMENU                    m_hOLEMenu; 
 
        PCHatchWin                  m_pHW; 
        BOOL                        m_fAllowInPlace; 
        BOOL                        m_fUIActive; 
        BOOL                        m_fContainerKnowsInsideOut; 
        //End CHAPTER23MOD 
 
    protected: 
        void      PointScale(LPRECT, LPPOINTS, BOOL); 
        void      Draw(HDC, BOOL, BOOL, LPRECT, PPOLYLINEDATA); 
        HINSTANCE Instance(void); 
        LPTSTR    String(UINT); 
        void      SendAdvise(UINT); 
        void      RectConvertMappings(LPRECT, BOOL); 
 
        /* 
         * These members pulled from IPolyline now serve as a 
         * central store for this functionality to be used from 
         * other interfaces like IPersistStorage and IDataObject. 
         * Other interfaces later may also use them. 
         */ 
        STDMETHODIMP DataSet(PPOLYLINEDATA, BOOL, BOOL); 
        STDMETHODIMP DataGet(PPOLYLINEDATA); 
 
        STDMETHODIMP RenderNative(HGLOBAL *); 
        STDMETHODIMP RenderBitmap(HBITMAP *); 
        STDMETHODIMP RenderMetafilePict(HGLOBAL *); 
 
 
    public: 
        CPolyline(LPUNKNOWN, PFNDESTROYED, HINSTANCE); 
        ~CPolyline(void); 
 
        BOOL      Init(void); 
 
        //Non-delegating object IUnknown 
        STDMETHODIMP QueryInterface(REFIID, PPVOID); 
        STDMETHODIMP_(ULONG) AddRef(void); 
        STDMETHODIMP_(ULONG) Release(void); 
 
        //CHAPTER23MOD 
        HRESULT  InPlaceActivate(LPOLECLIENTSITE, BOOL); 
        void     InPlaceDeactivate(void); 
        HRESULT  UIActivate(void); 
        void     UIDeactivate(void); 
        //End CHAPTER23MOD 
    }; 
 
typedef CPolyline *PCPolyline; 
 
 
//Codes for CPolyline::SendAdvise 
//......Code.....................Method called in CPolyline::SendAdvise 
#define OBJECTCODE_SAVED       0 //IOleAdviseHolder::SendOnSave 
#define OBJECTCODE_CLOSED      1 //IOleAdviseHolder::SendOnClose 
#define OBJECTCODE_RENAMED     2 //IOleAdviseHolder::SendOnRename 
#define OBJECTCODE_SAVEOBJECT  3 //IOleClientSite::SaveObject 
#define OBJECTCODE_DATACHANGED 4 //IDataAdviseHolder::SendOnDataChange 
#define OBJECTCODE_SHOWWINDOW  5 //IOleClientSite::OnShowWindow(TRUE) 
#define OBJECTCODE_HIDEWINDOW  6 //IOleClientSite::OnShowWindow(FALSE) 
#define OBJECTCODE_SHOWOBJECT  7 //IOleClientSite::ShowObject 
 
 
 
//Interface implementation contained in the Polyline. 
 
class CImpIPolyline : public IPolyline10 
    { 
    protected: 
        ULONG               m_cRef;      //Interface reference count 
        PCPolyline          m_pObj;      //Back pointer to object 
        LPUNKNOWN           m_pUnkOuter; //Controlling unknown 
 
    public: 
        CImpIPolyline(PCPolyline, LPUNKNOWN); 
        ~CImpIPolyline(void); 
 
        //IUnknown members. 
        STDMETHODIMP QueryInterface(REFIID, PPVOID); 
        STDMETHODIMP_(ULONG) AddRef(void); 
        STDMETHODIMP_(ULONG) Release(void); 
 
        //Manipulation members: 
        STDMETHODIMP Init(HWND, LPRECT, DWORD, UINT); 
        STDMETHODIMP New(void); 
        STDMETHODIMP Undo(void); 
        STDMETHODIMP Window(HWND *); 
 
        STDMETHODIMP RectGet(LPRECT); 
        STDMETHODIMP SizeGet(LPRECT); 
        STDMETHODIMP RectSet(LPRECT, BOOL); 
        STDMETHODIMP SizeSet(LPRECT, BOOL); 
 
        STDMETHODIMP ColorSet(UINT, COLORREF, COLORREF *); 
        STDMETHODIMP ColorGet(UINT, COLORREF *); 
 
        STDMETHODIMP LineStyleSet(UINT, UINT *); 
        STDMETHODIMP LineStyleGet(UINT *); 
    }; 
 
 
class CImpIConnPtCont : public IConnectionPointContainer 
    { 
    private: 
        ULONG               m_cRef;      //Interface ref count 
        PCPolyline          m_pObj;      //Back pointer to object 
        LPUNKNOWN           m_pUnkOuter; //Controlling unknown 
 
    public: 
        CImpIConnPtCont(PCPolyline, LPUNKNOWN); 
        ~CImpIConnPtCont(void); 
 
        //IUnknown members 
        STDMETHODIMP         QueryInterface(REFIID, PPVOID); 
        STDMETHODIMP_(DWORD) AddRef(void); 
        STDMETHODIMP_(DWORD) Release(void); 
 
        //IConnectionPointContainer members 
        STDMETHODIMP EnumConnectionPoints(IEnumConnectionPoints **); 
    STDMETHODIMP FindConnectionPoint(REFIID, IConnectionPoint **); 
    }; 
 
 
/* 
 * This connection point will only allow one connection, 
 * so it always returns the same connection key.  It also 
 * doesn't bother to implement enumerations. 
 */ 
 
#define CCONNMAX    1 
#define ADVISEKEY   72388       //Arbitrary 
 
class CConnectionPoint : public IConnectionPoint 
    { 
    private: 
        ULONG           m_cRef;     //Object reference count 
        PCPolyline      m_pObj;     //Containing object. 
 
    public: 
        CConnectionPoint(PCPolyline); 
        ~CConnectionPoint(void); 
 
        //IUnknown members 
        STDMETHODIMP         QueryInterface(REFIID, LPVOID *); 
        STDMETHODIMP_(ULONG) AddRef(void); 
        STDMETHODIMP_(ULONG) Release(void); 
 
        //IConnectionPoint members 
        STDMETHODIMP GetConnectionInterface(IID *); 
        STDMETHODIMP GetConnectionPointContainer 
            (IConnectionPointContainer **); 
        STDMETHODIMP Advise(LPUNKNOWN, DWORD *); 
        STDMETHODIMP Unadvise(DWORD); 
        STDMETHODIMP EnumConnections(IEnumConnections **); 
    }; 
 
 
 
class CImpIPersistStorage : public IPersistStorage 
    { 
    protected: 
        ULONG               m_cRef;      //Interface reference count 
        PCPolyline          m_pObj;      //Back pointer to object 
        LPUNKNOWN           m_pUnkOuter; //Controlling unknown 
        PSSTATE             m_psState;   //Storage state 
 
    public: 
        CImpIPersistStorage(PCPolyline, LPUNKNOWN); 
        ~CImpIPersistStorage(void); 
 
        STDMETHODIMP QueryInterface(REFIID, PPVOID); 
        STDMETHODIMP_(ULONG) AddRef(void); 
        STDMETHODIMP_(ULONG) Release(void); 
 
        STDMETHODIMP GetClassID(LPCLSID); 
 
        STDMETHODIMP IsDirty(void); 
        STDMETHODIMP InitNew(LPSTORAGE); 
        STDMETHODIMP Load(LPSTORAGE); 
        STDMETHODIMP Save(LPSTORAGE, BOOL); 
        STDMETHODIMP SaveCompleted(LPSTORAGE); 
        STDMETHODIMP HandsOffStorage(void); 
    }; 
 
 
class CImpIPersistStreamInit : public IPersistStreamInit 
    { 
    protected: 
        ULONG               m_cRef;      //Interface reference count 
        PCPolyline          m_pObj;      //Back pointer to object 
        LPUNKNOWN           m_pUnkOuter; //Controlling unknown 
 
    public: 
        CImpIPersistStreamInit(PCPolyline, LPUNKNOWN); 
        ~CImpIPersistStreamInit(void); 
 
        STDMETHODIMP QueryInterface(REFIID, PPVOID); 
        STDMETHODIMP_(ULONG) AddRef(void); 
        STDMETHODIMP_(ULONG) Release(void); 
 
        STDMETHODIMP GetClassID(LPCLSID); 
 
        STDMETHODIMP IsDirty(void); 
        STDMETHODIMP Load(LPSTREAM); 
        STDMETHODIMP Save(LPSTREAM, BOOL); 
        STDMETHODIMP GetSizeMax(ULARGE_INTEGER *); 
        STDMETHODIMP InitNew(void); 
    }; 
 
 
//IDATAOBJ.CPP 
class CImpIDataObject : public IDataObject 
    { 
    private: 
        ULONG               m_cRef;      //Interface reference count 
        PCPolyline          m_pObj;      //Back pointer to object 
        LPUNKNOWN           m_pUnkOuter; //Controlling unknown 
 
    public: 
        CImpIDataObject(PCPolyline, LPUNKNOWN); 
        ~CImpIDataObject(void); 
 
        //IUnknown members that delegate to m_pUnkOuter. 
        STDMETHODIMP         QueryInterface(REFIID, PPVOID); 
        STDMETHODIMP_(ULONG) AddRef(void); 
        STDMETHODIMP_(ULONG) Release(void); 
 
        //IDataObject members 
        STDMETHODIMP GetData(LPFORMATETC, LPSTGMEDIUM); 
        STDMETHODIMP GetDataHere(LPFORMATETC, LPSTGMEDIUM); 
        STDMETHODIMP QueryGetData(LPFORMATETC); 
        STDMETHODIMP GetCanonicalFormatEtc(LPFORMATETC,LPFORMATETC); 
        STDMETHODIMP SetData(LPFORMATETC, LPSTGMEDIUM, BOOL); 
        STDMETHODIMP EnumFormatEtc(DWORD, LPENUMFORMATETC *); 
        STDMETHODIMP DAdvise(LPFORMATETC, DWORD, LPADVISESINK 
            , DWORD *); 
        STDMETHODIMP DUnadvise(DWORD); 
        STDMETHODIMP EnumDAdvise(LPENUMSTATDATA *); 
    }; 
 
 
 
//IENUMFE.CPP 
class CEnumFormatEtc : public IEnumFORMATETC 
    { 
    private: 
        ULONG           m_cRef; 
        LPUNKNOWN       m_pUnkRef; 
        ULONG           m_iCur; 
        ULONG           m_cfe; 
        LPFORMATETC     m_prgfe; 
 
    public: 
        CEnumFormatEtc(LPUNKNOWN, ULONG, LPFORMATETC); 
        ~CEnumFormatEtc(void); 
 
        //IUnknown members that delegate to m_pUnkRef. 
        STDMETHODIMP         QueryInterface(REFIID, PPVOID); 
        STDMETHODIMP_(ULONG) AddRef(void); 
        STDMETHODIMP_(ULONG) Release(void); 
 
        //IEnumFORMATETC members 
        STDMETHODIMP Next(ULONG, LPFORMATETC, ULONG *); 
        STDMETHODIMP Skip(ULONG); 
        STDMETHODIMP Reset(void); 
        STDMETHODIMP Clone(IEnumFORMATETC **); 
    }; 
 
 
typedef CEnumFormatEtc *PCEnumFormatEtc; 
 
 
 
class CImpIOleObject : public IOleObject 
    { 
    private: 
        ULONG           m_cRef; 
        PCPolyline      m_pObj; 
        LPUNKNOWN       m_pUnkOuter; 
 
    public: 
        CImpIOleObject(PCPolyline, LPUNKNOWN); 
        ~CImpIOleObject(void); 
 
        //IUnknown members that delegate to m_pUnkOuter. 
        STDMETHODIMP         QueryInterface(REFIID, PPVOID); 
        STDMETHODIMP_(ULONG) AddRef(void); 
        STDMETHODIMP_(ULONG) Release(void); 
 
        //IOleObject members 
        STDMETHODIMP SetClientSite(LPOLECLIENTSITE); 
        STDMETHODIMP GetClientSite(LPOLECLIENTSITE *); 
        STDMETHODIMP SetHostNames(LPCOLESTR, LPCOLESTR); 
        STDMETHODIMP Close(DWORD); 
        STDMETHODIMP SetMoniker(DWORD, LPMONIKER); 
        STDMETHODIMP GetMoniker(DWORD, DWORD, LPMONIKER *); 
        STDMETHODIMP InitFromData(LPDATAOBJECT, BOOL, DWORD); 
        STDMETHODIMP GetClipboardData(DWORD, LPDATAOBJECT *); 
        STDMETHODIMP DoVerb(LONG, LPMSG, LPOLECLIENTSITE, LONG 
                         , HWND, LPCRECT); 
        STDMETHODIMP EnumVerbs(LPENUMOLEVERB *); 
        STDMETHODIMP Update(void); 
        STDMETHODIMP IsUpToDate(void); 
        STDMETHODIMP GetUserClassID(CLSID *); 
        STDMETHODIMP GetUserType(DWORD, LPOLESTR *); 
        STDMETHODIMP SetExtent(DWORD, LPSIZEL); 
        STDMETHODIMP GetExtent(DWORD, LPSIZEL); 
        STDMETHODIMP Advise(LPADVISESINK, DWORD *); 
        STDMETHODIMP Unadvise(DWORD); 
        STDMETHODIMP EnumAdvise(LPENUMSTATDATA *); 
        STDMETHODIMP GetMiscStatus(DWORD, DWORD *); 
        STDMETHODIMP SetColorScheme(LPLOGPALETTE); 
    }; 
 
 
//IVIEWOBJ.CPP 
class CImpIViewObject : public IViewObject2 
    { 
    private: 
        ULONG           m_cRef; 
        PCPolyline      m_pObj; 
        LPUNKNOWN       m_pUnkOuter; 
 
    public: 
        CImpIViewObject(PCPolyline, LPUNKNOWN); 
        ~CImpIViewObject(void); 
 
        //IUnknown members that delegate to m_pUnkOuter. 
        STDMETHODIMP         QueryInterface(REFIID, PPVOID); 
        STDMETHODIMP_(ULONG) AddRef(void); 
        STDMETHODIMP_(ULONG) Release(void); 
 
        //IViewObject members 
        STDMETHODIMP Draw(DWORD, LONG, LPVOID 
            , DVTARGETDEVICE *, HDC, HDC, LPCRECTL 
            , LPCRECTL, BOOL (CALLBACK *)(DWORD), DWORD); 
        STDMETHODIMP GetColorSet(DWORD, LONG, LPVOID 
            , DVTARGETDEVICE *, HDC, LPLOGPALETTE *); 
        STDMETHODIMP Freeze(DWORD, LONG, LPVOID, LPDWORD); 
        STDMETHODIMP Unfreeze(DWORD); 
        STDMETHODIMP SetAdvise(DWORD, DWORD, LPADVISESINK); 
        STDMETHODIMP GetAdvise(LPDWORD, LPDWORD, LPADVISESINK *); 
        STDMETHODIMP GetExtent(DWORD, LONG, DVTARGETDEVICE * 
            , LPSIZEL); 
    }; 
 
 
class CImpIRunnableObject : public IRunnableObject 
    { 
    protected: 
        ULONG           m_cRef; 
        PCPolyline      m_pObj; 
        LPUNKNOWN       m_pUnkOuter; 
 
    public: 
        CImpIRunnableObject(PCPolyline, LPUNKNOWN); 
        ~CImpIRunnableObject(void); 
 
        STDMETHODIMP QueryInterface(REFIID, LPVOID *); 
        STDMETHODIMP_(ULONG) AddRef(void); 
        STDMETHODIMP_(ULONG) Release(void); 
 
        STDMETHODIMP GetRunningClass(LPCLSID); 
        STDMETHODIMP Run(LPBINDCTX); 
        STDMETHODIMP_(BOOL) IsRunning(void); 
        STDMETHODIMP LockRunning(BOOL, BOOL); 
        STDMETHODIMP SetContainedObject(BOOL); 
    }; 
 
 
class CImpIExternalConnection : public IExternalConnection 
    { 
    protected: 
        ULONG           m_cRef; 
        PCPolyline      m_pObj; 
        LPUNKNOWN       m_pUnkOuter; 
        DWORD           m_cLockStrong; 
 
    public: 
        CImpIExternalConnection(PCPolyline, LPUNKNOWN); 
        ~CImpIExternalConnection(void); 
 
        STDMETHODIMP QueryInterface(REFIID, LPVOID *); 
        STDMETHODIMP_(ULONG) AddRef(void); 
        STDMETHODIMP_(ULONG) Release(void); 
 
        STDMETHODIMP_(DWORD) AddConnection(DWORD, DWORD); 
        STDMETHODIMP_(DWORD) ReleaseConnection(DWORD, DWORD, BOOL); 
    }; 
 
 
 
//CHAPTER23MOD 
class CImpIOleInPlaceObject : public IOleInPlaceObject 
    { 
    protected: 
        ULONG               m_cRef; 
        PCPolyline          m_pObj; 
        LPUNKNOWN           m_pUnkOuter; 
 
    public: 
        CImpIOleInPlaceObject(PCPolyline, LPUNKNOWN); 
        ~CImpIOleInPlaceObject(void); 
 
        STDMETHODIMP QueryInterface(REFIID, PPVOID); 
        STDMETHODIMP_(ULONG) AddRef(void); 
        STDMETHODIMP_(ULONG) Release(void); 
 
        STDMETHODIMP GetWindow(HWND *); 
        STDMETHODIMP ContextSensitiveHelp(BOOL); 
        STDMETHODIMP InPlaceDeactivate(void); 
        STDMETHODIMP UIDeactivate(void); 
        STDMETHODIMP SetObjectRects(LPCRECT, LPCRECT); 
        STDMETHODIMP ReactivateAndUndo(void); 
    }; 
 
 
 
class CImpIOleInPlaceActiveObject 
    : public IOleInPlaceActiveObject 
    { 
    protected: 
        ULONG               m_cRef; 
        PCPolyline          m_pObj; 
        LPUNKNOWN           m_pUnkOuter; 
 
    public: 
        CImpIOleInPlaceActiveObject(PCPolyline, LPUNKNOWN); 
        ~CImpIOleInPlaceActiveObject(void); 
 
        STDMETHODIMP QueryInterface(REFIID, PPVOID); 
        STDMETHODIMP_(ULONG) AddRef(void); 
        STDMETHODIMP_(ULONG) Release(void); 
 
        STDMETHODIMP GetWindow(HWND *); 
        STDMETHODIMP ContextSensitiveHelp(BOOL); 
        STDMETHODIMP TranslateAccelerator(LPMSG); 
        STDMETHODIMP OnFrameWindowActivate(BOOL); 
        STDMETHODIMP OnDocWindowActivate(BOOL); 
        STDMETHODIMP ResizeBorder(LPCRECT, LPOLEINPLACEUIWINDOW 
                         , BOOL); 
        STDMETHODIMP EnableModeless(BOOL); 
    }; 
 
 
//End CHAPTER23MOD 
 
#endif  //_POLYLINE_H_