home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Windows Gam…ming Gurus (2nd Edition) / Disc2.iso / msdn_vcb / samples / vc98 / sdk / com / tutsamp / perserve / pagelist.h < prev    next >
C/C++ Source or Header  |  1997-08-05  |  11KB  |  283 lines
  1. /*+==========================================================================
  2.   File:      PAGELIST.H
  3.  
  4.   Summary:   Include file for the connectable COPageList COM object class.
  5.  
  6.              COPageList offers a main standard IUnknown interface (basic
  7.              COM object features), an implementation of the standard
  8.              IConnectionPointContainer interface (connectable object
  9.              features), an implementation of the standard IPersistStream
  10.              interface (stream persistence features), and an
  11.              implementation of the custom IPageList interface (drawing
  12.              PageList-related features). This multiple interface COM
  13.              Object Class is achieved via the technique of nested classes.
  14.              The implementation of the various interfaces are nested
  15.              inside of the COPageList Class.
  16.  
  17.              For a comprehensive tutorial code tour of this module's
  18.              contents and offerings see the tutorial PERSERVE.HTM file.
  19.              For more specific technical details on the internal workings
  20.              see the comments dispersed throughout the module's source code.
  21.  
  22.   Functions: .
  23.  
  24.   Classes:   COPageList.
  25.  
  26.   Origin:    2-4-97: atrent - Editor-inheritance from PAPER.H in
  27.              the STOSERVE Tutorial Code Sample.
  28.  
  29. ----------------------------------------------------------------------------
  30.   This file is part of the Microsoft COM Tutorial Code Samples.
  31.  
  32.   Copyright (C) Microsoft Corporation, 1997.  All rights reserved.
  33.  
  34.   This source code is intended only as a supplement to Microsoft
  35.   Development Tools and/or on-line documentation.  See these other
  36.   materials for detailed information regarding Microsoft code samples.
  37.  
  38.   THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY
  39.   KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
  40.   IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
  41.   PARTICULAR PURPOSE.
  42. ==========================================================================+*/
  43.  
  44. #if !defined(PAGELIST_H)
  45. #define PAGELIST_H
  46.  
  47. #ifdef __cplusplus
  48.  
  49.  
  50. // Current format version of PageList is 1.0. Thus, the format version
  51. // is a compile-time constant.
  52. #define PAGELIST_VERSION10 MAKELONG(0,1)
  53.  
  54. // PageList allocation sizes for the Dynamic PageList array.
  55. enum
  56. {
  57.   PAGELIST_ALLOC_INIT = 30,
  58.   PAGELIST_ALLOC = 20
  59. };
  60.  
  61. // Strings used for assembling IStorage/IStream names.
  62. #define DRAWING_STR "Drawing"
  63. #define TEXT_STR    "Text"
  64.  
  65. // The PageList item structure.
  66. typedef struct _PAGEITEM
  67. {
  68.   SHORT     nType;                       // Page Type.
  69.   BOOL      bOpen;                       // Page Open status.
  70.   INT       iPage;                       // Page Number.
  71.   WCHAR     wszDataName[PAGE_NAME_SIZE]; // Page Storage/Stream Data Name.
  72.   WCHAR     wszTitle[PAGE_TITLE_SIZE];   // Page Title.
  73. } PAGEITEM;
  74.  
  75.  
  76. // Properties of the PageList.
  77. typedef struct _PAGELISTPROPS
  78. {
  79.   LONG lPageListVersion;
  80.   LONG lPageListSize;
  81.   LONG lPageNameCounter;
  82.   WCHAR wszTitle[PAGE_TITLE_SIZE];
  83.   WCHAR wszAuthor[PAGE_TITLE_SIZE];
  84.   WCHAR wszReserved1[PAGE_TITLE_SIZE];
  85. } PAGELISTPROPS;
  86.  
  87.  
  88. // PageList event constants.
  89. enum PAGELIST_EVENT
  90. {
  91.   PAGELIST_EVENT_NONE = 0,
  92.   PAGELIST_EVENT_LOADED,
  93.   PAGELIST_EVENT_SAVED,
  94.   PAGELIST_EVENT_CLEARED,
  95.   PAGELIST_EVENT_PAGEADDED,
  96.   PAGELIST_EVENT_PAGEDELETED,
  97.   PAGELIST_EVENT_PAGESET
  98. };
  99.  
  100.  
  101. /*O+O+++O+++O+++O+++O+++O+++O+++O+++O+++O+++O+++O+++O+++O+++O+++O+++O+++O+++O
  102.   ObjectClass: COPageList
  103.  
  104.   Summary:     COM object class for COPageList COM objects.  COM objects
  105.                of this class encapsulate management of a page list. The
  106.                list has items representing user editable pages. The
  107.                mulitple interfaces on this COM object are constructed via
  108.                the nested interface classes technique.
  109.  
  110.   Interfaces:  IUnknown
  111.                  Standard interface providing COM object features.
  112.                IConnectionPointContainer
  113.                  Standard Connection Point container features rendering
  114.                  COPageList objects connectable objects.
  115.                IPersistStream
  116.                  Standard Stream Persistance features.
  117.                IPageList
  118.                  Custom interface providing basic PageList features.
  119.  
  120.   Aggregation: Yes, COPageList COM Objects are aggregatable by passing
  121.                a non-NULL pUnkOuter IUnknown pointer into the constructor.
  122. O---O---O---O---O---O---O---O---O---O---O---O---O---O---O---O---O---O---O-O*/
  123. class COPageList : public IUnknown
  124. {
  125.   public:
  126.     // Main Object Constructor & Destructor.
  127.     COPageList(IUnknown* pUnkOuter, CServer* pServer);
  128.     ~COPageList(void);
  129.  
  130.     // A general public method for initializing this newly created
  131.     // object. Creates any subordinate arrays, structures, or objects.
  132.     // Not exposed as part of an interface. Used by Class Factory.
  133.     HRESULT Init(void);
  134.  
  135.     // Main object IUnknown methods. Non-delegating.
  136.     STDMETHODIMP         QueryInterface(REFIID, PPVOID);
  137.     STDMETHODIMP_(ULONG) AddRef(void);
  138.     STDMETHODIMP_(ULONG) Release(void);
  139.  
  140.   private:
  141.     // We declare nested class interface implementations here.
  142.  
  143.     class CImpIConnectionPointContainer : public IConnectionPointContainer
  144.     {
  145.       public:
  146.         // Interface Implementation Constructor & Destructor.
  147.         CImpIConnectionPointContainer(COPageList* pCO, IUnknown* pUnkOuter);
  148.         ~CImpIConnectionPointContainer(void);
  149.  
  150.         // IUnknown methods.
  151.         STDMETHODIMP         QueryInterface(REFIID, PPVOID);
  152.         STDMETHODIMP_(ULONG) AddRef(void);
  153.         STDMETHODIMP_(ULONG) Release(void);
  154.  
  155.         // IConnectionPointContainer methods.
  156.         STDMETHODIMP         FindConnectionPoint(REFIID, IConnectionPoint**);
  157.         STDMETHODIMP         EnumConnectionPoints(IEnumConnectionPoints**);
  158.  
  159.       private:
  160.         // Data private to this interface implementation.
  161.         COPageList*   m_pCO;          // Parent Object back pointer.
  162.         IUnknown*     m_pUnkOuter;    // Outer unknown for Delegation.
  163.     };
  164.  
  165.     class CImpIPersistStream : public IPersistStream
  166.     {
  167.       public:
  168.         // Interface Implementation Constructor & Destructor.
  169.         CImpIPersistStream(COPageList* pCO, IUnknown* pUnkOuter);
  170.         ~CImpIPersistStream(void);
  171.  
  172.         // IUnknown methods.
  173.         STDMETHODIMP         QueryInterface(REFIID, PPVOID);
  174.         STDMETHODIMP_(ULONG) AddRef(void);
  175.         STDMETHODIMP_(ULONG) Release(void);
  176.  
  177.         // IPersistStream methods.
  178.         STDMETHODIMP         GetClassID(CLSID* pClassID);
  179.         STDMETHODIMP         IsDirty(void);
  180.         STDMETHODIMP         Load(IStream* pIStream);
  181.         STDMETHODIMP         Save(IStream* pIStream, BOOL bClearDirty);
  182.         STDMETHODIMP         GetSizeMax(ULARGE_INTEGER* pcbSize);
  183.  
  184.       private:
  185.         // Data private to this interface implementation.
  186.         COPageList*   m_pCO;          // Parent Object back pointer.
  187.         IUnknown*     m_pUnkOuter;    // Outer unknown for Delegation.
  188.     };
  189.  
  190.     class CImpIPageList : public IPageList
  191.     {
  192.       public:
  193.         // Interface Implementation Constructor & Destructor.
  194.         CImpIPageList(COPageList* pCO, IUnknown* pUnkOuter);
  195.         ~CImpIPageList(void);
  196.  
  197.         // IUnknown methods.
  198.         STDMETHODIMP         QueryInterface(REFIID, PPVOID);
  199.         STDMETHODIMP_(ULONG) AddRef(void);
  200.         STDMETHODIMP_(ULONG) Release(void);
  201.  
  202.         // IPageList methods.
  203.         STDMETHODIMP         Get(
  204.                                  INT     iPage,
  205.                                  BOOL*   pbOpen,
  206.                                  SHORT*  pnType,
  207.                                  WCHAR*  pwszTitle,
  208.                                  WCHAR*  pwszDataName);
  209.         STDMETHODIMP         Set(
  210.                                  INT     iPage,
  211.                                  SHORT   nOpenStatus,
  212.                                  WCHAR*  pwszNewTitle);
  213.         STDMETHODIMP         Add(
  214.                                  INT   iPage,
  215.                                  SHORT nType,
  216.                                  WCHAR* pwszTitle,
  217.                                  INT* piNewPage);
  218.         STDMETHODIMP         Delete(INT iPage);
  219.         STDMETHODIMP         Clear(void);
  220.  
  221.       private:
  222.         // Private utility methods of this interface implementation.
  223.         HRESULT FindSlot(INT iPage, LONG* plSlot);
  224.         HRESULT NextSlot(INT iPage, LONG* plSlot);
  225.         HRESULT NextName(SHORT nType, WCHAR* pwszDataName);
  226.  
  227.         // Data private to this interface implementation of IPageList.
  228.         COPageList*   m_pCO;          // Parent Object back pointer.
  229.         IUnknown*     m_pUnkOuter;    // Outer unknown for Delegation.
  230.     };
  231.  
  232.     // Make the otherwise private and nested interface implementations
  233.     // friends to COM object instantiations of this COM object class.
  234.     friend CImpIConnectionPointContainer;
  235.     friend CImpIPersistStream;
  236.     friend CImpIPageList;
  237.  
  238.     // Private method of main connectable COPageList COM object to
  239.     // broadcast event notifications to all connected listening sinks.
  240.     HRESULT NotifySinks(PAGELIST_EVENT PageListEvent, INT iPage);
  241.  
  242.     // Private method to Clear entire page list array.
  243.     HRESULT Clear(void);
  244.  
  245.     // Private data of COPageList COM objects.
  246.  
  247.     // Nested IConnectionPointContainer implementation instantiation.
  248.     CImpIConnectionPointContainer m_ImpIConnectionPointContainer;
  249.  
  250.     // Nested IPersistStream implementation instantiation.
  251.     CImpIPersistStream m_ImpIPersistStream;
  252.  
  253.     // Nested IPageList implementation instantiation. This IPageList
  254.     // interface is instantiated as a native interface of COPageList.
  255.     CImpIPageList     m_ImpIPageList;
  256.  
  257.     // Main Object reference count.
  258.     ULONG             m_cRefs;
  259.  
  260.     // Outer unknown (aggregation & delegation).
  261.     IUnknown*         m_pUnkOuter;
  262.  
  263.     // Pointer to this component server's control object.
  264.     CServer*          m_pServer;
  265.  
  266.     // The array of connection points for this connectable COM object.
  267.     IConnectionPoint* m_aConnectionPoints[MAX_CONNECTION_POINTS];
  268.  
  269.     // The following private data and methods constitute the working
  270.     // heart of COPageList as an actual application object.
  271.     PAGELISTPROPS     m_PageListProps;// For file storage.
  272.     PAGEITEM*         m_paPageList;   // Dynamic page list array pointer.
  273.     LONG              m_lPageListEnd; // Current end of the page list.
  274.     LONG              m_lPageListMax; // Current end of the page list array.
  275.     BOOL              m_bDirty;       // RAM doesn't match file--save needed.
  276.     CLSID             m_ClassID;      // CLSID of this COM Object.
  277. };
  278.  
  279. #endif // __cplusplus
  280.  
  281.  
  282. #endif // PAGELIST_H
  283.