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