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 / chap10 / polyline / polyline.h < prev    next >
Encoding:
C/C++ Source or Header  |  1995-05-03  |  11.1 KB  |  383 lines
  1. /*
  2.  * POLYLINE.H
  3.  * Polyline Component Chapter 10
  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. //CHAPTER10MOD
  21. #define CHAPTER10
  22. #include <inole.h>
  23. #include <ipoly10.h>
  24. #include "resource.h"
  25. //End CHAPTER10MOD
  26.  
  27.  
  28. //Classname
  29. #define SZCLASSPOLYLINE             TEXT("polyline")
  30.  
  31. //Stream Name that holds the data
  32. #define SZSTREAM                    OLETEXT("CONTENTS")
  33.  
  34.  
  35. #define HIMETRIC_PER_INCH           2540
  36. #define CCHPATHMAX                  256
  37.  
  38. //Window extra bytes and offsets
  39. #define CBPOLYLINEWNDEXTRA          (sizeof(LONG))
  40. #define PLWL_STRUCTURE              0
  41.  
  42.  
  43. //DLLPOLY.CPP
  44. int PASCAL LibMain(HINSTANCE, WORD, WORD, LPSTR);
  45.  
  46. //This class factory object creates Polyline objects.
  47.  
  48. class CPolylineClassFactory : public IClassFactory
  49.     {
  50.     protected:
  51.         ULONG           m_cRef;
  52.  
  53.     public:
  54.         CPolylineClassFactory(void);
  55.         ~CPolylineClassFactory(void);
  56.  
  57.         //IUnknown members
  58.         STDMETHODIMP QueryInterface(REFIID, PPVOID);
  59.         STDMETHODIMP_(ULONG) AddRef(void);
  60.         STDMETHODIMP_(ULONG) Release(void);
  61.  
  62.         //IClassFactory members
  63.         STDMETHODIMP         CreateInstance(LPUNKNOWN, REFIID
  64.                                  , PPVOID);
  65.         STDMETHODIMP         LockServer(BOOL);
  66.     };
  67.  
  68. typedef CPolylineClassFactory *PCPolylineClassFactory;
  69.  
  70.  
  71.  
  72. //POLYWIN.CPP
  73. LRESULT APIENTRY PolylineWndProc(HWND, UINT, WPARAM, LPARAM);
  74.  
  75.  
  76. //Forward class references
  77. class CImpIPolyline;
  78. typedef class CImpIPolyline *PCImpIPolyline;
  79.  
  80. class CImpIConnPtCont;
  81. typedef CImpIConnPtCont *PCImpIConnPtCont;
  82.  
  83. class CConnectionPoint;
  84. typedef CConnectionPoint *PCConnectionPoint;
  85.  
  86. class CImpIPersistStorage;
  87. typedef class CImpIPersistStorage *PCImpIPersistStorage;
  88.  
  89. class CImpIPersistStreamInit;
  90. typedef class CImpIPersistStreamInit *PCImpIPersistStreamInit;
  91.  
  92.  
  93. //CHAPTER10MOD
  94. class CImpIDataObject;
  95. typedef class CImpIDataObject *PCImpIDataObject;
  96.  
  97. #define CFORMATETCGET       3
  98. #define CFORMATETCSET       1
  99. //End CHAPTER10MOD
  100.  
  101.  
  102. //POLYLINE.CPP
  103. class CPolyline : public IUnknown
  104.     {
  105.     friend LRESULT APIENTRY PolylineWndProc(HWND, UINT, WPARAM
  106.         , LPARAM);
  107.  
  108.     friend class CImpIPolyline;
  109.     friend class CImpIConnPtCont;
  110.     friend class CConnectionPoint;
  111.     friend class CImpIPersistStorage;
  112.     friend class CImpIPersistStreamInit;
  113.  
  114.     //CHAPTER10MOD
  115.     friend class CImpIDataObject;
  116.     //End CHAPTER10MOD
  117.  
  118.     protected:
  119.         HWND            m_hWnd;
  120.         HINSTANCE       m_hInst;
  121.  
  122.         ULONG           m_cRef;         //Object reference count
  123.         LPUNKNOWN       m_pUnkOuter;    //Controlling Unknown
  124.         PFNDESTROYED    m_pfnDestroy;   //Function called on closure
  125.         BOOL            m_fDirty;       //Have we changed?
  126.         POLYLINEDATA    m_pl;           //Our actual data
  127.  
  128.         //Contained interfaces
  129.         PCImpIPolyline          m_pImpIPolyline;
  130.         PCImpIConnPtCont        m_pImpIConnPtCont;
  131.         PCImpIPersistStorage    m_pImpIPersistStorage;
  132.         PCImpIPersistStreamInit m_pImpIPersistStreamInit;
  133.         //CHAPTER10MOD
  134.         PCImpIDataObject        m_pImpIDataObject;
  135.         //End CHAPTER10MOD
  136.  
  137.         /*
  138.          * Connected sink:  only one per object.  We get this
  139.          * through our connection point.
  140.          */
  141.         //CHAPTER10MOD
  142.         IPolylineAdviseSink10  *m_pAdv;
  143.         //End CHAPTER10MOD
  144.         PCConnectionPoint       m_pConnPt;
  145.  
  146.         PCStringTable   m_pST;          //Object strings
  147.         UINT            m_cf;           //Object clipboard format
  148.         CLSID           m_clsID;        //Current CLSID
  149.  
  150.         //We have to hold these for IPersistStorage::Save
  151.         LPSTORAGE       m_pIStorage;
  152.         LPSTREAM        m_pIStream;
  153.  
  154.         //CHAPTER10MOD
  155.         LPDATAADVISEHOLDER  m_pIDataAdviseHolder;
  156.         //End CHAPTER10MOD
  157.  
  158.  
  159.     protected:
  160.         void      PointScale(LPRECT, LPPOINTS, BOOL);
  161.         void      Draw(HDC, BOOL, BOOL);
  162.         void      RectConvertMappings(LPRECT, BOOL);
  163.  
  164.         //CHAPTER10MOD
  165.         /*
  166.          * These members pulled from IPolyline now serve as a
  167.          * central store for this functionality to be used from
  168.          * other interfaces like IPersistStorage and IDataObject.
  169.          * Other interfaces later may also use them.
  170.          */
  171.         STDMETHODIMP DataSet(PPOLYLINEDATA, BOOL, BOOL);
  172.         STDMETHODIMP DataGet(PPOLYLINEDATA);
  173.  
  174.         STDMETHODIMP RenderNative(HGLOBAL *);
  175.         STDMETHODIMP RenderBitmap(HBITMAP *);
  176.         STDMETHODIMP RenderMetafilePict(HGLOBAL *);
  177.         //End CHAPTER10MOD
  178.  
  179.  
  180.     public:
  181.         CPolyline(LPUNKNOWN, PFNDESTROYED, HINSTANCE);
  182.         ~CPolyline(void);
  183.  
  184.         BOOL      Init(void);
  185.  
  186.         //Non-delegating object IUnknown
  187.         STDMETHODIMP QueryInterface(REFIID, PPVOID);
  188.         STDMETHODIMP_(ULONG) AddRef(void);
  189.         STDMETHODIMP_(ULONG) Release(void);
  190.     };
  191.  
  192. typedef CPolyline *PCPolyline;
  193.  
  194.  
  195.  
  196.  
  197. //Interface implementations contained in the Polyline.
  198.  
  199. //CHPATER10MOD
  200. class CImpIPolyline : public IPolyline10
  201. //End CHAPTER10MOD
  202.     {
  203.     protected:
  204.         ULONG               m_cRef;      //Interface ref count
  205.         PCPolyline          m_pObj;      //Backpointer to object
  206.         LPUNKNOWN           m_pUnkOuter; //Controlling unknown
  207.  
  208.     public:
  209.         CImpIPolyline(PCPolyline, LPUNKNOWN);
  210.         ~CImpIPolyline(void);
  211.  
  212.         //IUnknown members.
  213.         STDMETHODIMP QueryInterface(REFIID, PPVOID);
  214.         STDMETHODIMP_(ULONG) AddRef(void);
  215.         STDMETHODIMP_(ULONG) Release(void);
  216.  
  217.         //CHAPTER10MOD
  218.         //Data* and Render* replaced with IDataObject
  219.         //End CHAPTER10MOD
  220.  
  221.         //Manipulation members:
  222.         STDMETHODIMP Init(HWND, LPRECT, DWORD, UINT);
  223.         STDMETHODIMP New(void);
  224.         STDMETHODIMP Undo(void);
  225.         STDMETHODIMP Window(HWND *);
  226.  
  227.         STDMETHODIMP RectGet(LPRECT);
  228.         STDMETHODIMP SizeGet(LPRECT);
  229.         STDMETHODIMP RectSet(LPRECT, BOOL);
  230.         STDMETHODIMP SizeSet(LPRECT, BOOL);
  231.  
  232.         STDMETHODIMP ColorSet(UINT, COLORREF, COLORREF *);
  233.         STDMETHODIMP ColorGet(UINT, COLORREF *);
  234.  
  235.         STDMETHODIMP LineStyleSet(UINT, UINT *);
  236.         STDMETHODIMP LineStyleGet(UINT *);
  237.     };
  238.  
  239.  
  240. class CImpIConnPtCont : public IConnectionPointContainer
  241.     {
  242.     private:
  243.         ULONG               m_cRef;      //Interface ref count
  244.         PCPolyline          m_pObj;      //Back pointer to object
  245.         LPUNKNOWN           m_pUnkOuter; //Controlling unknown
  246.  
  247.     public:
  248.         CImpIConnPtCont(PCPolyline, LPUNKNOWN);
  249.         ~CImpIConnPtCont(void);
  250.  
  251.         //IUnknown members
  252.         STDMETHODIMP         QueryInterface(REFIID, PPVOID);
  253.         STDMETHODIMP_(DWORD) AddRef(void);
  254.         STDMETHODIMP_(DWORD) Release(void);
  255.  
  256.         //IConnectionPointContainer members
  257.         STDMETHODIMP EnumConnectionPoints(IEnumConnectionPoints **);
  258.         STDMETHODIMP FindConnectionPoint(REFIID, IConnectionPoint **);
  259.     };
  260.  
  261.  
  262. /*
  263.  * This connection point will only allow one connection,
  264.  * so it always returns the same connection key.  It also
  265.  * doesn't bother to implement enumerations.
  266.  */
  267.  
  268. #define CCONNMAX    1
  269. #define ADVISEKEY   72388       //Arbitrary
  270.  
  271. class CConnectionPoint : public IConnectionPoint
  272.     {
  273.     private:
  274.         ULONG           m_cRef;     //Object reference count
  275.         PCPolyline      m_pObj;     //Containing object.
  276.  
  277.     public:
  278.         CConnectionPoint(PCPolyline);
  279.         ~CConnectionPoint(void);
  280.  
  281.         //IUnknown members
  282.         STDMETHODIMP         QueryInterface(REFIID, LPVOID *);
  283.         STDMETHODIMP_(ULONG) AddRef(void);
  284.         STDMETHODIMP_(ULONG) Release(void);
  285.  
  286.         //IConnectionPoint members
  287.         STDMETHODIMP GetConnectionInterface(IID *);
  288.         STDMETHODIMP GetConnectionPointContainer
  289.             (IConnectionPointContainer **);
  290.         STDMETHODIMP Advise(LPUNKNOWN, DWORD *);
  291.         STDMETHODIMP Unadvise(DWORD);
  292.         STDMETHODIMP EnumConnections(IEnumConnections **);
  293.     };
  294.  
  295.  
  296.  
  297. class CImpIPersistStorage : public IPersistStorage
  298.     {
  299.     protected:
  300.         ULONG               m_cRef;      //Interface reference count
  301.         PCPolyline          m_pObj;      //Back pointer to object
  302.         LPUNKNOWN           m_pUnkOuter; //Controlling unknown
  303.         PSSTATE             m_psState;   //Storage state
  304.  
  305.     public:
  306.         CImpIPersistStorage(PCPolyline, LPUNKNOWN);
  307.         ~CImpIPersistStorage(void);
  308.  
  309.         STDMETHODIMP QueryInterface(REFIID, PPVOID);
  310.         STDMETHODIMP_(ULONG) AddRef(void);
  311.         STDMETHODIMP_(ULONG) Release(void);
  312.  
  313.         STDMETHODIMP GetClassID(LPCLSID);
  314.  
  315.         STDMETHODIMP IsDirty(void);
  316.         STDMETHODIMP InitNew(LPSTORAGE);
  317.         STDMETHODIMP Load(LPSTORAGE);
  318.         STDMETHODIMP Save(LPSTORAGE, BOOL);
  319.         STDMETHODIMP SaveCompleted(LPSTORAGE);
  320.         STDMETHODIMP HandsOffStorage(void);
  321.     };
  322.  
  323.  
  324. class CImpIPersistStreamInit : public IPersistStreamInit
  325.     {
  326.     protected:
  327.         ULONG               m_cRef;      //Interface reference count
  328.         PCPolyline          m_pObj;      //Back pointer to object
  329.         LPUNKNOWN           m_pUnkOuter; //Controlling unknown
  330.  
  331.     public:
  332.         CImpIPersistStreamInit(PCPolyline, LPUNKNOWN);
  333.         ~CImpIPersistStreamInit(void);
  334.  
  335.         STDMETHODIMP QueryInterface(REFIID, PPVOID);
  336.         STDMETHODIMP_(ULONG) AddRef(void);
  337.         STDMETHODIMP_(ULONG) Release(void);
  338.  
  339.         STDMETHODIMP GetClassID(LPCLSID);
  340.  
  341.         STDMETHODIMP IsDirty(void);
  342.         STDMETHODIMP Load(LPSTREAM);
  343.         STDMETHODIMP Save(LPSTREAM, BOOL);
  344.         STDMETHODIMP GetSizeMax(ULARGE_INTEGER *);
  345.         STDMETHODIMP InitNew(void);
  346.     };
  347.  
  348.  
  349. //CHAPTER10MOD
  350. //IDATAOBJ.CPP
  351. class CImpIDataObject : public IDataObject
  352.     {
  353.     private:
  354.         ULONG               m_cRef;      //Interface reference count
  355.         PCPolyline          m_pObj;      //Back pointer to object
  356.         LPUNKNOWN           m_pUnkOuter; //Controlling unknown
  357.  
  358.     public:
  359.         CImpIDataObject(PCPolyline, LPUNKNOWN);
  360.         ~CImpIDataObject(void);
  361.  
  362.         //IUnknown members that delegate to m_pUnkOuter.
  363.         STDMETHODIMP         QueryInterface(REFIID, PPVOID);
  364.         STDMETHODIMP_(ULONG) AddRef(void);
  365.         STDMETHODIMP_(ULONG) Release(void);
  366.  
  367.         //IDataObject members
  368.         STDMETHODIMP GetData(LPFORMATETC, LPSTGMEDIUM);
  369.         STDMETHODIMP GetDataHere(LPFORMATETC, LPSTGMEDIUM);
  370.         STDMETHODIMP QueryGetData(LPFORMATETC);
  371.         STDMETHODIMP GetCanonicalFormatEtc(LPFORMATETC,LPFORMATETC);
  372.         STDMETHODIMP SetData(LPFORMATETC, LPSTGMEDIUM, BOOL);
  373.         STDMETHODIMP EnumFormatEtc(DWORD, LPENUMFORMATETC *);
  374.         STDMETHODIMP DAdvise(LPFORMATETC, DWORD, LPADVISESINK
  375.             , DWORD *);
  376.         STDMETHODIMP DUnadvise(DWORD);
  377.         STDMETHODIMP EnumDAdvise(LPENUMSTATDATA *);
  378.     };
  379.  
  380. //End CHAPTER10MOD
  381.  
  382. #endif  //_POLYLINE_H_
  383.