OBJECT1.H

/* 
 * OBJECT1.H 
 * 
 * Definition of the CObject1 class that uses interface 
 * implementations to provide ISampleOne and ISampleTwo. 
 * 
 * Copyright (c)1993-1995 Microsoft Corporation, All Rights Reserved 
 * 
 * Kraig Brockschmidt, Microsoft 
 * Internet  :  kraigb@microsoft.com 
 * Compuserve:  >INTERNET:kraigb@microsoft.com 
 */ 
 
 
#ifndef _OBJECT1_H_ 
#define _OBJECT1_H_ 
 
 
//Creation function 
BOOL CreateObject1(IUnknown **); 
 
 
/* 
 * The object we want to provide in OLE supports the IUnknown, 
 * ISampleOne, and ISampleTwo interfaces. 
 * 
 * The C++ class, CObject1, implements these interfaces with 
 * "interface implementations" where the C++ class itself inherits 
 * from and implements IUnknown members and then contains 
 * other C++ classes that each separately inherit from the other 
 * interfaces.  The other classes are the "interface implementations." 
 */ 
 
 
/* 
 * In this technique you'll generally need forward references 
 * like this for use in declaring the object class. 
 */ 
class CImpISampleOne; 
typedef CImpISampleOne *PCImpISampleOne; 
 
class CImpISampleTwo; 
typedef CImpISampleTwo *PCImpISampleTwo; 
 
//The C++ class that manages the actual object. 
class CObject1 : public IUnknown 
    { 
    /* 
     * Usually interface implementations will need back pointers 
     * to the object itself since this object usually manages 
     * the important data members.  In that case, make the 
     * interface implementation classes friends of the object. 
     */ 
 
    friend CImpISampleOne; 
    friend CImpISampleTwo; 
 
 
    private: 
        DWORD           m_cRef;         //Object reference count 
 
        /* 
         * I use "m_pImpI" as a prefix to differentiate interface 
         * implementations for this object from other interface 
         * pointer variables I might hold to other objects, whic 
         * would be prefixed with "m_pI". 
         */ 
        PCImpISampleOne  m_pImpISampleOne; 
        PCImpISampleTwo  m_pImpISampleTwo; 
 
    public: 
        CObject1(void); 
        ~CObject1(void); 
 
        BOOL Init(void); 
 
        //IUnknown members 
        STDMETHODIMP         QueryInterface(REFIID, PPVOID); 
        STDMETHODIMP_(DWORD) AddRef(void); 
        STDMETHODIMP_(DWORD) Release(void); 
    }; 
 
 
typedef CObject1 *PCObject1; 
 
 
/* 
 * Interface implementation classes are C++ classes that 
 * each singly inherit from an interface.  Their IUnknown 
 * members delegate calls to CObject1's IUnknown members-- 
 * since IUnknown members affect the entire *object*, and 
 * since these interfaces are not the object itself, we must 
 * delegate to implement the correct behavior. 
 */ 
 
class CImpISampleOne : public ISampleOne 
    { 
    private: 
        DWORD       m_cRef;         //For debugging 
        PCObject1   m_pObj;         //Back pointer for delegation 
 
    public: 
        CImpISampleOne(PCObject1); 
        ~CImpISampleOne(void); 
 
        //IUnknown members 
        STDMETHODIMP         QueryInterface(REFIID, PPVOID); 
        STDMETHODIMP_(DWORD) AddRef(void); 
        STDMETHODIMP_(DWORD) Release(void); 
 
        //ISampleOne members 
        STDMETHODIMP         GetMessage(LPTSTR, UINT); 
    }; 
 
 
 
class CImpISampleTwo : public ISampleTwo 
    { 
    private: 
        DWORD       m_cRef;         //For debugging 
        PCObject1   m_pObj;         //Back pointer for delegation 
 
    public: 
        CImpISampleTwo(PCObject1); 
        ~CImpISampleTwo(void); 
 
        //IUnknown members 
        STDMETHODIMP         QueryInterface(REFIID, PPVOID); 
        STDMETHODIMP_(DWORD) AddRef(void); 
        STDMETHODIMP_(DWORD) Release(void); 
 
        //ISampleTwo members 
        STDMETHODIMP         GetString(LPTSTR, UINT); 
    }; 
 
 
#endif _OBJECT1_H_