2022-11-12 09:45:35 +00:00
|
|
|
// MyCom.h
|
|
|
|
|
2023-09-14 16:51:54 +01:00
|
|
|
#ifndef ZIP7_INC_MY_COM_H
|
|
|
|
#define ZIP7_INC_MY_COM_H
|
2022-11-12 09:45:35 +00:00
|
|
|
|
|
|
|
#include "MyWindows.h"
|
2023-09-14 16:51:54 +01:00
|
|
|
#include "MyTypes.h"
|
2022-11-12 09:45:35 +00:00
|
|
|
|
|
|
|
template <class T>
|
|
|
|
class CMyComPtr
|
|
|
|
{
|
|
|
|
T* _p;
|
|
|
|
public:
|
2023-09-14 16:51:54 +01:00
|
|
|
CMyComPtr(): _p(NULL) {}
|
|
|
|
CMyComPtr(T* p) throw() { if ((_p = p) != NULL) p->AddRef(); }
|
|
|
|
CMyComPtr(const CMyComPtr<T>& lp) throw() { if ((_p = lp._p) != NULL) _p->AddRef(); }
|
2022-11-12 09:45:35 +00:00
|
|
|
~CMyComPtr() { if (_p) _p->Release(); }
|
|
|
|
void Release() { if (_p) { _p->Release(); _p = NULL; } }
|
|
|
|
operator T*() const { return (T*)_p; }
|
|
|
|
// T& operator*() const { return *_p; }
|
|
|
|
T** operator&() { return &_p; }
|
|
|
|
T* operator->() const { return _p; }
|
|
|
|
T* operator=(T* p)
|
|
|
|
{
|
2023-09-14 16:51:54 +01:00
|
|
|
if (p)
|
2022-11-12 09:45:35 +00:00
|
|
|
p->AddRef();
|
|
|
|
if (_p)
|
|
|
|
_p->Release();
|
|
|
|
_p = p;
|
|
|
|
return p;
|
|
|
|
}
|
|
|
|
T* operator=(const CMyComPtr<T>& lp) { return (*this = lp._p); }
|
|
|
|
bool operator!() const { return (_p == NULL); }
|
|
|
|
// bool operator==(T* pT) const { return _p == pT; }
|
|
|
|
void Attach(T* p2)
|
|
|
|
{
|
|
|
|
Release();
|
|
|
|
_p = p2;
|
|
|
|
}
|
|
|
|
T* Detach()
|
|
|
|
{
|
|
|
|
T* pt = _p;
|
|
|
|
_p = NULL;
|
|
|
|
return pt;
|
|
|
|
}
|
|
|
|
#ifdef _WIN32
|
|
|
|
HRESULT CoCreateInstance(REFCLSID rclsid, REFIID iid, LPUNKNOWN pUnkOuter = NULL, DWORD dwClsContext = CLSCTX_ALL)
|
|
|
|
{
|
|
|
|
return ::CoCreateInstance(rclsid, pUnkOuter, dwClsContext, iid, (void**)&_p);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
/*
|
|
|
|
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 <class Q>
|
2023-09-14 16:51:54 +01:00
|
|
|
HRESULT QueryInterface(REFGUID iid, Q** pp) const throw()
|
2022-11-12 09:45:35 +00:00
|
|
|
{
|
2023-09-14 16:51:54 +01:00
|
|
|
// if (*pp) throw 20220216; // for debug
|
2022-11-12 09:45:35 +00:00
|
|
|
return _p->QueryInterface(iid, (void**)pp);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2023-09-14 16:51:54 +01:00
|
|
|
#define Z7_DECL_CMyComPtr_QI_FROM(i, v, unk) \
|
|
|
|
CMyComPtr<i> v; (unk)->QueryInterface(IID_ ## i, (void **)&v);
|
|
|
|
|
|
|
|
|
2022-11-12 09:45:35 +00:00
|
|
|
//////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
inline HRESULT StringToBstr(LPCOLESTR src, BSTR *bstr)
|
|
|
|
{
|
|
|
|
*bstr = ::SysAllocString(src);
|
2023-09-14 16:51:54 +01:00
|
|
|
return (*bstr) ? S_OK : E_OUTOFMEMORY;
|
2022-11-12 09:45:35 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
class CMyComBSTR
|
|
|
|
{
|
|
|
|
BSTR m_str;
|
2023-09-14 16:51:54 +01:00
|
|
|
Z7_CLASS_NO_COPY(CMyComBSTR)
|
|
|
|
public:
|
2022-11-12 09:45:35 +00:00
|
|
|
CMyComBSTR(): m_str(NULL) {}
|
2023-09-14 16:51:54 +01:00
|
|
|
~CMyComBSTR() { ::SysFreeString(m_str); }
|
|
|
|
BSTR* operator&() { return &m_str; }
|
|
|
|
operator LPCOLESTR() const { return m_str; }
|
|
|
|
// operator bool() const { return m_str != NULL; }
|
|
|
|
// bool operator!() const { return m_str == NULL; }
|
|
|
|
|
|
|
|
void Wipe_and_Free()
|
|
|
|
{
|
|
|
|
if (m_str)
|
|
|
|
{
|
|
|
|
memset(m_str, 0, ::SysStringLen(m_str) * sizeof(*m_str));
|
|
|
|
Empty();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
// operator BSTR() const { return m_str; }
|
|
|
|
|
2022-11-12 09:45:35 +00:00
|
|
|
CMyComBSTR(LPCOLESTR src) { m_str = ::SysAllocString(src); }
|
|
|
|
// CMyComBSTR(int nSize) { m_str = ::SysAllocStringLen(NULL, nSize); }
|
|
|
|
// CMyComBSTR(int nSize, LPCOLESTR sz) { m_str = ::SysAllocStringLen(sz, nSize); }
|
2023-09-14 16:51:54 +01:00
|
|
|
// CMyComBSTR(const CMyComBSTR& src) { m_str = src.MyCopy(); }
|
|
|
|
|
2022-11-12 09:45:35 +00:00
|
|
|
/*
|
|
|
|
CMyComBSTR(REFGUID src)
|
|
|
|
{
|
|
|
|
LPOLESTR szGuid;
|
|
|
|
StringFromCLSID(src, &szGuid);
|
|
|
|
m_str = ::SysAllocString(szGuid);
|
|
|
|
CoTaskMemFree(szGuid);
|
|
|
|
}
|
|
|
|
*/
|
2023-09-14 16:51:54 +01:00
|
|
|
|
|
|
|
/*
|
2022-11-12 09:45:35 +00:00
|
|
|
CMyComBSTR& operator=(const CMyComBSTR& src)
|
|
|
|
{
|
|
|
|
if (m_str != src.m_str)
|
|
|
|
{
|
|
|
|
if (m_str)
|
|
|
|
::SysFreeString(m_str);
|
|
|
|
m_str = src.MyCopy();
|
|
|
|
}
|
|
|
|
return *this;
|
|
|
|
}
|
2023-09-14 16:51:54 +01:00
|
|
|
*/
|
|
|
|
|
2022-11-12 09:45:35 +00:00
|
|
|
CMyComBSTR& operator=(LPCOLESTR src)
|
|
|
|
{
|
|
|
|
::SysFreeString(m_str);
|
|
|
|
m_str = ::SysAllocString(src);
|
|
|
|
return *this;
|
|
|
|
}
|
2023-09-14 16:51:54 +01:00
|
|
|
|
|
|
|
unsigned Len() const { return ::SysStringLen(m_str); }
|
|
|
|
|
2022-11-12 09:45:35 +00:00
|
|
|
BSTR MyCopy() const
|
|
|
|
{
|
2023-09-14 16:51:54 +01:00
|
|
|
// We don't support Byte BSTRs here
|
|
|
|
return ::SysAllocStringLen(m_str, ::SysStringLen(m_str));
|
|
|
|
/*
|
|
|
|
UINT byteLen = ::SysStringByteLen(m_str);
|
2022-11-12 09:45:35 +00:00
|
|
|
BSTR res = ::SysAllocStringByteLen(NULL, byteLen);
|
2023-09-14 16:51:54 +01:00
|
|
|
if (res && byteLen != 0 && m_str)
|
|
|
|
memcpy(res, m_str, byteLen);
|
2022-11-12 09:45:35 +00:00
|
|
|
return res;
|
2023-09-14 16:51:54 +01:00
|
|
|
*/
|
2022-11-12 09:45:35 +00:00
|
|
|
}
|
2023-09-14 16:51:54 +01:00
|
|
|
|
2022-11-12 09:45:35 +00:00
|
|
|
/*
|
|
|
|
void Attach(BSTR src) { m_str = src; }
|
|
|
|
BSTR Detach()
|
|
|
|
{
|
|
|
|
BSTR s = m_str;
|
|
|
|
m_str = NULL;
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
*/
|
2023-09-14 16:51:54 +01:00
|
|
|
|
2022-11-12 09:45:35 +00:00
|
|
|
void Empty()
|
|
|
|
{
|
|
|
|
::SysFreeString(m_str);
|
|
|
|
m_str = NULL;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2023-09-14 16:51:54 +01:00
|
|
|
class CMyComBSTR_Wipe: public CMyComBSTR
|
2022-11-12 09:45:35 +00:00
|
|
|
{
|
2023-09-14 16:51:54 +01:00
|
|
|
Z7_CLASS_NO_COPY(CMyComBSTR_Wipe)
|
2022-11-12 09:45:35 +00:00
|
|
|
public:
|
2023-09-14 16:51:54 +01:00
|
|
|
CMyComBSTR_Wipe(): CMyComBSTR() {}
|
|
|
|
~CMyComBSTR_Wipe() { Wipe_and_Free(); }
|
2022-11-12 09:45:35 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
2023-09-14 16:51:54 +01:00
|
|
|
/*
|
|
|
|
If CMyUnknownImp doesn't use virtual destructor, the code size is smaller.
|
|
|
|
But if some class_1 derived from CMyUnknownImp
|
|
|
|
uses Z7_COM_ADDREF_RELEASE and IUnknown::Release()
|
|
|
|
and some another class_2 is derived from class_1,
|
|
|
|
then class_1 must use virtual destructor:
|
|
|
|
virtual ~class_1();
|
|
|
|
In that case, class_1::Release() calls correct destructor of class_2.
|
|
|
|
We can use virtual ~CMyUnknownImp() to disable warning
|
|
|
|
"class has virtual functions, but destructor is not virtual".
|
|
|
|
Also we can use virtual ~IUnknown() {} in MyWindows.h
|
|
|
|
*/
|
|
|
|
|
|
|
|
class CMyUnknownImp
|
|
|
|
{
|
|
|
|
Z7_CLASS_NO_COPY(CMyUnknownImp)
|
|
|
|
protected:
|
|
|
|
ULONG _m_RefCount;
|
|
|
|
CMyUnknownImp(): _m_RefCount(0) {}
|
|
|
|
|
|
|
|
#ifdef _WIN32
|
|
|
|
#if defined(__GNUC__) || defined(__clang__)
|
2023-10-21 13:10:45 +01:00
|
|
|
// virtual ~CMyUnknownImp() {} // to disable GCC/CLANG warnings
|
2023-09-14 16:51:54 +01:00
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2022-11-12 09:45:35 +00:00
|
|
|
|
2023-09-14 16:51:54 +01:00
|
|
|
#define Z7_COM_QI_BEGIN \
|
|
|
|
private: STDMETHOD(QueryInterface) (REFGUID iid, void **outObject) throw() Z7_override Z7_final \
|
|
|
|
{ *outObject = NULL;
|
2022-11-12 09:45:35 +00:00
|
|
|
|
2023-09-14 16:51:54 +01:00
|
|
|
#define Z7_COM_QI_ENTRY(i) \
|
|
|
|
else if (iid == IID_ ## i) \
|
|
|
|
{ i *ti = this; *outObject = ti; }
|
|
|
|
// { *outObject = (void *)(i *)this; }
|
2022-11-12 09:45:35 +00:00
|
|
|
|
2023-09-14 16:51:54 +01:00
|
|
|
#define Z7_COM_QI_ENTRY_UNKNOWN_0 \
|
|
|
|
if (iid == IID_IUnknown) \
|
|
|
|
{ IUnknown *tu = this; *outObject = tu; }
|
2022-11-12 09:45:35 +00:00
|
|
|
|
2023-09-14 16:51:54 +01:00
|
|
|
#define Z7_COM_QI_ENTRY_UNKNOWN(i) \
|
|
|
|
if (iid == IID_IUnknown) \
|
|
|
|
{ i *ti = this; IUnknown *tu = ti; *outObject = tu; }
|
|
|
|
// { *outObject = (void *)(IUnknown *)(i *)this; }
|
|
|
|
|
|
|
|
#define Z7_COM_QI_BEGIN2(i) \
|
|
|
|
Z7_COM_QI_BEGIN \
|
|
|
|
Z7_COM_QI_ENTRY_UNKNOWN(i) \
|
|
|
|
Z7_COM_QI_ENTRY(i)
|
|
|
|
|
|
|
|
#define Z7_COM_QI_END \
|
|
|
|
else return E_NOINTERFACE; \
|
|
|
|
++_m_RefCount; /* AddRef(); */ return S_OK; }
|
|
|
|
|
|
|
|
#define Z7_COM_ADDREF_RELEASE \
|
|
|
|
private: \
|
|
|
|
STDMETHOD_(ULONG, AddRef)() throw() Z7_override Z7_final \
|
|
|
|
{ return ++_m_RefCount; } \
|
|
|
|
STDMETHOD_(ULONG, Release)() throw() Z7_override Z7_final \
|
|
|
|
{ if (--_m_RefCount != 0) return _m_RefCount; delete this; return 0; } \
|
|
|
|
|
|
|
|
#define Z7_COM_UNKNOWN_IMP_SPEC(i) \
|
|
|
|
Z7_COM_QI_BEGIN \
|
2022-11-12 09:45:35 +00:00
|
|
|
i \
|
2023-09-14 16:51:54 +01:00
|
|
|
Z7_COM_QI_END \
|
|
|
|
Z7_COM_ADDREF_RELEASE
|
2022-11-12 09:45:35 +00:00
|
|
|
|
|
|
|
|
2023-09-14 16:51:54 +01:00
|
|
|
#define Z7_COM_UNKNOWN_IMP_0 \
|
|
|
|
Z7_COM_QI_BEGIN \
|
|
|
|
Z7_COM_QI_ENTRY_UNKNOWN_0 \
|
|
|
|
Z7_COM_QI_END \
|
|
|
|
Z7_COM_ADDREF_RELEASE
|
2022-11-12 09:45:35 +00:00
|
|
|
|
2023-09-14 16:51:54 +01:00
|
|
|
#define Z7_COM_UNKNOWN_IMP_1(i) \
|
|
|
|
Z7_COM_UNKNOWN_IMP_SPEC( \
|
|
|
|
Z7_COM_QI_ENTRY_UNKNOWN(i) \
|
|
|
|
Z7_COM_QI_ENTRY(i) \
|
2022-11-12 09:45:35 +00:00
|
|
|
)
|
|
|
|
|
2023-09-14 16:51:54 +01:00
|
|
|
#define Z7_COM_UNKNOWN_IMP_2(i1, i2) \
|
|
|
|
Z7_COM_UNKNOWN_IMP_SPEC( \
|
|
|
|
Z7_COM_QI_ENTRY_UNKNOWN(i1) \
|
|
|
|
Z7_COM_QI_ENTRY(i1) \
|
|
|
|
Z7_COM_QI_ENTRY(i2) \
|
2022-11-12 09:45:35 +00:00
|
|
|
)
|
|
|
|
|
2023-09-14 16:51:54 +01:00
|
|
|
#define Z7_COM_UNKNOWN_IMP_3(i1, i2, i3) \
|
|
|
|
Z7_COM_UNKNOWN_IMP_SPEC( \
|
|
|
|
Z7_COM_QI_ENTRY_UNKNOWN(i1) \
|
|
|
|
Z7_COM_QI_ENTRY(i1) \
|
|
|
|
Z7_COM_QI_ENTRY(i2) \
|
|
|
|
Z7_COM_QI_ENTRY(i3) \
|
2022-11-12 09:45:35 +00:00
|
|
|
)
|
|
|
|
|
2023-09-14 16:51:54 +01:00
|
|
|
#define Z7_COM_UNKNOWN_IMP_4(i1, i2, i3, i4) \
|
|
|
|
Z7_COM_UNKNOWN_IMP_SPEC( \
|
|
|
|
Z7_COM_QI_ENTRY_UNKNOWN(i1) \
|
|
|
|
Z7_COM_QI_ENTRY(i1) \
|
|
|
|
Z7_COM_QI_ENTRY(i2) \
|
|
|
|
Z7_COM_QI_ENTRY(i3) \
|
|
|
|
Z7_COM_QI_ENTRY(i4) \
|
2022-11-12 09:45:35 +00:00
|
|
|
)
|
|
|
|
|
2023-09-14 16:51:54 +01:00
|
|
|
#define Z7_COM_UNKNOWN_IMP_5(i1, i2, i3, i4, i5) \
|
|
|
|
Z7_COM_UNKNOWN_IMP_SPEC( \
|
|
|
|
Z7_COM_QI_ENTRY_UNKNOWN(i1) \
|
|
|
|
Z7_COM_QI_ENTRY(i1) \
|
|
|
|
Z7_COM_QI_ENTRY(i2) \
|
|
|
|
Z7_COM_QI_ENTRY(i3) \
|
|
|
|
Z7_COM_QI_ENTRY(i4) \
|
|
|
|
Z7_COM_QI_ENTRY(i5) \
|
2022-11-12 09:45:35 +00:00
|
|
|
)
|
|
|
|
|
2023-09-14 16:51:54 +01:00
|
|
|
#define Z7_COM_UNKNOWN_IMP_6(i1, i2, i3, i4, i5, i6) \
|
|
|
|
Z7_COM_UNKNOWN_IMP_SPEC( \
|
|
|
|
Z7_COM_QI_ENTRY_UNKNOWN(i1) \
|
|
|
|
Z7_COM_QI_ENTRY(i1) \
|
|
|
|
Z7_COM_QI_ENTRY(i2) \
|
|
|
|
Z7_COM_QI_ENTRY(i3) \
|
|
|
|
Z7_COM_QI_ENTRY(i4) \
|
|
|
|
Z7_COM_QI_ENTRY(i5) \
|
|
|
|
Z7_COM_QI_ENTRY(i6) \
|
|
|
|
)
|
|
|
|
|
|
|
|
#define Z7_COM_UNKNOWN_IMP_7(i1, i2, i3, i4, i5, i6, i7) \
|
|
|
|
Z7_COM_UNKNOWN_IMP_SPEC( \
|
|
|
|
Z7_COM_QI_ENTRY_UNKNOWN(i1) \
|
|
|
|
Z7_COM_QI_ENTRY(i1) \
|
|
|
|
Z7_COM_QI_ENTRY(i2) \
|
|
|
|
Z7_COM_QI_ENTRY(i3) \
|
|
|
|
Z7_COM_QI_ENTRY(i4) \
|
|
|
|
Z7_COM_QI_ENTRY(i5) \
|
|
|
|
Z7_COM_QI_ENTRY(i6) \
|
|
|
|
Z7_COM_QI_ENTRY(i7) \
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
|
|
#define Z7_IFACES_IMP_UNK_1(i1) \
|
|
|
|
Z7_COM_UNKNOWN_IMP_1(i1) \
|
|
|
|
Z7_IFACE_COM7_IMP(i1) \
|
|
|
|
|
|
|
|
#define Z7_IFACES_IMP_UNK_2(i1, i2) \
|
|
|
|
Z7_COM_UNKNOWN_IMP_2(i1, i2) \
|
|
|
|
Z7_IFACE_COM7_IMP(i1) \
|
|
|
|
Z7_IFACE_COM7_IMP(i2) \
|
|
|
|
|
|
|
|
#define Z7_IFACES_IMP_UNK_3(i1, i2, i3) \
|
|
|
|
Z7_COM_UNKNOWN_IMP_3(i1, i2, i3) \
|
|
|
|
Z7_IFACE_COM7_IMP(i1) \
|
|
|
|
Z7_IFACE_COM7_IMP(i2) \
|
|
|
|
Z7_IFACE_COM7_IMP(i3) \
|
|
|
|
|
|
|
|
#define Z7_IFACES_IMP_UNK_4(i1, i2, i3, i4) \
|
|
|
|
Z7_COM_UNKNOWN_IMP_4(i1, i2, i3, i4) \
|
|
|
|
Z7_IFACE_COM7_IMP(i1) \
|
|
|
|
Z7_IFACE_COM7_IMP(i2) \
|
|
|
|
Z7_IFACE_COM7_IMP(i3) \
|
|
|
|
Z7_IFACE_COM7_IMP(i4) \
|
|
|
|
|
|
|
|
#define Z7_IFACES_IMP_UNK_5(i1, i2, i3, i4, i5) \
|
|
|
|
Z7_COM_UNKNOWN_IMP_5(i1, i2, i3, i4, i5) \
|
|
|
|
Z7_IFACE_COM7_IMP(i1) \
|
|
|
|
Z7_IFACE_COM7_IMP(i2) \
|
|
|
|
Z7_IFACE_COM7_IMP(i3) \
|
|
|
|
Z7_IFACE_COM7_IMP(i4) \
|
|
|
|
Z7_IFACE_COM7_IMP(i5) \
|
|
|
|
|
|
|
|
#define Z7_IFACES_IMP_UNK_6(i1, i2, i3, i4, i5, i6) \
|
|
|
|
Z7_COM_UNKNOWN_IMP_6(i1, i2, i3, i4, i5, i6) \
|
|
|
|
Z7_IFACE_COM7_IMP(i1) \
|
|
|
|
Z7_IFACE_COM7_IMP(i2) \
|
|
|
|
Z7_IFACE_COM7_IMP(i3) \
|
|
|
|
Z7_IFACE_COM7_IMP(i4) \
|
|
|
|
Z7_IFACE_COM7_IMP(i5) \
|
|
|
|
Z7_IFACE_COM7_IMP(i6) \
|
|
|
|
|
|
|
|
|
|
|
|
#define Z7_CLASS_IMP_COM_0(c) \
|
|
|
|
Z7_class_final(c) : \
|
|
|
|
public IUnknown, \
|
|
|
|
public CMyUnknownImp { \
|
|
|
|
Z7_COM_UNKNOWN_IMP_0 \
|
|
|
|
private:
|
|
|
|
|
|
|
|
#define Z7_CLASS_IMP_COM_1(c, i1) \
|
|
|
|
Z7_class_final(c) : \
|
|
|
|
public i1, \
|
|
|
|
public CMyUnknownImp { \
|
|
|
|
Z7_IFACES_IMP_UNK_1(i1) \
|
|
|
|
private:
|
|
|
|
|
|
|
|
#define Z7_CLASS_IMP_COM_2(c, i1, i2) \
|
|
|
|
Z7_class_final(c) : \
|
|
|
|
public i1, \
|
|
|
|
public i2, \
|
|
|
|
public CMyUnknownImp { \
|
|
|
|
Z7_IFACES_IMP_UNK_2(i1, i2) \
|
|
|
|
private:
|
|
|
|
|
|
|
|
#define Z7_CLASS_IMP_COM_3(c, i1, i2, i3) \
|
|
|
|
Z7_class_final(c) : \
|
|
|
|
public i1, \
|
|
|
|
public i2, \
|
|
|
|
public i3, \
|
|
|
|
public CMyUnknownImp { \
|
|
|
|
Z7_IFACES_IMP_UNK_3(i1, i2, i3) \
|
|
|
|
private:
|
|
|
|
|
|
|
|
#define Z7_CLASS_IMP_COM_4(c, i1, i2, i3, i4) \
|
|
|
|
Z7_class_final(c) : \
|
|
|
|
public i1, \
|
|
|
|
public i2, \
|
|
|
|
public i3, \
|
|
|
|
public i4, \
|
|
|
|
public CMyUnknownImp { \
|
|
|
|
Z7_IFACES_IMP_UNK_4(i1, i2, i3, i4) \
|
|
|
|
private:
|
|
|
|
|
|
|
|
#define Z7_CLASS_IMP_COM_5(c, i1, i2, i3, i4, i5) \
|
|
|
|
Z7_class_final(c) : \
|
|
|
|
public i1, \
|
|
|
|
public i2, \
|
|
|
|
public i3, \
|
|
|
|
public i4, \
|
|
|
|
public i5, \
|
|
|
|
public CMyUnknownImp { \
|
|
|
|
Z7_IFACES_IMP_UNK_5(i1, i2, i3, i4, i5) \
|
|
|
|
private:
|
|
|
|
|
|
|
|
#define Z7_CLASS_IMP_COM_6(c, i1, i2, i3, i4, i5, i6) \
|
|
|
|
Z7_class_final(c) : \
|
|
|
|
public i1, \
|
|
|
|
public i2, \
|
|
|
|
public i3, \
|
|
|
|
public i4, \
|
|
|
|
public i5, \
|
|
|
|
public i6, \
|
|
|
|
public CMyUnknownImp { \
|
|
|
|
Z7_IFACES_IMP_UNK_6(i1, i2, i3, i4, i5, i6) \
|
|
|
|
private:
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
#define Z7_CLASS_IMP_NOQIB_0(c) \
|
|
|
|
Z7_class_final(c) : \
|
|
|
|
public IUnknown, \
|
|
|
|
public CMyUnknownImp { \
|
|
|
|
Z7_COM_UNKNOWN_IMP_0 \
|
|
|
|
private:
|
|
|
|
*/
|
|
|
|
|
|
|
|
#define Z7_CLASS_IMP_NOQIB_1(c, i1) \
|
|
|
|
Z7_class_final(c) : \
|
|
|
|
public i1, \
|
|
|
|
public CMyUnknownImp { \
|
|
|
|
Z7_COM_UNKNOWN_IMP_0 \
|
|
|
|
Z7_IFACE_COM7_IMP(i1) \
|
|
|
|
private:
|
|
|
|
|
|
|
|
#define Z7_CLASS_IMP_NOQIB_2(c, i1, i2) \
|
|
|
|
Z7_class_final(c) : \
|
|
|
|
public i1, \
|
|
|
|
public i2, \
|
|
|
|
public CMyUnknownImp { \
|
|
|
|
Z7_COM_UNKNOWN_IMP_1(i2) \
|
|
|
|
Z7_IFACE_COM7_IMP(i1) \
|
|
|
|
Z7_IFACE_COM7_IMP(i2) \
|
|
|
|
private:
|
|
|
|
|
|
|
|
#define Z7_CLASS_IMP_NOQIB_3(c, i1, i2, i3) \
|
|
|
|
Z7_class_final(c) : \
|
|
|
|
public i1, \
|
|
|
|
public i2, \
|
|
|
|
public i3, \
|
|
|
|
public CMyUnknownImp { \
|
|
|
|
Z7_COM_UNKNOWN_IMP_2(i2, i3) \
|
|
|
|
Z7_IFACE_COM7_IMP(i1) \
|
|
|
|
Z7_IFACE_COM7_IMP(i2) \
|
|
|
|
Z7_IFACE_COM7_IMP(i3) \
|
|
|
|
private:
|
|
|
|
|
|
|
|
#define Z7_CLASS_IMP_NOQIB_4(c, i1, i2, i3, i4) \
|
|
|
|
Z7_class_final(c) : \
|
|
|
|
public i1, \
|
|
|
|
public i2, \
|
|
|
|
public i3, \
|
|
|
|
public i4, \
|
|
|
|
public CMyUnknownImp { \
|
|
|
|
Z7_COM_UNKNOWN_IMP_3(i2, i3, i4) \
|
|
|
|
Z7_IFACE_COM7_IMP(i1) \
|
|
|
|
Z7_IFACE_COM7_IMP(i2) \
|
|
|
|
Z7_IFACE_COM7_IMP(i3) \
|
|
|
|
Z7_IFACE_COM7_IMP(i4) \
|
|
|
|
|
|
|
|
/*
|
|
|
|
#define Z7_CLASS_IMP_NOQIB_5(c, i1, i2, i3, i4, i5) \
|
|
|
|
Z7_class_final(c) : \
|
|
|
|
public i1, \
|
|
|
|
public i2, \
|
|
|
|
public i3, \
|
|
|
|
public i4, \
|
|
|
|
public i5, \
|
|
|
|
public CMyUnknownImp { \
|
|
|
|
Z7_COM_UNKNOWN_IMP_4(i2, i3, i4, i5) \
|
|
|
|
Z7_IFACE_COM7_IMP(i1) \
|
|
|
|
Z7_IFACE_COM7_IMP(i2) \
|
|
|
|
Z7_IFACE_COM7_IMP(i3) \
|
|
|
|
Z7_IFACE_COM7_IMP(i4) \
|
|
|
|
Z7_IFACE_COM7_IMP(i5) \
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
#define Z7_CLASS_IMP_IInStream(c) \
|
|
|
|
class c Z7_final : \
|
|
|
|
public IInStream, \
|
|
|
|
public CMyUnknownImp { \
|
|
|
|
Z7_IFACES_IMP_UNK_2(ISequentialInStream, IInStream) \
|
|
|
|
|
|
|
|
|
|
|
|
#define k_My_HRESULT_WritingWasCut 0x20000010
|
|
|
|
|
2022-11-12 09:45:35 +00:00
|
|
|
#endif
|