object.h

英文版的 想要的话可以下载了 为大家服务

/*
 * OBJECT.H
 *
 * Definition of the classes CConnObject, CImpIConnPtCont, and
 * CEnumConnectionPoints for the connectable object;
 * CConnectionPoint, CImpIConnectionPoint, CImpIDuckEvents, and
 * CEnumConnections for the connection point.
 *
 * Copyright (c)1993-1995 Microsoft Corporation, All Rights Reserved
 *
 * Kraig Brockschmidt, Microsoft
 * Internet  :  [e-mail]
 * Compuserve:  >INTERNET:[e-mail]
 */


#ifndef _OBJECT_H_
#define _OBJECT_H_


//Number of connection points in this implementation
#define CCONNPOINTS     1


/*
 * The connectable object itself implements IUnknown and
 * IConnectionPointContainer.  It is closely associated with
 * the connection point enumerator, CEnumConnectionPoints.
 */

class CConnectionPoint;
typedef CConnectionPoint *PCConnectionPoint;


//ID's for triggering events
enum
    {
    EVENT_QUACK=1, EVENT_FLAP, EVENT_PADDLE
    };


class CConnObject : public IConnectionPointContainer
    {
    private:
        DWORD             m_cRef;         //Object reference count

        //Array holding all the points we have.
        PCConnectionPoint m_rgpConnPt[CCONNPOINTS];

    public:
        CConnObject(void);
        ~CConnObject(void);

        BOOL Init(void);

        //IUnknown members
        STDMETHODIMP         QueryInterface(REFIID, PPVOID);
        STDMETHODIMP_(DWORD) AddRef(void);
        STDMETHODIMP_(DWORD) Release(void);

        //IConnectionPointContainer members
        STDMETHODIMP EnumConnectionPoints(IEnumConnectionPoints **);
	    STDMETHODIMP FindConnectionPoint(REFIID, IConnectionPoint **);

        //Other members
        BOOL TriggerEvent(UINT);
    };


typedef CConnObject *PCConnObject;



//Enumerator class for EnumConnectionPoints

class CEnumConnectionPoints : public IEnumConnectionPoints
    {
    private:
        ULONG           m_cRef;     //Object reference count
        LPUNKNOWN       m_pUnkRef;  //IUnknown for ref counting
        ULONG           m_iCur;     //Current element
        ULONG           m_cPoints;  //Number of conn points
        IConnectionPoint **m_rgpCP; //Source of conn points

    public:
        CEnumConnectionPoints(LPUNKNOWN, ULONG, IConnectionPoint **);
        ~CEnumConnectionPoints(void);

        //IUnknown members that delegate to m_pUnkRef.
        STDMETHODIMP         QueryInterface(REFIID, LPVOID *);
        STDMETHODIMP_(ULONG) AddRef(void);
        STDMETHODIMP_(ULONG) Release(void);

        //IEnumConnectionPoints members
        STDMETHODIMP Next(ULONG, IConnectionPoint **, ULONG *);
        STDMETHODIMP Skip(ULONG);
        STDMETHODIMP Reset(void);
        STDMETHODIMP Clone(IEnumConnectionPoints **);
    };

typedef CEnumConnectionPoints *PCEnumConnectionPoints;




/*
 * The connection point object iself is contained within the
 * connection point container, which is the connectable object.
 * It therefore manages a back pointer to that connectable object,
 * and implement IConnectionPoint.  This object has a few
 * member functions besides those in IConnectionPoint that are
 * used to fire the outgoing calls.
 */

#define CCONNMAX    2

class CConnectionPoint : public IConnectionPoint
    {
    private:
        ULONG           m_cRef;     //Object reference count
        PCConnObject    m_pObj;     //Containing object

        IID             m_iid;      //Our relevant interface

        /*
         * To keep things simple we'll only support two
         * advise connections at most.  Production quality
         * connection points should supprt any number of
         * connections.  For each connection we need to maintain
         * the sink pointer and the cookie assigned to it.
         */
        IUnknown       *m_rgpIUnknown[CCONNMAX];
        DWORD           m_rgdwCookies[CCONNMAX];

        UINT            m_cConn;
        DWORD           m_dwCookieNext; //Counter

    public:
        CConnectionPoint(PCConnObject, REFIID);
        ~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 **);
    };


//Enumeration clas for EnumConnections

class CEnumConnections : public IEnumConnections
    {
    private:
        ULONG           m_cRef;     //Object reference count
        LPUNKNOWN       m_pUnkRef;  //IUnknown for ref counting
        ULONG           m_iCur;     //Current element
        ULONG           m_cConn;    //Number of connections
        LPCONNECTDATA   m_rgConnData; //Source of connections

    public:
        CEnumConnections(LPUNKNOWN, ULONG, LPCONNECTDATA);
        ~CEnumConnections(void);

        //IUnknown members that delegate to m_pUnkRef.
        STDMETHODIMP         QueryInterface(REFIID, LPVOID *);
        STDMETHODIMP_(ULONG) AddRef(void);
        STDMETHODIMP_(ULONG) Release(void);

        //IEnumConnections members
        STDMETHODIMP Next(ULONG, LPCONNECTDATA, ULONG *);
        STDMETHODIMP Skip(ULONG);
        STDMETHODIMP Reset(void);
        STDMETHODIMP Clone(IEnumConnections **);
    };

typedef CEnumConnections *PCEnumConnections;


#endif _OBJECT_H_