141 lines
4.4 KiB
C++
141 lines
4.4 KiB
C++
// Copyright 1995-1997 Microsoft Corporation. All Rights Reserved.
|
|
|
|
#if _MSC_VER > 1000
|
|
#pragma once
|
|
#endif
|
|
|
|
#ifndef _UNKNOWN_H_
|
|
#define _UNKNOWN_H_
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// UNKNOWNOBJECTINFO
|
|
//
|
|
// if you want a simple co-creatable object, with no other guarantees about
|
|
// it, then you need to put the following entry in the global table of objects.
|
|
// other object types that are more complex, such as automation objects, and
|
|
// controls, will also use this information...
|
|
|
|
typedef struct {
|
|
|
|
const CLSID *rclsid; // CLSID of your object. ONLY USE IF YOU'RE CoCreatable!
|
|
LPCSTR pszObjectName; // Name of your object. ONLY USE IF YOU'RE CoCreatable!
|
|
IUnknown *(*pfnCreate)(IUnknown *); // pointer to creation fn. ONLY USE IF YOU'RE CoCreatable!
|
|
|
|
} UNKNOWNOBJECTINFO;
|
|
|
|
#define NAMEOFOBJECT(index) (((UNKNOWNOBJECTINFO *)(g_ObjectInfo[(index)]).pInfo)->pszObjectName)
|
|
#define CLSIDOFOBJECT(index) (*(((UNKNOWNOBJECTINFO *)(g_ObjectInfo[(index)]).pInfo)->rclsid))
|
|
#define CREATEFNOFOBJECT(index) (((UNKNOWNOBJECTINFO *)(g_ObjectInfo[(index)]).pInfo)->pfnCreate)
|
|
|
|
#ifndef INITOBJECTS
|
|
|
|
#define DEFINE_UNKNOWNOBJECT(name, clsid, objname, fn) \
|
|
extern UNKNOWNOBJECTINFO name##Object \
|
|
|
|
#else
|
|
#define DEFINE_UNKNOWNOBJECT(name, clsid, objname, fn) \
|
|
UNKNOWNOBJECTINFO name##Object = { clsid, objname, fn } \
|
|
|
|
#endif // INITOBJECTS
|
|
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// DECLARE_STANDARD_UNKNOWN
|
|
//
|
|
// All objects that are going to inherit from CUnknown for their IUnknown
|
|
// implementation should put this in their class declaration instead of the
|
|
// three IUnknown methods.
|
|
//
|
|
#define DECLARE_STANDARD_UNKNOWN() \
|
|
STDMETHOD(QueryInterface)(REFIID riid, void **ppvObjOut) { \
|
|
return ExternalQueryInterface(riid, ppvObjOut); \
|
|
} \
|
|
STDMETHOD_(ULONG, AddRef)(void) { \
|
|
return ExternalAddRef(); \
|
|
} \
|
|
STDMETHOD_(ULONG, Release)(void) { \
|
|
return ExternalRelease(); \
|
|
} \
|
|
|
|
// global variable where we store the current lock count on our DLL. This resides
|
|
// in InProcServer.Cpp
|
|
|
|
extern LONG g_cLocks;
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// this class doesn't inherit from IUnknown since people inheriting from it
|
|
// are going to do so, and just delegate their IUnknown calls to the External*
|
|
// member functions on this object. the internal private unknown object does
|
|
// need to inherit from IUnknown, since it will be used directly as an IUnknown
|
|
// object.
|
|
|
|
class CUnknownObject
|
|
{
|
|
public:
|
|
CUnknownObject(IUnknown *pUnkOuter, void *pvInterface)
|
|
: m_pvInterface(pvInterface),
|
|
m_pUnkOuter((pUnkOuter) ? pUnkOuter : &m_UnkPrivate)
|
|
{ InterlockedIncrement(&g_cLocks); }
|
|
|
|
CUnknownObject(IUnknown *pUnkOuter) {
|
|
m_pUnkOuter = pUnkOuter ? pUnkOuter : &m_UnkPrivate;
|
|
InterlockedIncrement(&g_cLocks);
|
|
}
|
|
virtual ~CUnknownObject() { InterlockedDecrement(&g_cLocks); }
|
|
|
|
// these are all protected so that classes that inherit from this can
|
|
// at get at them.
|
|
|
|
protected:
|
|
// IUnknown methods. these just delegate to the controlling
|
|
// unknown.
|
|
|
|
HRESULT ExternalQueryInterface(REFIID riid, void **ppvObjOut) {
|
|
return m_pUnkOuter->QueryInterface(riid, ppvObjOut);
|
|
}
|
|
ULONG ExternalAddRef(void) {
|
|
return m_pUnkOuter->AddRef();
|
|
}
|
|
ULONG ExternalRelease(void) {
|
|
return m_pUnkOuter->Release();
|
|
}
|
|
|
|
// people should use this during creation to return their private
|
|
// unknown
|
|
//
|
|
inline IUnknown *PrivateUnknown (void) {
|
|
return &m_UnkPrivate;
|
|
}
|
|
|
|
virtual HRESULT InternalQueryInterface(REFIID riid, void **ppvObjOut);
|
|
|
|
IUnknown *m_pUnkOuter; // outer controlling Unknown
|
|
void *m_pvInterface; // the real interface we're working with.
|
|
|
|
private:
|
|
// the inner, private unknown implementation is for the aggregator
|
|
// to control the lifetime of this object, and for those cases where
|
|
// this object isn't aggregated.
|
|
|
|
class CPrivateUnknownObject : public IUnknown {
|
|
public:
|
|
STDMETHOD(QueryInterface)(REFIID riid, void **ppvObjOut);
|
|
STDMETHOD_(ULONG, AddRef)(void);
|
|
STDMETHOD_(ULONG, Release)(void);
|
|
|
|
// constructor is remarkably trivial
|
|
//
|
|
CPrivateUnknownObject() : m_cRef(1) {}
|
|
|
|
private:
|
|
CUnknownObject *m_pMainUnknown();
|
|
ULONG m_cRef;
|
|
} m_UnkPrivate;
|
|
|
|
// so they can reference themselves in CUnknownObject from pMainUnknown()
|
|
|
|
friend class CPrivateUnknownObject;
|
|
};
|
|
|
|
#endif // _UNKNOWN_H_
|