// This is a part of the Active Template Library.
// Copyright (C) 1996-1998 Microsoft Corporation
// All rights reserved.
//
// This source code is only intended as a supplement to the
// Active Template Library Reference and related
// electronic documentation provided with the library.
// See these sources for detailed information regarding the
// Active Template Library product.
#ifndef __ATLBASE_H__
#define __ATLBASE_H__
#ifndef __cplusplus
#error ATL requires C++ compilation (use a .cpp suffix)
#endif
#ifndef _ATL_NO_PRAGMA_WARNINGS
#pragma warning(disable: 4201) // nameless unions are part of C++
#pragma warning(disable: 4127) // constant expression
#pragma warning(disable: 4505) // unreferenced local function has been removed
#pragma warning(disable: 4512) // can't generate assignment operator (so what?)
#pragma warning(disable: 4514) // unreferenced inlines are common
#pragma warning(disable: 4103) // pragma pack
#pragma warning(disable: 4702) // unreachable code
#pragma warning(disable: 4237) // bool
#pragma warning(disable: 4710) // function couldn't be inlined
#pragma warning(disable: 4355) // 'this' : used in base member initializer list
#pragma warning(disable: 4097) // typedef name used as synonym for class-name
#pragma warning(disable: 4786) // identifier was truncated in the debug information
#pragma warning(disable: 4268) // const static/global data initialized to zeros
#pragma warning(disable: 4291) // allow placement new
#endif //!_ATL_NO_PRAGMA_WARNINGS
#include
#include
#include
#include
#include
#include
#ifdef new
#pragma push_macro("new")
#define _ATL_REDEF_NEW
#undef new
#endif
#include
#include
#ifndef _ATL_NO_DEBUG_CRT
// Warning: if you define the above symbol, you will have
// to provide your own definition of the ATLASSERT(x) macro
// in order to compile ATL
#include
#endif
#include
#include
#include
#ifdef _DEBUG
#include
#include
#endif
#include
#include
#pragma pack(push, _ATL_PACKING)
#if defined(_ATL_DLL)
#pragma comment(lib, "atl.lib")
#endif
extern "C" const __declspec(selectany) GUID LIBID_ATLLib = {0x44EC0535,0x400F,0x11D0,{0x9D,0xCD,0x00,0xA0,0xC9,0x03,0x91,0xD3}};
extern "C" const __declspec(selectany) CLSID CLSID_Registrar = {0x44EC053A,0x400F,0x11D0,{0x9D,0xCD,0x00,0xA0,0xC9,0x03,0x91,0xD3}};
extern "C" const __declspec(selectany) IID IID_IRegistrar = {0x44EC053B,0x400F,0x11D0,{0x9D,0xCD,0x00,0xA0,0xC9,0x03,0x91,0xD3}};
extern "C" const __declspec(selectany) IID IID_IAxWinHostWindow = {0xb6ea2050,0x48a,0x11d1,{0x82,0xb9,0x0,0xc0,0x4f,0xb9,0x94,0x2e}};
extern "C" const __declspec(selectany) IID IID_IAxWinAmbientDispatch = {0xb6ea2051,0x48a,0x11d1,{0x82,0xb9,0x0,0xc0,0x4f,0xb9,0x94,0x2e}};
extern "C" const __declspec(selectany) IID
IID_IInternalConnection = {0x72AD0770,0x6A9F,0x11d1,{0xBC,0xEC,0x00,0x60,0x08,0x8F,0x44,0x4E}};
extern "C" const __declspec(selectany) IID IID_IDocHostUIHandlerDispatch = {0x425B5AF0,0x65F1,0x11d1,{0x96,0x11,0x00,0x00,0xF8,0x1E,0x0D,0x0D}};
#ifndef _ATL_DLL_IMPL
namespace ATL
{
#endif
struct _ATL_CATMAP_ENTRY
{
int iType;
const CATID* pcatid;
};
#define _ATL_CATMAP_ENTRY_END 0
#define _ATL_CATMAP_ENTRY_IMPLEMENTED 1
#define _ATL_CATMAP_ENTRY_REQUIRED 2
typedef HRESULT (WINAPI _ATL_CREATORFUNC)(void* pv, REFIID riid, LPVOID* ppv);
typedef HRESULT (WINAPI _ATL_CREATORARGFUNC)(void* pv, REFIID riid, LPVOID* ppv, DWORD dw);
typedef HRESULT (WINAPI _ATL_MODULEFUNC)(DWORD dw);
typedef LPCTSTR (WINAPI _ATL_DESCRIPTIONFUNC)();
typedef const struct _ATL_CATMAP_ENTRY* (_ATL_CATMAPFUNC)();
typedef void (__stdcall _ATL_TERMFUNC)(DWORD dw);
struct _ATL_TERMFUNC_ELEM
{
_ATL_TERMFUNC* pFunc;
DWORD dw;
_ATL_TERMFUNC_ELEM* pNext;
};
struct _ATL_OBJMAP_ENTRY
{
const CLSID* pclsid;
HRESULT (WINAPI *pfnUpdateRegistry)(BOOL bRegister);
_ATL_CREATORFUNC* pfnGetClassObject;
_ATL_CREATORFUNC* pfnCreateInstance;
IUnknown* pCF;
DWORD dwRegister;
_ATL_DESCRIPTIONFUNC* pfnGetObjectDescription;
_ATL_CATMAPFUNC* pfnGetCategoryMap;
HRESULT WINAPI RevokeClassObject()
{
return CoRevokeClassObject(dwRegister);
}
HRESULT WINAPI RegisterClassObject(DWORD dwClsContext, DWORD dwFlags)
{
IUnknown* p = NULL;
if (pfnGetClassObject == NULL)
return S_OK;
HRESULT hRes = pfnGetClassObject(pfnCreateInstance, IID_IUnknown, (LPVOID*) &p);
if (SUCCEEDED(hRes))
hRes = CoRegisterClassObject(*pclsid, p, dwClsContext, dwFlags, &dwRegister);
if (p != NULL)
p->Release();
return hRes;
}
// Added in ATL 3.0
void (WINAPI *pfnObjectMain)(bool bStarting);
};
struct _ATL_REGMAP_ENTRY
{
LPCOLESTR szKey;
LPCOLESTR szData;
};
struct _AtlCreateWndData
{
void* m_pThis;
DWORD m_dwThreadID;
_AtlCreateWndData* m_pNext;
};
struct _ATL_MODULE
{
// Attributes
public:
UINT cbSize;
HINSTANCE m_hInst;
HINSTANCE m_hInstResource;
HINSTANCE m_hInstTypeLib;
_ATL_OBJMAP_ENTRY* m_pObjMap;
LONG m_nLockCnt;
HANDLE m_hHeap;
union
{
CRITICAL_SECTION m_csTypeInfoHolder;
CRITICAL_SECTION m_csStaticDataInit;
};
CRITICAL_SECTION m_csWindowCreate;
CRITICAL_SECTION m_csObjMap;
// Original Size = 100
// Stuff added in ATL 3.0
DWORD dwAtlBuildVer;
_AtlCreateWndData* m_pCreateWndList;
bool m_bDestroyHeap;
GUID* pguidVer;
DWORD m_dwHeaps; // Number of heaps we have (-1)
HANDLE* m_phHeaps;
int m_nHeap; // Which heap to choose from
_ATL_TERMFUNC_ELEM* m_pTermFuncs;
};
const int _nAtlModuleVer1Size = 100;
//This define makes debugging asserts easier.
#define _ATL_SIMPLEMAPENTRY ((_ATL_CREATORARGFUNC*)1)
struct _ATL_INTMAP_ENTRY
{
const IID* piid; // the interface id (IID)
DWORD dw;
_ATL_CREATORARGFUNC* pFunc; //NULL:
end, 1:offset, n:ptr
};
/////////////////////////////////////////////////////////////////////////////
// QI Support
ATLAPI AtlInternalQueryInterface(void* pThis,
const _ATL_INTMAP_ENTRY* pEntries, REFIID iid, void** ppvObject);
/////////////////////////////////////////////////////////////////////////////
// Smart Pointer helpers
ATLAPI_(IUnknown*) AtlComPtrAssign(IUnknown** pp, IUnknown* lp);
ATLAPI_(IUnknown*) AtlComQIPtrAssign(IUnknown** pp, IUnknown* lp, REFIID riid);
/////////////////////////////////////////////////////////////////////////////
// Inproc Marshaling helpers
ATLAPI AtlFreeMarshalStream(IStream* pStream);
ATLAPI AtlMarshalPtrInProc(IUnknown* pUnk, const IID& iid, IStream** ppStream);
ATLAPI AtlUnmarshalPtr(IStream* pStream, const IID& iid, IUnknown** ppUnk);
ATLAPI_(BOOL) AtlWaitWithMessageLoop(HANDLE hEvent);
/////////////////////////////////////////////////////////////////////////////
// Connection Point Helpers
ATLAPI AtlAdvise(IUnknown* pUnkCP, IUnknown* pUnk, const IID& iid, LPDWORD pdw);
ATLAPI AtlUnadvise(IUnknown* pUnkCP, const IID& iid, DWORD dw);
/////////////////////////////////////////////////////////////////////////////
// IDispatch Error handling
ATLAPI AtlSetErrorInfo(const CLSID& clsid, LPCOLESTR lpszDesc,
DWORD dwHelpID, LPCOLESTR lpszHelpFile, const IID& iid, HRESULT hRes,
HINSTANCE hInst);
/////////////////////////////////////////////////////////////////////////////
// Module
ATLAPI AtlModuleRegisterClassObjects(_ATL_MODULE* pM, DWORD dwClsContext, DWORD dwFlags);
ATLAPI AtlModuleRevokeClassObjects(_ATL_MODULE* pM);
ATLAPI AtlModuleGetClassObject(_ATL_MODULE* pM, REFCLSID rclsid, REFIID riid, LPVOID* ppv);
ATLAPI AtlModuleRegisterServer(_ATL_MODULE* pM, BOOL bRegTypeLib, const CLSID* pCLSID = NULL);
ATLAPI AtlModuleUnregisterServer(_ATL_MODULE* pM, const CLSID* pCLSID = NULL);
ATLAPI AtlModuleUnregisterServerEx(_ATL_MODULE* pM, BOOL bUnRegTypeLib, const CLSID* pCLSID = NULL);
ATLAPI AtlModuleUpdateRegistryFromResourceD(_ATL_MODULE*pM, LPCOLESTR lpszRes,
BOOL bRegister, struct _ATL_REGMAP_ENTRY* pMapEntries, IRegistrar* pReg = NULL);
ATLAPI AtlModuleRegisterTypeLib(_ATL_MODULE* pM, LPCOLESTR lpszIndex);
ATLAPI AtlModuleUnRegisterTypeLib(_ATL_MODULE* pM, LPCOLESTR lpszIndex);
ATLAPI AtlModuleLoadTypeLib(_ATL_MODULE* pM, LPCOLESTR lpszIndex, BSTR* pbstrPath, ITypeLib** ppTypeLib);
ATLAPI AtlModuleInit(_ATL_MODULE* pM, _ATL_OBJMAP_ENTRY* p, HINSTANCE h);
ATLAPI AtlModuleTerm(_ATL_MODULE* pM);
ATLAPI_(DWORD) AtlGetVersion(void* pReserved);
ATLAPI_(void) AtlModuleAddCreateWndData(_ATL_MODULE* pM, _AtlCreateWndData* pData, void* pObject);
ATLAPI_(void*) AtlModuleExtractCreateWndData(_ATL_MODULE* pM);
ATLAPI AtlModuleAddTermFunc(_ATL_MODULE* pM, _ATL_TERMFUNC* pFunc, DWORD dw);
#ifndef _ATL_DLL_IMPL
}; //namespace ATL
#endif
namespace ATL
{
enum atlTraceFlags
{
// Application defined categories
atlTraceUser = 0x00000001
,
atlTraceUser2 = 0x00000002,
atlTraceUser3 = 0x00000004,
atlTraceUser4 = 0x00000008,
// ATL defined categories
atlTraceGeneral = 0x00000020,
atlTraceCOM = 0x00000040,
atlTraceQI = 0x00000080,
atlTraceRegistrar = 0x00000100,
atlTraceRefcount = 0x00000200,
atlTraceWindowing = 0x00000400,
atlTraceControls = 0x00000800,
atlTraceHosting = 0x00001000,
atlTraceDBClient = 0x00002000,
atlTraceDBProvider = 0x00004000,
atlTraceSnapin = 0x00008000,
atlTraceNotImpl = 0x00010000,
};
#ifndef ATL_TRACE_CATEGORY
#define ATL_TRACE_CATEGORY 0xFFFFFFFF
#endif
#ifdef _DEBUG
#ifndef ATL_TRACE_LEVEL
#define ATL_TRACE_LEVEL 0
#endif
inline void _cdecl AtlTrace(LPCSTR lpszFormat, ...)
{
va_list args;
va_start(args, lpszFormat);
int nBuf;
char szBuffer[512];
nBuf = _vsnprintf(szBuffer, sizeof(szBuffer), lpszFormat, args);
ATLASSERT(nBuf < sizeof(szBuffer)); //Output truncated as it was > sizeof(szBuffer)
OutputDebugStringA(szBuffer);
va_end(args);
}
inline void _cdecl AtlTrace2(DWORD category, UINT level, LPCSTR lpszFormat, ...)
{
if (category & ATL_TRACE_CATEGORY && level <= ATL_TRACE_LEVEL)
{
va_list args;
va_start(args, lpszFormat);
int nBuf;
char szBuffer[512];
nBuf = _vsnprintf(szBuffer, sizeof(szBuffer), lpszFormat, args);
ATLASSERT(nBuf < sizeof(szBuffer)); //Output truncated as it was > sizeof(szBuffer)
OutputDebugStringA("ATL: ");
OutputDebugStringA(szBuffer);
va_end(args);
}
}
#ifndef OLE2ANSI
inline void _cdecl AtlTrace(LPCWSTR lpszFormat, ...)
{
va_list args;
va_start(args, lpszFormat);
int nBuf;
WCHAR szBuffer[512];
nBuf = _vsnwprintf(szBuffer, sizeof(szBuffer) / sizeof(WCHAR), lpszFormat, args);
ATLASSERT(nBuf < sizeof(szBuffer));//Output truncated as it was > sizeof(szBuffer)
OutputDebugStringW(szBuffer);
va_end(args);
}
inline void _cdecl AtlTrace2(DWORD category, UINT level, LPCWSTR lpszFormat, ...)
{
if (category & ATL_TRACE_CATEGORY && level <= ATL_TRACE_LEVEL)
{
va_list args;
va_start(args, lpszFormat);
int nBuf;
WCHAR szBuffer[512];
nBuf = _vsnwprintf(szBuffer, sizeof(szBuffer) / sizeof(WCHAR), lpszFormat, args);
ATLASSERT(nBuf < sizeof(szBuffer));//Output truncated as it was > sizeof(szBuffer)
OutputDebugStringW(L"ATL: ");
OutputDebugStringW(szBuffer);
va_end(args);
}
}
#endif //!OLE2ANSI
#ifndef ATLTRACE
#define ATLTRACE AtlTrace
#define ATLTRACE2 AtlTrace2
#endif
#define ATLTRACENOTIMPL(funcname) ATLTRACE2(atlTraceNotImpl, 2, _T("ATL: %s not implemented.\n"), funcname); return E_NOTIMPL
#else // !DEBUG
inline void _cdecl AtlTrace(LPCSTR , ...){}
inline void _cdecl AtlTrace2(DWORD, UINT, LPCSTR , ...){}
#ifndef OLE2ANSI
inline void _cdecl AtlTrace(LPCWSTR , ...){}
inline void _cdecl AtlTrace2(DWORD, UINT, LPCWSTR , ...){}
#endif //OLE2ANSI
#ifndef ATLTRACE
#define AT
LTRACE 1 ? (void)0 : AtlTrace
#define ATLTRACE2 1 ? (void)0 : AtlTrace2
#endif //ATLTRACE
#define ATLTRACENOTIMPL(funcname) return E_NOTIMPL
#endif //_DEBUG
/////////////////////////////////////////////////////////////////////////////
// Win32 libraries
#pragma comment(lib, "kernel32.lib")
#pragma comment(lib, "user32.lib")
#pragma comment(lib, "olepro32.lib")
#pragma comment(lib, "advapi32.lib")
#pragma comment(lib, "ole32.lib")
#pragma comment(lib, "oleaut32.lib")
#pragma comment(lib, "uuid.lib")
static HRESULT AtlSetChildSite(IUnknown* punkChild, IUnknown* punkParent)
{
if (punkChild == NULL)
return E_POINTER;
HRESULT hr;
IObjectWithSite* pChildSite = NULL;
hr = punkChild->QueryInterface(IID_IObjectWithSite, (void**)&pChildSite);
if (SUCCEEDED(hr) && pChildSite != NULL)
{
hr = pChildSite->SetSite(punkParent);
pChildSite->Release();
}
return hr;
}
template
class _NoAddRefReleaseOnCComPtr : public T
{
private:
STDMETHOD_(ULONG, AddRef)()=0;
STDMETHOD_(ULONG, Release)()=0;
};
template
class CComPtr
{
public:
typedef T _PtrClass;
CComPtr()
{
p=NULL;
}
CComPtr(T* lp)
{
if ((p = lp) != NULL)
p->AddRef();
}
CComPtr(const CComPtr
{
if ((p = lp.p) != NULL)
p->AddRef();
}
~CComPtr()
{
if (p)
p->Release();
}
void Release()
{
IUnknown* pTemp = p;
if (pTemp)
{
p = NULL;
pTemp->Release();
}
}
operator T*() const
{
return (T*)p;
}
T& operator*() const
{
ATLASSERT(p!=NULL);
return *p;
}
//The assert on operator& usually indicates a bug. If this is really
//what is needed, however, take the address of the p member explicitly.
T** operator&()
{
ATLASSERT(p==NULL);
return &p;
}
_NoAddRefReleaseOnCComPtr
{
ATLASSERT(p!=NULL);
return (_NoAddRefReleaseOnCComPtr
}
T* operator=(T* lp)
{
return (T*)AtlComPtrAssign((IUnknown**)&p, lp);
}
T* operator=(const CComPtr
{
return (T*)AtlComPtrAssign((IUnknown**)&p, lp.p);
}
bool operator!() const
{
return (p == NULL);
}
bool operator<(T* pT) const
{
return p < pT;
}
bool operator==(T* pT) const
{
return p == pT;
}
// Compare two objects for equivalence
bool IsEqualObject(IUnknown* pOther)
{
if (p == NULL && pOther == NULL)
return true; // They are both NULL objects
if (p == NULL || pOther == NULL)
return false; // One is NULL the other is not
CComPtr
CComPtr
p->QueryInterface(IID_IUnknown, (void**)&punk1);
pOther->QueryInterface(IID_IUnknown, (void**)&punk2);
return punk1 == punk2;
}
void Attach(T* p2)
{
if (p)
p->Release();
p = p2;
}
T* Detach()
{
T* pt = p;
p = NULL;
return pt;
}
HRESULT CopyTo(T** ppT)
{
ATLASSERT(ppT != NULL);
if (ppT == NULL)
return E_POINTER;
*ppT = p;
if (p)
p->AddRef();
return S_OK;
}
HRESULT SetSite(IUnknown* punkParent)
{
return AtlSetChildSite(p, punkParent);
}
HRESULT Advise(IUnknown* pUnk, const IID& iid, LPDWORD pdw)
{
return AtlAdvise(p, pUnk, iid, pdw);
}
HRESULT CoCreateInstance(REFCLSID rclsid, LPUNKNOWN pUnkOuter = NULL, DWORD dwClsContext = CLSCTX_ALL)
{
ATLASSERT(p == NULL);
return ::CoCreateInstance(rclsid, pUnkOuter, dwClsContext, __uuidof(T), (void**)&p);
}
HRESULT CoCreateInstance(LPCOLESTR szProgID, LPUNKNOWN pUnkOuter = NULL, DWORD dwClsContext = CLSCTX_ALL)
{
CLSID clsid;
HRESULT hr = CLSIDFromProgID(szProgID, &clsid);
ATLASSERT(p == NULL);
if (SUCCEEDED(hr))
hr = ::CoCreateInstance(clsid, pUnkOuter, dwClsContext, __uuidof(T), (void**)&p);
return hr;
}
template
HRESULT QueryInterface(Q** pp) const
{
ATLASSERT(pp != NULL && *pp == NULL);
return p->QueryInterface(__uuidof(Q), (void**)pp);
}
T* p;
};
template
class CComQIPtr
{
public:
typedef T _PtrClass;
CComQIPtr()
{
p=NULL;
}
CComQIPtr(T* lp)
{
if ((p = lp) != NULL)
p->AddRef();
}
CComQIPtr(const CComQIPtr
{
if ((p = lp.p) != NULL)
p->AddRef();
}
CComQIPtr(IUnknown* lp)
{
p=NULL;
if (lp != NULL)
lp->QueryInterface(*piid, (void **)&p);
}
~CComQIPtr()
{
if (p)
p->Release();
}
void Release()
{
IUnknown* pTemp = p;
if (pTemp)
{
p = NULL;
pTemp->Release();
}
}
operator T*() const
{
return p;
}
T& operator*() const
{
ATLASSERT(p!=NULL); return *p;
}
//The assert on operator& usually indicates a bug. If this is really
//what is needed, however, take the address of the p member explicitly.
T** operator&()
{
ATLASSERT(p==NULL);
return &p;
}
_NoAddRefReleaseOnCComPtr
{
ATLASSERT(p!=NULL);
return (_NoAddRefReleaseOnCComPtr
}
T* operator=(T* lp)
{
return (T*)AtlComPtrAssign((IUnknown**)&p, lp);
}
T* operator=(const CComQIPtr
{
return (T*)AtlComPtrAssign((IUnknown**)&p, lp.p);
}
T* operator=(IUnknown* lp)
{
return (T*)AtlComQIPtrAssign((IUnknown**)&p, lp, *piid);
}
bool operator!() const
{
return (p == NULL);
}
bool operator<(T* pT) const
{
return p < pT;
}
bool operator==(T* pT) const
{
return p == pT;
}
// Compare two objects for equivalence
bool IsEqualObject(IUnknown* pOther)
{
if (p == NULL && pOther == NULL)
return true; // They are both NULL objects
if (p == NULL || pOther == NULL)
return false; // One is NULL the other is not
CComPtr
CComPtr
p->QueryInterface(IID_IUnknown, (void**)&punk1);
pOther->QueryInterface(IID_IUnknown, (void**)&punk2);
return punk1 == punk2;
}
void Attach(T* p2)
{
if (p)
p->Release();
p = p2;
}
T* Detach()
{
T* pt = p;
p = NULL;
return pt;
}
HRESULT CopyTo(T** ppT)
{
ATLASSERT(ppT != NULL);
if (ppT == NULL)
return E_POINTER;
*ppT = p;
if (p)
p->AddRef();
return S_OK;
}
HRESULT SetSite(IUnknown* punkParent)
{
return AtlSetChildSite(p, punkParent);
}
HRESULT Advise(IUnknown* pUnk, const IID& iid, LPDWORD pdw)
{
return AtlAdvise(p, pUnk, iid, pdw);
}
HRESULT CoCreateInstance(REFCLSID rclsid, LPUNKNOWN pUnkOuter = NULL, DWORD dwClsContext = CLSCTX_ALL)
{
ATLASSERT(p == NULL);
return ::CoCreateInstance(rclsid, pUnkOuter, dwClsContext, __uuidof(T), (void**)&p);
}
HRESULT CoCreateInstance(LPCOLESTR szProgID, LPUNKNOWN pUnkOuter = NULL, DWORD dwClsContext = CLSCTX_ALL)
{
CLSID clsid;
HRESULT hr = CLSIDFromProgID(szProgID, &clsid);
ATLASSERT(p == NULL);
if (SUCCEEDED(hr))
hr = ::CoCreateInstance(clsid, pUnkOuter, dwClsContext, __uuidof(T), (void**)&p);
return hr;
}
template
HRESULT QueryInterface(Q** pp)
{
ATLASSERT(pp != NULL && *pp == NULL);
return p->QueryInterface(__uuidof(Q), (void**)pp);
}
T* p;
};
//Specialization to make it work
template<>
class CComQIPtr
{
public:
typedef IUnknown _PtrClass;
CComQIPtr()
{
p=NULL;
}
CComQIPtr(IUnknown* lp)
{
//Actually do a QI to get identity
p=NULL;
if (lp != NULL)
lp->QueryInterface(IID_IUnknown, (void **)&p);
}
CComQIPtr(const CComQIPtr
{
if ((p = lp.p) != NULL)
p->AddRef();
}
~CComQIPtr()
{
if (p)
p->Release();
}
void Release()
{
IUnknown* pTemp = p;
if (pTemp)
{
p = NULL;
pTemp->Release();
}
}
operator IUnknown*() const
{
return p;
}
IUnknown& operator*() const
{
ATLASSERT(p!=NULL);
return *p;
}
//The assert on operator& usually indicates a bug. If this is really
//what is needed, however, take the address of the p member explicitly.
IUnknown** operator&()
{
ATLASSERT(p==NULL);
return &p;
}
_NoAddRefReleaseOnCComPtr
{
ATLASSERT(p!=NULL);
return (_NoAddRefReleaseOnCComPtr
}
IUnknown* operator=(IUnknown* lp)
{
//Actually do a QI to get identity
return (IUnknown*)AtlComQIPtrAssign((IUnknown**)&p, lp, IID_IUnknown);
}
IUnknown* operator=(const CComQIPtr
{
return (IUnknown*)AtlComPtrAssign((IUnknown**)&p, lp.p);
}
bool operator!() const
{
return (p == NULL);
}
bool operator<(IUnknown* pT) const
{
return p < pT;
}
bool operator==(IUnknown* pT) const
{
return p == pT;
}
// Compare two objects for equivalence
bool IsEqualObject(IUnknown* pOther)
{
if (p == NULL && pOther == NULL)
return true; // They are both NULL objects
if (p == NULL || pOther == NULL)
return false; // One is NULL the other is not
CComPtr
CComPtr
p->QueryInterface(IID_IUnknown, (void**)&p
unk1);
pOther->QueryInterface(IID_IUnknown, (void**)&punk2);
return punk1 == punk2;
}
IUnknown* Detach()
{
IUnknown* pt = p;
p = NULL;
return pt;
}
HRESULT CopyTo(T** ppT)
{
ATLASSERT(ppT != NULL);
if (ppT == NULL)
return E_POINTER;
*ppT = p;
if (p)
p->AddRef();
return S_OK;
}
HRESULT SetSite(IUnknown* punkParent)
{
return AtlSetChildSite(p, punkParent);
}
HRESULT Advise(IUnknown* pUnk, const IID& iid, LPDWORD pdw)
{
return AtlAdvise(p, pUnk, iid, pdw);
}
HRESULT CoCreateInstance(REFCLSID rclsid, LPUNKNOWN pUnkOuter = NULL, DWORD dwClsContext = CLSCTX_ALL)
{
ATLASSERT(p == NULL);
return ::CoCreateInstance(rclsid, pUnkOuter, dwClsContext, __uuidof(T), (void**)&p);
}
HRESULT CoCreateInstance(LPCOLESTR szProgID, LPUNKNOWN pUnkOuter = NULL, DWORD dwClsContext = CLSCTX_ALL)
{
CLSID clsid;
HRESULT hr = CLSIDFromProgID(szProgID, &clsid);
ATLASSERT(p == NULL);
if (SUCCEEDED(hr))
hr = ::CoCreateInstance(clsid, pUnkOuter, dwClsContext, __uuidof(T), (void**)&p);
return hr;
}
template
HRESULT QueryInterface(Q** pp)
{
ATLASSERT(pp != NULL && *pp == NULL);
return p->QueryInterface(__uuidof(Q), (void**)pp);
}
IUnknown* p;
};
#define com_cast CComQIPtr
/////////////////////////////////////////////////////////////
// Class to Adapt CComBSTR and CComPtr for use with STL containers
// the syntax to use it is
// std::vector< CAdapt
template
class CAdapt
{
public:
CAdapt()
{
}
CAdapt(const T& rSrc)
{
m_T = rSrc;
}
CAdapt(const CAdapt& rSrCA)
{
m_T = rSrCA.m_T;
}
CAdapt& operator=(const T& rSrc)
{
m_T = rSrc;
return *this;
}
bool operator<(const T& rSrc) const
{
return m_T < rSrc;
}
bool operator==(const T& rSrc) const
{
return m_T == rSrc;
}
operator T&()
{
return m_T;
}
operator const T&() const
{
return m_T;
}
T m_T;
};
/////////////////////////////////////////////////////////////////////////////
// GUID comparison
inline BOOL InlineIsEqualGUID(REFGUID rguid1, REFGUID rguid2)
{
return (
((PLONG) &rguid1)[0] == ((PLONG) &rguid2)[0] &&
((PLONG) &rguid1)[1] == ((PLONG) &rguid2)[1] &&
((PLONG) &rguid1)[2] == ((PLONG) &rguid2)[2] &&
((PLONG) &rguid1)[3] == ((PLONG) &rguid2)[3]);
}
inline BOOL InlineIsEqualUnknown(REFGUID rguid1)
{
return (
((PLONG) &rguid1)[0] == 0 &&
((PLONG) &rguid1)[1] == 0 &&
#ifdef _ATL_BYTESWAP
((PLONG) &rguid1)[2] == 0xC0000000 &&
((PLONG) &rguid1)[3] == 0x00000046);
#else
((PLONG) &rguid1)[2] == 0x000000C0 &&
((PLONG) &rguid1)[3] == 0x46000000);
#endif
}
/////////////////////////////////////////////////////////////////////////////
// Threading Model Support
class CComCriticalSection
{
public:
void Lock() {EnterCriticalSection(&m_sec);}
void Unlock() {LeaveCriticalSection(&m_sec);}
void Init() {InitializeCritica
lSection(&m_sec);}
void Term() {DeleteCriticalSection(&m_sec);}
CRITICAL_SECTION m_sec;
};
class CComAutoCriticalSection
{
public:
void Lock() {EnterCriticalSection(&m_sec);}
void Unlock() {LeaveCriticalSection(&m_sec);}
CComAutoCriticalSection() {InitializeCriticalSection(&m_sec);}
~CComAutoCriticalSection() {DeleteCriticalSection(&m_sec);}
CRITICAL_SECTION m_sec;
};
class CComFakeCriticalSection
{
public:
void Lock() {}
void Unlock() {}
void Init() {}
void Term() {}
};
class CComMultiThreadModelNoCS
{
public:
static ULONG WINAPI Increment(LPLONG p) {return InterlockedIncrement(p);}
static ULONG WINAPI Decrement(LPLONG p) {return InterlockedDecrement(p);}
typedef CComFakeCriticalSection AutoCriticalSection;
typedef CComFakeCriticalSection CriticalSection;
typedef CComMultiThreadModelNoCS ThreadModelNoCS;
};
class CComMultiThreadModel
{
public:
static ULONG WINAPI Increment(LPLONG p) {return InterlockedIncrement(p);}
static ULONG WINAPI Decrement(LPLONG p) {return InterlockedDecrement(p);}
typedef CComAutoCriticalSection AutoCriticalSection;
typedef CComCriticalSection CriticalSection;
typedef CComMultiThreadModelNoCS ThreadModelNoCS;
};
class CComSingleThreadModel
{
public:
static ULONG WINAPI Increment(LPLONG p) {return ++(*p);}
static ULONG WINAPI Decrement(LPLONG p) {return --(*p);}
typedef CComFakeCriticalSection AutoCriticalSection;
typedef CComFakeCriticalSection CriticalSection;
typedef CComSingleThreadModel ThreadModelNoCS;
};
#if defined(_ATL_SINGLE_THREADED)
typedef CComSingleThreadModel CComObjectThreadModel;
typedef CComSingleThreadModel CComGlobalsThreadModel;
#elif defined(_ATL_APARTMENT_THREADED)
typedef CComSingleThreadModel CComObjectThreadModel;
typedef CComMultiThreadModel CComGlobalsThreadModel;
#else
typedef CComMultiThreadModel CComObjectThreadModel;
typedef CComMultiThreadModel CComGlobalsThreadModel;
#endif
/////////////////////////////////////////////////////////////////////////////
// CComModule
#define THREADFLAGS_APARTMENT 0x1
#define THREADFLAGS_BOTH 0x2
#define AUTPRXFLAG 0x4
HRESULT WINAPI AtlDumpIID(REFIID iid, LPCTSTR pszClassName, HRESULT hr);
#ifdef _ATL_DEBUG_INTERFACES
struct _QIThunk
{
STDMETHOD(QueryInterface)(REFIID iid, void** pp)
{
ATLASSERT(m_dwRef >= 0);
return pUnk->QueryInterface(iid, pp);
}
STDMETHOD_(ULONG, AddRef)()
{
if (bBreak)
DebugBreak();
pUnk->AddRef();
return InternalAddRef();
}
ULONG InternalAddRef()
{
if (bBreak)
DebugBreak();
ATLASSERT(m_dwRef >= 0);
long l = InterlockedIncrement(&m_dwRef);
ATLTRACE(_T("%d> "), m_dwRef);
AtlDumpIID(iid, lpszClassName, S_OK);
if (l > m_dwMaxRef)
m_dwMaxRef = l;
return l;
}
STDMETHOD_(ULONG, Release)();
STDMETHOD(f3)();
STDMETHOD(f4)();
STDMETHOD(f5)();
STDMETHOD(f6)();
STDMETHOD(f7)();
STDMETHOD(f8)();
STDMETHOD(f9)();
STDMETHOD(f10)();
STDMETHOD(f11)()
;
STDMETHOD(f12)();
STDMETHOD(f13)();
STDMETHOD(f14)();
STDMETHOD(f15)();
STDMETHOD(f16)();
STDMETHOD(f17)();
STDMETHOD(f18)();
STDMETHOD(f19)();
STDMETHOD(f20)();
STDMETHOD(f21)();
STDMETHOD(f22)();
STDMETHOD(f23)();
STDMETHOD(f24)();
STDMETHOD(f25)();
STDMETHOD(f26)();
STDMETHOD(f27)();
STDMETHOD(f28)();
STDMETHOD(f29)();
STDMETHOD(f30)();
STDMETHOD(f31)();
STDMETHOD(f32)();
STDMETHOD(f33)();
STDMETHOD(f34)();
STDMETHOD(f35)();
STDMETHOD(f36)();
STDMETHOD(f37)();
STDMETHOD(f38)();
STDMETHOD(f39)();
STDMETHOD(f40)();
STDMETHOD(f41)();
STDMETHOD(f42)();
STDMETHOD(f43)();
STDMETHOD(f44)();
STDMETHOD(f45)();
STDMETHOD(f46)();
STDMETHOD(f47)();
STDMETHOD(f48)();
STDMETHOD(f49)();
STDMETHOD(f50)();
STDMETHOD(f51)();
STDMETHOD(f52)();
STDMETHOD(f53)();
STDMETHOD(f54)();
STDMETHOD(f55)();
STDMETHOD(f56)();
STDMETHOD(f57)();
STDMETHOD(f58)();
STDMETHOD(f59)();
STDMETHOD(f60)();
STDMETHOD(f61)();
STDMETHOD(f62)();
STDMETHOD(f63)();
STDMETHOD(f64)();
STDMETHOD(f65)();
STDMETHOD(f66)();
STDMETHOD(f67)();
STDMETHOD(f68)();
STDMETHOD(f69)();
STDMETHOD(f70)();
STDMETHOD(f71)();
STDMETHOD(f72)();
STDMETHOD(f73)();
STDMETHOD(f74)();
STDMETHOD(f75)();
STDMETHOD(f76)();
STDMETHOD(f77)();
STDMETHOD(f78)();
STDMETHOD(f79)();
STDMETHOD(f80)();
STDMETHOD(f81)();
STDMETHOD(f82)();
STDMETHOD(f83)();
STDMETHOD(f84)();
STDMETHOD(f85)();
STDMETHOD(f86)();
STDMETHOD(f87)();
STDMETHOD(f88)();
STDMETHOD(f89)();
STDMETHOD(f90)();
STDMETHOD(f91)();
STDMETHOD(f92)();
STDMETHOD(f93)();
STDMETHOD(f94)();
STDMETHOD(f95)();
STDMETHOD(f96)();
STDMETHOD(f97)();
STDMETHOD(f98)();
STDMETHOD(f99)();
STDMETHOD(f100)();
STDMETHOD(f101)();
STDMETHOD(f102)();
STDMETHOD(f103)();
STDMETHOD(f104)();
STDMETHOD(f105)();
STDMETHOD(f106)();
STDMETHOD(f107)();
STDMETHOD(f108)();
STDMETHOD(f109)();
STDMETHOD(f110)();
STDMETHOD(f111)();
STDMETHOD(f112)();
STDMETHOD(f113)();
STDMETHOD(f114)();
STDMETHOD(f115)();
STDMETHOD(f116)();
STDMETHOD(f117)();
STDMETHOD(f118)();
STDMETHOD(f119)();
STDMETHOD(f120)();
STDMETHOD(f121)();
STDMETHOD(f122)();
STDMETHOD(f123)();
STDMETHOD(f124)();
STDMETHOD(f125)();
STDMETHOD(f126)();
STDMETHOD(f127)();
STDMETHOD(f128)();
STDMETHOD(f129)();
STDMETHOD(f130)();
STDMETHOD(f131)();
STDMETHOD(f132)();
STDMETHOD(f133)();
STDMETHOD(f134)();
STDMETHOD(f135)();
STDMETHOD(f136)();
STDMETHOD(f137)();
STDMETHOD(f138)();
STDMETHOD(f139)();
STDMETHOD(f140)();
STDMETHOD(f141)();
STDMETHOD(f142)();
STDMETHOD(f143)();
STDMETHOD(f144)();
STDMETHOD(f145)();
STDMETHOD(f146)();
STDMETHOD(f147)();
STDMETHOD(f148)();
STDMETHOD(f149)();
STDMETHOD(f150)();
STDMETHOD(f151)();
STDMETHOD(f152)();
STDMETHOD(f153)();
STDMETHOD(f154)();
STDMETHOD(f155)();
STDMETHOD(f156)();
STDMETHOD(f157)();
STDMETHOD(f158)();
STDMETHOD(f159)();
STDMETHOD(f160)();
STDMETHOD(f161)();
STDMETHOD(f162)();
STDMETHOD(f163)();
STDMETHOD(f164)();
STDMETHOD(f165)();
STDMETHOD(f166)();
STDMETHOD(f167)();
STDMETHOD(f168)();
STDMETHOD(f169)();
STDMETHOD(f170)();
STDMETHOD(f171)();
STDMETHOD(f172)();
STDMETHOD(f173)();
STDMETHOD(f174)();
STDMETHOD(f175)();
STDMETHOD(f176)();
STDMETHOD(f177)();
STDMETHOD(f178)();
STDMETHOD(f179)();
STDMETHOD(f180)();
STDMETHOD(f181)();
STDMETHOD(f182)();
STDMETHOD(f183)();
STDMETHOD(f184)();
STDMETHOD(f185)();
STDMETHOD(f186)();
STDMETHOD(f187)();
STDMETHOD(f188)();
STDMETHOD(f189)();
STDMETHOD(f190)();
STDMETHOD(f191)();
STDMETHOD(f192)();
STDMETHOD(f193)();
STDMETHOD(f194)();
STDMETHOD(f195)();
STDMETHOD(f196)();
STDMETHOD(f197)();
STDMETHOD(f198)();
STDMETHOD(f199)();
STDMETHOD(f200)();
STDMETHOD(f201)();
STDMETHOD(f202)();
STDMETHOD(f203)();
STDMETHOD(f204)();
STDMETHOD(f205)();
STDMETHOD(f206)();
STDMETHOD(f207)();
STDMETHOD(f208)();
STDMETHOD(f209)();
STDMETHOD(f210)();
STDMETHOD(f211)();
STDMETHOD(f212)();
STDMETHOD(f213)();
STDMETHOD(f214)();
STDMETHOD(f215)();
STDMETHOD(f216)();
STDMETHOD(f217)();
STDMETHOD(f218)();
STDMETHOD(f219)();
STDMETHOD(f220)();
STDMETHOD(f221)();
STDMETHOD(f222)();
STDMETHOD(f223)();
STDMETHOD(f224)();
STDMETHOD(f225)();
STDMETHOD(f226)();
STDMETHOD(f227)();
STDMETHOD(f228)();
STDMETHOD(f229)();
STDMETHOD(f230)();
STDMETHOD(f231)();
STDMETHOD(f232)();
STDMETHOD(f233)();
STDMETHOD(f234)();
STDMETHOD(f235)();
STDMETHOD(f236)();
STDMETHOD(f237)();
STDMETHOD(f238)();
STDMETHOD(f239)();
STDMETHOD(f240)();
STDMETHOD(f241)();
STDMETHOD(f242)();
STDMETHOD(f243)();
STDMETHOD(f244)();
STDMETHOD(f245)();
STDMETHOD(f246)();
STDMETHOD(f247)();
STDMETHOD(f248)();
STDMETHOD(f249)();
STDMETHOD(f250)();
STDMETHOD(f251)();
STDMETHOD(f252)();
STDMETHOD(f253)();
STDMETHOD(f254)();
STDMETHOD(f255)();
STDMETHOD(f256)();
STDMETHOD(f257)();
STDMETHOD(f258)();
STDMETHOD(f259)();
STDMETHOD(f260)();
STDMETHOD(f261)();
STDMETHOD(f262)();
STDMETHOD(f263)();
STDMETHOD(f264)();
STDMETHOD(f265)();
STDMETHOD(f266)();
STDMETHOD(f267)();
STDMETHOD(f268)();
STDMETHOD(f269)();
STDMETHOD(f270)();
STDMETHOD(f271)();
STDMETHOD(f272)();
STDMETHOD(f273)();
STDMETHOD(f274)();
STDMETHOD(f275)();
STDMETHOD(f276)();
STDMETHOD(f277)();
STDMETHOD(f278)();
STDMETHOD(f279)();
STDMETHOD(f280)();
STDMETHOD(f281)();
STDMETHOD(f282)();
STDMETHOD(f283)();
STDMETHOD(f284)();
STDMETHOD(f285)();
STDMETHOD(f286)();
STDMETHOD(f287)();
STDMETHOD(f288)();
STDMETHOD(f289)();
STDMETHOD(f290)();
STDMETHOD(f291)();
STDMETHOD(f292)();
STDMETHOD(f293)();
STDMETHOD(f294)();
STDMETHOD(f295)();
STDMETHOD(f296)();
STDMETHOD(f297)();
STDMETHOD(f298)();
STDMETHOD(f299)();
STDMETHOD(f300)();
STDMETHOD(f301)
();
STDMETHOD(f302)();
STDMETHOD(f303)();
STDMETHOD(f304)();
STDMETHOD(f305)();
STDMETHOD(f306)();
STDMETHOD(f307)();
STDMETHOD(f308)();
STDMETHOD(f309)();
STDMETHOD(f310)();
STDMETHOD(f311)();
STDMETHOD(f312)();
STDMETHOD(f313)();
STDMETHOD(f314)();
STDMETHOD(f315)();
STDMETHOD(f316)();
STDMETHOD(f317)();
STDMETHOD(f318)();
STDMETHOD(f319)();
STDMETHOD(f320)();
STDMETHOD(f321)();
STDMETHOD(f322)();
STDMETHOD(f323)();
STDMETHOD(f324)();
STDMETHOD(f325)();
STDMETHOD(f326)();
STDMETHOD(f327)();
STDMETHOD(f328)();
STDMETHOD(f329)();
STDMETHOD(f330)();
STDMETHOD(f331)();
STDMETHOD(f332)();
STDMETHOD(f333)();
STDMETHOD(f334)();
STDMETHOD(f335)();
STDMETHOD(f336)();
STDMETHOD(f337)();
STDMETHOD(f338)();
STDMETHOD(f339)();
STDMETHOD(f340)();
STDMETHOD(f341)();
STDMETHOD(f342)();
STDMETHOD(f343)();
STDMETHOD(f344)();
STDMETHOD(f345)();
STDMETHOD(f346)();
STDMETHOD(f347)();
STDMETHOD(f348)();
STDMETHOD(f349)();
STDMETHOD(f350)();
STDMETHOD(f351)();
STDMETHOD(f352)();
STDMETHOD(f353)();
STDMETHOD(f354)();
STDMETHOD(f355)();
STDMETHOD(f356)();
STDMETHOD(f357)();
STDMETHOD(f358)();
STDMETHOD(f359)();
STDMETHOD(f360)();
STDMETHOD(f361)();
STDMETHOD(f362)();
STDMETHOD(f363)();
STDMETHOD(f364)();
STDMETHOD(f365)();
STDMETHOD(f366)();
STDMETHOD(f367)();
STDMETHOD(f368)();
STDMETHOD(f369)();
STDMETHOD(f370)();
STDMETHOD(f371)();
STDMETHOD(f372)();
STDMETHOD(f373)();
STDMETHOD(f374)();
STDMETHOD(f375)();
STDMETHOD(f376)();
STDMETHOD(f377)();
STDMETHOD(f378)();
STDMETHOD(f379)();
STDMETHOD(f380)();
STDMETHOD(f381)();
STDMETHOD(f382)();
STDMETHOD(f383)();
STDMETHOD(f384)();
STDMETHOD(f385)();
STDMETHOD(f386)();
STDMETHOD(f387)();
STDMETHOD(f388)();
STDMETHOD(f389)();
STDMETHOD(f390)();
STDMETHOD(f391)();
STDMETHOD(f392)();
STDMETHOD(f393)();
STDMETHOD(f394)();
STDMETHOD(f395)();
STDMETHOD(f396)();
STDMETHOD(f397)();
STDMETHOD(f398)();
STDMETHOD(f399)();
STDMETHOD(f400)();
STDMETHOD(f401)();
STDMETHOD(f402)();
STDMETHOD(f403)();
STDMETHOD(f404)();
STDMETHOD(f405)();
STDMETHOD(f406)();
STDMETHOD(f407)();
STDMETHOD(f408)();
STDMETHOD(f409)();
STDMETHOD(f410)();
STDMETHOD(f411)();
STDMETHOD(f412)();
STDMETHOD(f413)();
STDMETHOD(f414)();
STDMETHOD(f415)();
STDMETHOD(f416)();
STDMETHOD(f417)();
STDMETHOD(f418)();
STDMETHOD(f419)();
STDMETHOD(f420)();
STDMETHOD(f421)();
STDMETHOD(f422)();
STDMETHOD(f423)();
STDMETHOD(f424)();
STDMETHOD(f425)();
STDMETHOD(f426)();
STDMETHOD(f427)();
STDMETHOD(f428)();
STDMETHOD(f429)();
STDMETHOD(f430)();
STDMETHOD(f431)();
STDMETHOD(f432)();
STDMETHOD(f433)();
STDMETHOD(f434)();
STDMETHOD(f435)();
STDMETHOD(f436)();
STDMETHOD(f437)();
STDMETHOD(f438)();
STDMETHOD(f439)();
STDMETHOD(f440)();
STDMETHOD(f441)();
STDMETHOD(f442)();
STDMETHOD(f443)();
STDMETHOD(f4
44)();
STDMETHOD(f445)();
STDMETHOD(f446)();
STDMETHOD(f447)();
STDMETHOD(f448)();
STDMETHOD(f449)();
STDMETHOD(f450)();
STDMETHOD(f451)();
STDMETHOD(f452)();
STDMETHOD(f453)();
STDMETHOD(f454)();
STDMETHOD(f455)();
STDMETHOD(f456)();
STDMETHOD(f457)();
STDMETHOD(f458)();
STDMETHOD(f459)();
STDMETHOD(f460)();
STDMETHOD(f461)();
STDMETHOD(f462)();
STDMETHOD(f463)();
STDMETHOD(f464)();
STDMETHOD(f465)();
STDMETHOD(f466)();
STDMETHOD(f467)();
STDMETHOD(f468)();
STDMETHOD(f469)();
STDMETHOD(f470)();
STDMETHOD(f471)();
STDMETHOD(f472)();
STDMETHOD(f473)();
STDMETHOD(f474)();
STDMETHOD(f475)();
STDMETHOD(f476)();
STDMETHOD(f477)();
STDMETHOD(f478)();
STDMETHOD(f479)();
STDMETHOD(f480)();
STDMETHOD(f481)();
STDMETHOD(f482)();
STDMETHOD(f483)();
STDMETHOD(f484)();
STDMETHOD(f485)();
STDMETHOD(f486)();
STDMETHOD(f487)();
STDMETHOD(f488)();
STDMETHOD(f489)();
STDMETHOD(f490)();
STDMETHOD(f491)();
STDMETHOD(f492)();
STDMETHOD(f493)();
STDMETHOD(f494)();
STDMETHOD(f495)();
STDMETHOD(f496)();
STDMETHOD(f497)();
STDMETHOD(f498)();
STDMETHOD(f499)();
STDMETHOD(f500)();
STDMETHOD(f501)();
STDMETHOD(f502)();
STDMETHOD(f503)();
STDMETHOD(f504)();
STDMETHOD(f505)();
STDMETHOD(f506)();
STDMETHOD(f507)();
STDMETHOD(f508)();
STDMETHOD(f509)();
STDMETHOD(f510)();
STDMETHOD(f511)();
STDMETHOD(f512)();
STDMETHOD(f513)();
STDMETHOD(f514)();
STDMETHOD(f515)();
STDMETHOD(f516)();
STDMETHOD(f517)();
STDMETHOD(f518)();
STDMETHOD(f519)();
STDMETHOD(f520)();
STDMETHOD(f521)();
STDMETHOD(f522)();
STDMETHOD(f523)();
STDMETHOD(f524)();
STDMETHOD(f525)();
STDMETHOD(f526)();
STDMETHOD(f527)();
STDMETHOD(f528)();
STDMETHOD(f529)();
STDMETHOD(f530)();
STDMETHOD(f531)();
STDMETHOD(f532)();
STDMETHOD(f533)();
STDMETHOD(f534)();
STDMETHOD(f535)();
STDMETHOD(f536)();
STDMETHOD(f537)();
STDMETHOD(f538)();
STDMETHOD(f539)();
STDMETHOD(f540)();
STDMETHOD(f541)();
STDMETHOD(f542)();
STDMETHOD(f543)();
STDMETHOD(f544)();
STDMETHOD(f545)();
STDMETHOD(f546)();
STDMETHOD(f547)();
STDMETHOD(f548)();
STDMETHOD(f549)();
STDMETHOD(f550)();
STDMETHOD(f551)();
STDMETHOD(f552)();
STDMETHOD(f553)();
STDMETHOD(f554)();
STDMETHOD(f555)();
STDMETHOD(f556)();
STDMETHOD(f557)();
STDMETHOD(f558)();
STDMETHOD(f559)();
STDMETHOD(f560)();
STDMETHOD(f561)();
STDMETHOD(f562)();
STDMETHOD(f563)();
STDMETHOD(f564)();
STDMETHOD(f565)();
STDMETHOD(f566)();
STDMETHOD(f567)();
STDMETHOD(f568)();
STDMETHOD(f569)();
STDMETHOD(f570)();
STDMETHOD(f571)();
STDMETHOD(f572)();
STDMETHOD(f573)();
STDMETHOD(f574)();
STDMETHOD(f575)();
STDMETHOD(f576)();
STDMETHOD(f577)();
STDMETHOD(f578)();
STDMETHOD(f579)();
STDMETHOD(f580)();
STDMETHOD(f581)();
STDMETHOD(f582)();
STDMETHOD(f583)();
STDMETHOD(f584)();
STDMETHOD(f585)();
STDMETHOD(f586)();
STDMETHOD
(f587)();
STDMETHOD(f588)();
STDMETHOD(f589)();
STDMETHOD(f590)();
STDMETHOD(f591)();
STDMETHOD(f592)();
STDMETHOD(f593)();
STDMETHOD(f594)();
STDMETHOD(f595)();
STDMETHOD(f596)();
STDMETHOD(f597)();
STDMETHOD(f598)();
STDMETHOD(f599)();
STDMETHOD(f600)();
STDMETHOD(f601)();
STDMETHOD(f602)();
STDMETHOD(f603)();
STDMETHOD(f604)();
STDMETHOD(f605)();
STDMETHOD(f606)();
STDMETHOD(f607)();
STDMETHOD(f608)();
STDMETHOD(f609)();
STDMETHOD(f610)();
STDMETHOD(f611)();
STDMETHOD(f612)();
STDMETHOD(f613)();
STDMETHOD(f614)();
STDMETHOD(f615)();
STDMETHOD(f616)();
STDMETHOD(f617)();
STDMETHOD(f618)();
STDMETHOD(f619)();
STDMETHOD(f620)();
STDMETHOD(f621)();
STDMETHOD(f622)();
STDMETHOD(f623)();
STDMETHOD(f624)();
STDMETHOD(f625)();
STDMETHOD(f626)();
STDMETHOD(f627)();
STDMETHOD(f628)();
STDMETHOD(f629)();
STDMETHOD(f630)();
STDMETHOD(f631)();
STDMETHOD(f632)();
STDMETHOD(f633)();
STDMETHOD(f634)();
STDMETHOD(f635)();
STDMETHOD(f636)();
STDMETHOD(f637)();
STDMETHOD(f638)();
STDMETHOD(f639)();
STDMETHOD(f640)();
STDMETHOD(f641)();
STDMETHOD(f642)();
STDMETHOD(f643)();
STDMETHOD(f644)();
STDMETHOD(f645)();
STDMETHOD(f646)();
STDMETHOD(f647)();
STDMETHOD(f648)();
STDMETHOD(f649)();
STDMETHOD(f650)();
STDMETHOD(f651)();
STDMETHOD(f652)();
STDMETHOD(f653)();
STDMETHOD(f654)();
STDMETHOD(f655)();
STDMETHOD(f656)();
STDMETHOD(f657)();
STDMETHOD(f658)();
STDMETHOD(f659)();
STDMETHOD(f660)();
STDMETHOD(f661)();
STDMETHOD(f662)();
STDMETHOD(f663)();
STDMETHOD(f664)();
STDMETHOD(f665)();
STDMETHOD(f666)();
STDMETHOD(f667)();
STDMETHOD(f668)();
STDMETHOD(f669)();
STDMETHOD(f670)();
STDMETHOD(f671)();
STDMETHOD(f672)();
STDMETHOD(f673)();
STDMETHOD(f674)();
STDMETHOD(f675)();
STDMETHOD(f676)();
STDMETHOD(f677)();
STDMETHOD(f678)();
STDMETHOD(f679)();
STDMETHOD(f680)();
STDMETHOD(f681)();
STDMETHOD(f682)();
STDMETHOD(f683)();
STDMETHOD(f684)();
STDMETHOD(f685)();
STDMETHOD(f686)();
STDMETHOD(f687)();
STDMETHOD(f688)();
STDMETHOD(f689)();
STDMETHOD(f690)();
STDMETHOD(f691)();
STDMETHOD(f692)();
STDMETHOD(f693)();
STDMETHOD(f694)();
STDMETHOD(f695)();
STDMETHOD(f696)();
STDMETHOD(f697)();
STDMETHOD(f698)();
STDMETHOD(f699)();
STDMETHOD(f700)();
STDMETHOD(f701)();
STDMETHOD(f702)();
STDMETHOD(f703)();
STDMETHOD(f704)();
STDMETHOD(f705)();
STDMETHOD(f706)();
STDMETHOD(f707)();
STDMETHOD(f708)();
STDMETHOD(f709)();
STDMETHOD(f710)();
STDMETHOD(f711)();
STDMETHOD(f712)();
STDMETHOD(f713)();
STDMETHOD(f714)();
STDMETHOD(f715)();
STDMETHOD(f716)();
STDMETHOD(f717)();
STDMETHOD(f718)();
STDMETHOD(f719)();
STDMETHOD(f720)();
STDMETHOD(f721)();
STDMETHOD(f722)();
STDMETHOD(f723)();
STDMETHOD(f724)();
STDMETHOD(f725)();
STDMETHOD(f726)();
STDMETHOD(f727)();
STDMETHOD(f728)();
STDMETHOD(f729)();
STDMET
HOD(f730)();
STDMETHOD(f731)();
STDMETHOD(f732)();
STDMETHOD(f733)();
STDMETHOD(f734)();
STDMETHOD(f735)();
STDMETHOD(f736)();
STDMETHOD(f737)();
STDMETHOD(f738)();
STDMETHOD(f739)();
STDMETHOD(f740)();
STDMETHOD(f741)();
STDMETHOD(f742)();
STDMETHOD(f743)();
STDMETHOD(f744)();
STDMETHOD(f745)();
STDMETHOD(f746)();
STDMETHOD(f747)();
STDMETHOD(f748)();
STDMETHOD(f749)();
STDMETHOD(f750)();
STDMETHOD(f751)();
STDMETHOD(f752)();
STDMETHOD(f753)();
STDMETHOD(f754)();
STDMETHOD(f755)();
STDMETHOD(f756)();
STDMETHOD(f757)();
STDMETHOD(f758)();
STDMETHOD(f759)();
STDMETHOD(f760)();
STDMETHOD(f761)();
STDMETHOD(f762)();
STDMETHOD(f763)();
STDMETHOD(f764)();
STDMETHOD(f765)();
STDMETHOD(f766)();
STDMETHOD(f767)();
STDMETHOD(f768)();
STDMETHOD(f769)();
STDMETHOD(f770)();
STDMETHOD(f771)();
STDMETHOD(f772)();
STDMETHOD(f773)();
STDMETHOD(f774)();
STDMETHOD(f775)();
STDMETHOD(f776)();
STDMETHOD(f777)();
STDMETHOD(f778)();
STDMETHOD(f779)();
STDMETHOD(f780)();
STDMETHOD(f781)();
STDMETHOD(f782)();
STDMETHOD(f783)();
STDMETHOD(f784)();
STDMETHOD(f785)();
STDMETHOD(f786)();
STDMETHOD(f787)();
STDMETHOD(f788)();
STDMETHOD(f789)();
STDMETHOD(f790)();
STDMETHOD(f791)();
STDMETHOD(f792)();
STDMETHOD(f793)();
STDMETHOD(f794)();
STDMETHOD(f795)();
STDMETHOD(f796)();
STDMETHOD(f797)();
STDMETHOD(f798)();
STDMETHOD(f799)();
STDMETHOD(f800)();
STDMETHOD(f801)();
STDMETHOD(f802)();
STDMETHOD(f803)();
STDMETHOD(f804)();
STDMETHOD(f805)();
STDMETHOD(f806)();
STDMETHOD(f807)();
STDMETHOD(f808)();
STDMETHOD(f809)();
STDMETHOD(f810)();
STDMETHOD(f811)();
STDMETHOD(f812)();
STDMETHOD(f813)();
STDMETHOD(f814)();
STDMETHOD(f815)();
STDMETHOD(f816)();
STDMETHOD(f817)();
STDMETHOD(f818)();
STDMETHOD(f819)();
STDMETHOD(f820)();
STDMETHOD(f821)();
STDMETHOD(f822)();
STDMETHOD(f823)();
STDMETHOD(f824)();
STDMETHOD(f825)();
STDMETHOD(f826)();
STDMETHOD(f827)();
STDMETHOD(f828)();
STDMETHOD(f829)();
STDMETHOD(f830)();
STDMETHOD(f831)();
STDMETHOD(f832)();
STDMETHOD(f833)();
STDMETHOD(f834)();
STDMETHOD(f835)();
STDMETHOD(f836)();
STDMETHOD(f837)();
STDMETHOD(f838)();
STDMETHOD(f839)();
STDMETHOD(f840)();
STDMETHOD(f841)();
STDMETHOD(f842)();
STDMETHOD(f843)();
STDMETHOD(f844)();
STDMETHOD(f845)();
STDMETHOD(f846)();
STDMETHOD(f847)();
STDMETHOD(f848)();
STDMETHOD(f849)();
STDMETHOD(f850)();
STDMETHOD(f851)();
STDMETHOD(f852)();
STDMETHOD(f853)();
STDMETHOD(f854)();
STDMETHOD(f855)();
STDMETHOD(f856)();
STDMETHOD(f857)();
STDMETHOD(f858)();
STDMETHOD(f859)();
STDMETHOD(f860)();
STDMETHOD(f861)();
STDMETHOD(f862)();
STDMETHOD(f863)();
STDMETHOD(f864)();
STDMETHOD(f865)();
STDMETHOD(f866)();
STDMETHOD(f867)();
STDMETHOD(f868)();
STDMETHOD(f869)();
STDMETHOD(f870)();
STDMETHOD(f871)();
STDMETHOD(f872)();
STD
METHOD(f873)();
STDMETHOD(f874)();
STDMETHOD(f875)();
STDMETHOD(f876)();
STDMETHOD(f877)();
STDMETHOD(f878)();
STDMETHOD(f879)();
STDMETHOD(f880)();
STDMETHOD(f881)();
STDMETHOD(f882)();
STDMETHOD(f883)();
STDMETHOD(f884)();
STDMETHOD(f885)();
STDMETHOD(f886)();
STDMETHOD(f887)();
STDMETHOD(f888)();
STDMETHOD(f889)();
STDMETHOD(f890)();
STDMETHOD(f891)();
STDMETHOD(f892)();
STDMETHOD(f893)();
STDMETHOD(f894)();
STDMETHOD(f895)();
STDMETHOD(f896)();
STDMETHOD(f897)();
STDMETHOD(f898)();
STDMETHOD(f899)();
STDMETHOD(f900)();
STDMETHOD(f901)();
STDMETHOD(f902)();
STDMETHOD(f903)();
STDMETHOD(f904)();
STDMETHOD(f905)();
STDMETHOD(f906)();
STDMETHOD(f907)();
STDMETHOD(f908)();
STDMETHOD(f909)();
STDMETHOD(f910)();
STDMETHOD(f911)();
STDMETHOD(f912)();
STDMETHOD(f913)();
STDMETHOD(f914)();
STDMETHOD(f915)();
STDMETHOD(f916)();
STDMETHOD(f917)();
STDMETHOD(f918)();
STDMETHOD(f919)();
STDMETHOD(f920)();
STDMETHOD(f921)();
STDMETHOD(f922)();
STDMETHOD(f923)();
STDMETHOD(f924)();
STDMETHOD(f925)();
STDMETHOD(f926)();
STDMETHOD(f927)();
STDMETHOD(f928)();
STDMETHOD(f929)();
STDMETHOD(f930)();
STDMETHOD(f931)();
STDMETHOD(f932)();
STDMETHOD(f933)();
STDMETHOD(f934)();
STDMETHOD(f935)();
STDMETHOD(f936)();
STDMETHOD(f937)();
STDMETHOD(f938)();
STDMETHOD(f939)();
STDMETHOD(f940)();
STDMETHOD(f941)();
STDMETHOD(f942)();
STDMETHOD(f943)();
STDMETHOD(f944)();
STDMETHOD(f945)();
STDMETHOD(f946)();
STDMETHOD(f947)();
STDMETHOD(f948)();
STDMETHOD(f949)();
STDMETHOD(f950)();
STDMETHOD(f951)();
STDMETHOD(f952)();
STDMETHOD(f953)();
STDMETHOD(f954)();
STDMETHOD(f955)();
STDMETHOD(f956)();
STDMETHOD(f957)();
STDMETHOD(f958)();
STDMETHOD(f959)();
STDMETHOD(f960)();
STDMETHOD(f961)();
STDMETHOD(f962)();
STDMETHOD(f963)();
STDMETHOD(f964)();
STDMETHOD(f965)();
STDMETHOD(f966)();
STDMETHOD(f967)();
STDMETHOD(f968)();
STDMETHOD(f969)();
STDMETHOD(f970)();
STDMETHOD(f971)();
STDMETHOD(f972)();
STDMETHOD(f973)();
STDMETHOD(f974)();
STDMETHOD(f975)();
STDMETHOD(f976)();
STDMETHOD(f977)();
STDMETHOD(f978)();
STDMETHOD(f979)();
STDMETHOD(f980)();
STDMETHOD(f981)();
STDMETHOD(f982)();
STDMETHOD(f983)();
STDMETHOD(f984)();
STDMETHOD(f985)();
STDMETHOD(f986)();
STDMETHOD(f987)();
STDMETHOD(f988)();
STDMETHOD(f989)();
STDMETHOD(f990)();
STDMETHOD(f991)();
STDMETHOD(f992)();
STDMETHOD(f993)();
STDMETHOD(f994)();
STDMETHOD(f995)();
STDMETHOD(f996)();
STDMETHOD(f997)();
STDMETHOD(f998)();
STDMETHOD(f999)();
STDMETHOD(f1000)();
STDMETHOD(f1001)();
STDMETHOD(f1002)();
STDMETHOD(f1003)();
STDMETHOD(f1004)();
STDMETHOD(f1005)();
STDMETHOD(f1006)();
STDMETHOD(f1007)();
STDMETHOD(f1008)();
STDMETHOD(f1009)();
STDMETHOD(f1010)();
STDMETHOD(f1011)();
STDMETHOD(f1012)();
STDMETHOD(f1013)();
STDMETHOD(f1014)();
STDMET
HOD(f1015)();
STDMETHOD(f1016)();
STDMETHOD(f1017)();
STDMETHOD(f1018)();
STDMETHOD(f1019)();
STDMETHOD(f1020)();
STDMETHOD(f1021)();
STDMETHOD(f1022)();
STDMETHOD(f1023)();
STDMETHOD(f1024)();
_QIThunk(IUnknown* pOrig, LPCTSTR p, const IID& i, UINT n, bool b)
{
lpszClassName = p;
iid = i;
nIndex = n;
m_dwRef = 0;
m_dwMaxRef = 0;
pUnk = pOrig;
bBreak = b;
bNonAddRefThunk = false;
}
IUnknown* pUnk;
long m_dwRef;
long m_dwMaxRef;
LPCTSTR lpszClassName;
IID iid;
UINT nIndex;
bool bBreak;
bool bNonAddRefThunk;
void Dump()
{
TCHAR buf[256];
if (m_dwRef != 0)
{
wsprintf(buf, _T("INTERFACE LEAK: RefCount = %d, MaxRefCount = %d, {Allocation = %d} "), m_dwRef, m_dwMaxRef, nIndex);
OutputDebugString(buf);
AtlDumpIID(iid, lpszClassName, S_OK);
}
else
{
wsprintf(buf, _T("NonAddRef Thunk LEAK: {Allocation = %d}\n"), nIndex);
OutputDebugString(buf);
}
}
};
#endif
/////////////////////////////////////////////////////////////////////////////
// Collection helpers - CSimpleArray & CSimpleMap
template
class CSimpleArray
{
public:
T* m_aT;
int m_nSize;
int m_nAllocSize;
// Construction/destruction
CSimpleArray() : m_aT(NULL), m_nSize(0), m_nAllocSize(0)
{ }
~CSimpleArray()
{
RemoveAll();
}
// Operations
int GetSize() const
{
return m_nSize;
}
BOOL Add(T& t)
{
if(m_nSize == m_nAllocSize)
{
T* aT;
int nNewAllocSize = (m_nAllocSize == 0) ? 1 : (m_nSize * 2);
aT = (T*)realloc(m_aT, nNewAllocSize * sizeof(T));
if(aT == NULL)
return FALSE;
m_nAllocSize = nNewAllocSize;
m_aT = aT;
}
m_nSize++;
SetAtIndex(m_nSize - 1, t);
return TRUE;
}
BOOL Remove(T& t)
{
int nIndex = Find(t);
if(nIndex == -1)
return FALSE;
return RemoveAt(nIndex);
}
BOOL RemoveAt(int nIndex)
{
if(nIndex != (m_nSize - 1))
{
m_aT[nIndex].~T();
memmove((void*)&m_aT[nIndex], (void*)&m_aT[nIndex + 1], (m_nSize - (nIndex + 1)) * sizeof(T));
}
m_nSize--;
return TRUE;
}
void RemoveAll()
{
if(m_aT != NULL)
{
for(int i = 0; i < m_nSize; i++)
m_aT[i].~T();
free(m_aT);
m_aT = NULL;
}
m_nSize = 0;
m_nAllocSize = 0;
}
T& operator[] (int nIndex) const
{
ATLASSERT(nIndex >= 0 && nIndex < m_nSize);
return m_aT[nIndex];
}
T* GetData() const
{
return m_aT;
}
// Implementation
class Wrapper
{
public:
Wrapper(T& _t) : t(_t)
{
}
template
void *operator new(size_t, _Ty* p)
{
return p;
}
T t;
};
void SetAtIndex(int nIndex, T& t)
{
ATLASSERT(nIndex >= 0 && nIndex < m_nSize);
new(&m_aT[nIndex]) Wrapper(t);
}
int Find(T& t) const
{
for(int i = 0; i < m_nSize; i++)
{
if(m_aT[i] == t)
return i;
}
return -1; // not found
}
};
// for arrays of simple types
template
class CSimpleValArray : public CSimpleAr
ray< T >
{
public:
BOOL Add(T t)
{
return CSimpleArray< T >::Add(t);
}
BOOL Remove(T t)
{
return CSimpleArray< T >::Remove(t);
}
T operator[] (int nIndex) const
{
return CSimpleArray< T >::operator[](nIndex);
}
};
// intended for small number of simple types or pointers
template
class CSimpleMap
{
public:
TKey* m_aKey;
TVal* m_aVal;
int m_nSize;
// Construction/destruction
CSimpleMap() : m_aKey(NULL), m_aVal(NULL), m_nSize(0)
{ }
~CSimpleMap()
{
RemoveAll();
}
// Operations
int GetSize() const
{
return m_nSize;
}
BOOL Add(TKey key, TVal val)
{
TKey* pKey;
pKey = (TKey*)realloc(m_aKey, (m_nSize + 1) * sizeof(TKey));
if(pKey == NULL)
return FALSE;
m_aKey = pKey;
TVal* pVal;
pVal = (TVal*)realloc(m_aVal, (m_nSize + 1) * sizeof(TVal));
if(pVal == NULL)
return FALSE;
m_aVal = pVal;
m_nSize++;
SetAtIndex(m_nSize - 1, key, val);
return TRUE;
}
BOOL Remove(TKey key)
{
int nIndex = FindKey(key);
if(nIndex == -1)
return FALSE;
if(nIndex != (m_nSize - 1))
{
m_aKey[nIndex].~TKey();
m_aVal[nIndex].~TVal();
memmove((void*)&m_aKey[nIndex], (void*)&m_aKey[nIndex + 1], (m_nSize - (nIndex + 1)) * sizeof(TKey));
memmove((void*)&m_aVal[nIndex], (void*)&m_aVal[nIndex + 1], (m_nSize - (nIndex + 1)) * sizeof(TVal));
}
TKey* pKey;
pKey = (TKey*)realloc(m_aKey, (m_nSize - 1) * sizeof(TKey));
if(pKey != NULL || m_nSize == 1)
m_aKey = pKey;
TVal* pVal;
pVal = (TVal*)realloc(m_aVal, (m_nSize - 1) * sizeof(TVal));
if(pVal != NULL || m_nSize == 1)
m_aVal = pVal;
m_nSize--;
return TRUE;
}
void RemoveAll()
{
if(m_aKey != NULL)
{
for(int i = 0; i < m_nSize; i++)
{
m_aKey[i].~TKey();
m_aVal[i].~TVal();
}
free(m_aKey);
m_aKey = NULL;
}
if(m_aVal != NULL)
{
free(m_aVal);
m_aVal = NULL;
}
m_nSize = 0;
}
BOOL SetAt(TKey key, TVal val)
{
int nIndex = FindKey(key);
if(nIndex == -1)
return FALSE;
SetAtIndex(nIndex, key, val);
return TRUE;
}
TVal Lookup(TKey key) const
{
int nIndex = FindKey(key);
if(nIndex == -1)
return NULL; // must be able to convert
return GetValueAt(nIndex);
}
TKey ReverseLookup(TVal val) const
{
int nIndex = FindVal(val);
if(nIndex == -1)
return NULL; // must be able to convert
return GetKeyAt(nIndex);
}
TKey& GetKeyAt(int nIndex) const
{
ATLASSERT(nIndex >= 0 && nIndex < m_nSize);
return m_aKey[nIndex];
}
TVal& GetValueAt(int nIndex) const
{
ATLASSERT(nIndex >= 0 && nIndex < m_nSize);
return m_aVal[nIndex];
}
// Implementation
template
class Wrapper
{
public:
Wrapper(T& _t) : t(_t)
{
}
template
void *operator new(size_t, _Ty* p)
{
return p;
}
T t;
};
void SetAtIndex(int nIndex, TKey& key, TVal& val)
{
ATLASSERT(nIndex
>= 0 && nIndex < m_nSize);
new(&m_aKey[nIndex]) Wrapper
new(&m_aVal[nIndex]) Wrapper
}
int FindKey(TKey& key) const
{
for(int i = 0; i < m_nSize; i++)
{
if(m_aKey[i] == key)
return i;
}
return -1; // not found
}
int FindVal(TVal& val) const
{
for(int i = 0; i < m_nSize; i++)
{
if(m_aVal[i] == val)
return i;
}
return -1; // not found
}
};
class CComModule;
__declspec(selectany) CComModule* _pModule=NULL;
// {B62F5910-6528-11d1-9611-0000F81E0D0D}
_declspec(selectany) GUID GUID_ATLVer30 = { 0xb62f5910, 0x6528, 0x11d1, { 0x96, 0x11, 0x0, 0x0, 0xf8, 0x1e, 0xd, 0xd } };
class CComModule : public _ATL_MODULE
{
// Operations
public:
static GUID m_libid;
#ifdef _ATL_DEBUG_INTERFACES
UINT m_nIndexQI;
UINT m_nIndexBreakAt;
CSimpleArray<_QIThunk*>* m_paThunks;
#endif // _ATL_DEBUG_INTERFACES
void AddCreateWndData(_AtlCreateWndData* pData, void* pObject)
{
AtlModuleAddCreateWndData(this, pData, pObject);
}
void* ExtractCreateWndData()
{
return AtlModuleExtractCreateWndData(this);
}
HRESULT Init(_ATL_OBJMAP_ENTRY* p, HINSTANCE h, const GUID* plibid = NULL)
{
pguidVer = &GUID_ATLVer30;
_pModule = this;
cbSize = sizeof(_ATL_MODULE);
dwAtlBuildVer = _ATL_VER;
AtlModuleInit(this, p, h);
if (plibid != NULL)
memcpy((void*)&m_libid, plibid, sizeof(GUID));
#ifdef _ATL_MIN_CRT
// Create a base heap
m_hHeap = HeapCreate(0, 0, 0);
#ifndef _ATL_NO_MP_HEAP
OSVERSIONINFO ver;
SYSTEM_INFO si;
memset( &ver, 0, sizeof( ver ) );
ver.dwOSVersionInfoSize = sizeof( ver );
GetVersionEx( &ver );
GetSystemInfo(&si);
if( ((ver.dwPlatformId != VER_PLATFORM_WIN32_NT) ||
(ver.dwMajorVersion < 5)) && (si.dwNumberOfProcessors > 1) )
{
DWORD dwHeaps = si.dwNumberOfProcessors * 2;
m_dwHeaps = 0xFFFFFFFF;
for (int bits = 0; bits < 32; bits++)
{
if (dwHeaps & 0x80000000)
break;
dwHeaps <<= 1;
m_dwHeaps >>= 1;
}
m_dwHeaps >>= 1;
// Allocate more heaps for each processor
m_phHeaps = (HANDLE*) HeapAlloc(m_hHeap, _ATL_HEAPFLAGS, sizeof(HANDLE) * (m_dwHeaps + 1));
for (DWORD i = 0; i <= m_dwHeaps; i++)
m_phHeaps[i] = HeapCreate(0, 0, 0);
}
else
#endif
{
m_phHeaps = NULL;
m_dwHeaps = 0;
}
#endif
#ifdef _ATL_DEBUG_INTERFACES
m_nIndexQI = 0;
m_nIndexBreakAt = 0;
m_paThunks = NULL;
ATLTRY(m_paThunks = new CSimpleArray<_QIThunk*>);
if (m_paThunks == NULL)
return E_OUTOFMEMORY;
#endif // _ATL_DEBUG_INTERFACES
return S_OK;
}
#ifdef _ATL_DEBUG_INTERFACES
HRESULT AddThunk(IUnknown** pp, LPCTSTR lpsz, REFIID iid)
{
if ((pp == NULL) || (*pp == NULL))
return E_POINTER;
IUnknown* p = *pp;
_QIThunk* pThunk = NULL;
EnterCriticalSection(&m_csObjMap);
// Check if exists already for identity
if (InlineIsEqualUnknown(iid))
{
for (int i = 0; i < m_paThunks->GetSize(); i++)
{
if (m_paThunks->operator[](i)->pUnk == p)
{
m_paThunks->operator[](i)->InternalAddRef();
pThunk = m_paThunks->operator[](i);
break;
}
}
}
if (pThunk == NULL)
{
++m_nIndexQI;
if (m_nIndexBreakAt == m_nIndexQI)
DebugBreak();
ATLTRY(pThunk = new _QIThunk(p, lpsz, iid, m_nIndexQI, (m_nIndexBreakAt == m_nIndexQI)));
if (pThunk == NULL)
return E_OUTOFMEMORY;
pThunk->InternalAddRef();
m_paThunks->Add(pThunk);
}
LeaveCriticalSection(&m_csObjMap);
*pp = (IUnknown*)pThunk;
return S_OK;
}
HRESULT AddNonAddRefThunk(IUnknown* p, LPCTSTR lpsz, IUnknown** ppThunkRet)
{
_QIThunk* pThunk = NULL;
EnterCriticalSection(&m_csObjMap);
// Check if exists already for identity
for (int i = 0; i < m_paThunks->GetSize(); i++)
{
if (m_paThunks->operator[](i)->pUnk == p)
{
m_paThunks->operator[](i)->bNonAddRefThunk = true;
pThunk = m_paThunks->operator[](i);
break;
}
}
if (pThunk == NULL)
{
++m_nIndexQI;
if (m_nIndexBreakAt == m_nIndexQI)
DebugBreak();
ATLTRY(pThunk = new _QIThunk(p, lpsz, IID_IUnknown, m_nIndexQI, (m_nIndexBreakAt == m_nIndexQI)));
if (pThunk == NULL)
{
*ppThunkRet = NULL;
return E_OUTOFMEMORY;
}
pThunk->bNonAddRefThunk = true;
m_paThunks->Add(pThunk);
}
LeaveCriticalSection(&m_csObjMap);
*ppThunkRet = (IUnknown*)pThunk;
return S_OK;;
}
void DeleteNonAddRefThunk(IUnknown* pUnk)
{
EnterCriticalSection(&m_csObjMap);
for (int i = 0; i < m_paThunks->GetSize(); i++)
{
if (m_paThunks->operator[](i)->pUnk == pUnk)
{
delete m_paThunks->operator[](i);
m_paThunks->RemoveAt(i);
break;
}
}
LeaveCriticalSection(&m_csObjMap);
}
void DeleteThunk(_QIThunk* p)
{
EnterCriticalSection(&m_csObjMap);
int nIndex = m_paThunks->Find(p);
if (nIndex != -1)
{
delete m_paThunks->operator[](nIndex);
m_paThunks->RemoveAt(nIndex);
}
LeaveCriticalSection(&m_csObjMap);
}
bool DumpLeakedThunks()
{
bool b = false;
for (int i = 0; i < m_paThunks->GetSize(); i++)
{
b = true;
m_paThunks->operator[](i)->Dump();
delete m_paThunks->operator[](i);
}
m_paThunks->RemoveAll();
return b;
}
#endif // _ATL_DEBUG_INTERFACES
void Term()
{
#ifdef _ATL_DEBUG_INTERFACES
m_bDestroyHeap = false; // prevent heap from going away
AtlModuleTerm(this);
DumpLeakedThunks();
delete m_paThunks;
#ifndef _ATL_NO_MP_HEAP
if (m_phHeaps != NULL)
{
for (DWORD i = 0; i <= m_dwHeaps; i++)
HeapDestroy(m_phHeaps[i]);
}
#endif
if (m_hHeap != NULL)
HeapDestroy(m_hHeap);
#else
AtlModuleTerm(this);
#endif // _ATL_DEBUG_INTERFACES
}
HRESULT AddTermFunc(_ATL_TERMFUNC* pFunc, DWORD dw)
{
return AtlModuleAddTermFunc(this, pFunc, dw);
}
LONG Lock()
{
return CComGlobalsThreadModel::Increment(&m_nLockCnt);
}
LONG Unlock()
{
return CComGlo