451 lines
16 KiB
C++
451 lines
16 KiB
C++
/** \file
|
|
* Wrappers for ITypeLibInfo.
|
|
*/
|
|
/*
|
|
* Copyright © 2002 Michael Geddes.
|
|
*
|
|
* This material is provided "as is", with absolutely no warranty
|
|
* expressed or implied. Any use is at your own risk. Permission to
|
|
* use or copy this software for any purpose is hereby granted without
|
|
* fee, provided the above notices are retained on all copies.
|
|
* Permission to modify the code and to distribute modified code is
|
|
* granted, provided the above notices are retained, and a notice that
|
|
* the code was modified is included with the above copyright notice.
|
|
*
|
|
* This header is part of Comet version 2.
|
|
* https://github.com/alamaison/comet
|
|
*/
|
|
|
|
#ifndef COMET_TLIBINFO_H
|
|
#define COMET_TLIBINFO_H
|
|
|
|
#ifdef _SHOW_INC
|
|
#pragma message(" #Include " __FILE__)
|
|
#endif
|
|
|
|
#include <oaidl.h>
|
|
#include <comet/ptr.h>
|
|
#include <comet/uuid.h>
|
|
|
|
namespace comet
|
|
{
|
|
template<> struct comtype<ITypeLib>
|
|
{
|
|
static const IID& uuid() throw() { return IID_IPictureDisp; }
|
|
typedef ::IUnknown base;
|
|
};
|
|
template<> struct comtype<ITypeInfo>
|
|
{
|
|
static const IID& uuid() throw() { return IID_ITypeInfo; }
|
|
typedef ::IUnknown base;
|
|
};
|
|
template<> struct comtype<ITypeInfo2>
|
|
{
|
|
static const IID& uuid() throw() { return IID_ITypeInfo2; }
|
|
typedef ::ITypeInfo base;
|
|
};
|
|
/*! \addtogroup Interfaces
|
|
*/
|
|
//@{
|
|
namespace impl
|
|
{
|
|
/// A class to handle the auto-releaseing of structs returned by by the Typeinfo interfaces.
|
|
template< typename B, typename T>
|
|
struct tlib_info
|
|
{
|
|
typedef void (__stdcall B::*RelFunc)(T*);
|
|
template< RelFunc RELEASE>
|
|
struct typeinfo_attr_base
|
|
{
|
|
public:
|
|
typeinfo_attr_base() : info_(NULL), attrib_(NULL), rc_(NULL) {}
|
|
typeinfo_attr_base( const com_ptr<B> &info, T *attrib ) : info_(info),attrib_(attrib),rc_(NULL)
|
|
{
|
|
if (attrib != NULL)
|
|
{
|
|
rc_ = new long;
|
|
(*rc_)=1;
|
|
}
|
|
}
|
|
typeinfo_attr_base( const typeinfo_attr_base &base)
|
|
: info_(base.info_), attrib_(base.attrib_), rc_(base.rc_)
|
|
{
|
|
++*rc_;
|
|
}
|
|
~typeinfo_attr_base()
|
|
{
|
|
release();
|
|
}
|
|
typeinfo_attr_base &operator =( const typeinfo_attr_base &base)
|
|
{
|
|
release();
|
|
info_= base.info_;
|
|
attrib_= base.attrib_;
|
|
rc_ = base.rc_;
|
|
++*rc_;
|
|
return *this;
|
|
}
|
|
void release()
|
|
{
|
|
if(attrib_ != NULL && rc_ != NULL )
|
|
{
|
|
if (0 == --*rc_)
|
|
{
|
|
(info_.raw()->*RELEASE)( attrib_);
|
|
delete rc_;
|
|
}
|
|
rc_ = NULL;
|
|
attrib_ = NULL;
|
|
info_ = NULL;
|
|
}
|
|
}
|
|
|
|
|
|
T *operator->() const
|
|
{
|
|
if( attrib_ ==NULL ) throw com_error(E_POINTER);
|
|
return attrib_;
|
|
}
|
|
bool is_null() const { return attrib_ == NULL; }
|
|
protected:
|
|
long *rc_;
|
|
T *attrib_;
|
|
com_ptr<B> info_;
|
|
};
|
|
};
|
|
};
|
|
|
|
/// Auto-release wrapper for TYPEATTR.
|
|
typedef impl::tlib_info<ITypeInfo, TYPEATTR>::typeinfo_attr_base< &ITypeInfo::ReleaseTypeAttr > type_attr_t;
|
|
/// Auto-release wrapper for FUNCDESC.
|
|
typedef impl::tlib_info<ITypeInfo, FUNCDESC>::typeinfo_attr_base< &ITypeInfo::ReleaseFuncDesc > func_desc_t;
|
|
/// Auto-release wrapper for VARDESC.
|
|
typedef impl::tlib_info<ITypeInfo, VARDESC>::typeinfo_attr_base< &ITypeInfo::ReleaseVarDesc > var_desc_t;
|
|
|
|
/// Auto-release wrapper for TLIBATTR.
|
|
typedef impl::tlib_info<ITypeLib, TLIBATTR>::typeinfo_attr_base< &ITypeLib::ReleaseTLibAttr > tlibattr_t;
|
|
|
|
|
|
/** Flags for GetImplTypeFlags.
|
|
* \sa IMPLTYPEFLAGS
|
|
*/
|
|
enum impl_type_flag
|
|
{
|
|
eft_default=0x1, ///< The interface or dispinterface represents the default for the source or sink.
|
|
eft_source =0x2, ///< This member of a coclass is called rather than implemented.
|
|
eft_restricted=0x4, ///< The member should not be displayed or programmable by users.
|
|
eft_defaultvtable=0x8 ///< Sinks receive events through the VTBL.
|
|
};
|
|
|
|
/** Specialisation wrapper for ITypeInfo.
|
|
* \struct wrap_t<ITypeInfo> tlbinfo.h comet/tlbinfo.h
|
|
* Wrapper for ITypeInfo typelib information.
|
|
* \sa ITypeInfo
|
|
*/
|
|
template<>
|
|
struct wrap_t<ITypeInfo>
|
|
{
|
|
private:
|
|
inline ITypeInfo *raw_(){ return reinterpret_cast<ITypeInfo *>(this); }
|
|
public:
|
|
|
|
/** Returns a wrapped Type Attributes struct.
|
|
* \sa TYPEATTR
|
|
*/
|
|
type_attr_t GetTypeAttr()
|
|
{
|
|
TYPEATTR *pTypeAttr;
|
|
raw_()->GetTypeAttr( &pTypeAttr) | raise_exception ;
|
|
return type_attr_t( raw_(), pTypeAttr);
|
|
}
|
|
|
|
/// Returns an ITypeComp interface.
|
|
com_ptr<ITypeComp> GetTypeComp()
|
|
{
|
|
com_ptr<ITypeComp> ppTComp;
|
|
raw_()->GetTypeComp( ppTComp.out()) | raise_exception;
|
|
return ppTComp;
|
|
}
|
|
|
|
/** Get the function description struct.
|
|
* \sa FUNCDESC
|
|
*/
|
|
func_desc_t GetFuncDesc( unsigned int index)
|
|
{
|
|
FUNCDESC *pFuncDesc ;
|
|
raw_()->GetFuncDesc(index, &pFuncDesc) | raise_exception ;
|
|
return func_desc_t( raw_(), pFuncDesc);
|
|
}
|
|
|
|
/** Get the Variable/Constant/Datamember description.
|
|
* \sa VARDESC
|
|
*/
|
|
var_desc_t GetVarDesc( unsigned int index )
|
|
{
|
|
VARDESC *pVarDesc;
|
|
raw_()->GetVarDesc( index,&pVarDesc) | raise_exception;
|
|
return var_desc_t(raw_(), pVarDesc);
|
|
}
|
|
|
|
|
|
#ifdef NOT_YET
|
|
std::list<std::string> GetNames( MEMBERID memid )
|
|
{
|
|
/* [local] */ HRESULT GetNames( /* [in] */ MEMBERID memid, /* [length_is][size_is][out] */ BSTR *rgBstrNames,
|
|
/* [in] */ UINT cMaxNames, /* [out] */ UINT *pcNames) ;
|
|
}
|
|
#endif //
|
|
|
|
/// Retrieves the type description of implemented interface types.
|
|
HREFTYPE GetRefTypeOfImplType( unsigned int index)
|
|
{
|
|
HREFTYPE reftype;
|
|
raw_()->GetRefTypeOfImplType(index, &reftype) | raise_exception;
|
|
return reftype;
|
|
}
|
|
|
|
/// Retrieves the type description of implemented interface types.
|
|
long GetImplTypeFlags( int index)
|
|
{
|
|
INT implTypeFlags;
|
|
raw_()->GetImplTypeFlags( index, &implTypeFlags) |raise_exception;
|
|
return implTypeFlags;
|
|
}
|
|
|
|
#ifdef NOT_YET
|
|
std::vector<MEMBERID> GetIDsOfNames( const std::vector<bstr_t> &rgsNames);
|
|
{
|
|
/* [local] */ HRESULT GetIDsOfNames(
|
|
/* [size_is][in] */ LPOLESTR *rgszNames,
|
|
/* [in] */ UINT cNames,
|
|
/* [size_is][out] */ MEMBERID *pMemId) ;
|
|
}
|
|
|
|
/* [local] */ HRESULT Invoke(
|
|
/* [in] */ PVOID pvInstance,
|
|
/* [in] */ MEMBERID memid,
|
|
/* [in] */ WORD wFlags,
|
|
/* [out][in] */ DISPPARAMS *pDispParams,
|
|
/* [out] */ VARIANT *pVarResult,
|
|
/* [out] */ EXCEPINFO *pExcepInfo,
|
|
/* [out] */ UINT *puArgErr) ;
|
|
#endif // NOT_YET
|
|
/// Raw wrapper to make sure comet still works/compiles.
|
|
HRESULT GetIDsOfNames( LPOLESTR *rgszNames, UINT cNames,
|
|
MEMBERID *pMemId)
|
|
{
|
|
return raw_()->GetIDsOfNames( rgszNames, cNames, pMemId);
|
|
}
|
|
|
|
/// Raw wrapper to make sure comet still works/compiles.
|
|
HRESULT Invoke( PVOID pvInstance, MEMBERID memid, WORD wFlags,
|
|
DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo,
|
|
UINT *puArgErr)
|
|
{
|
|
return raw_()->Invoke( pvInstance, memid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
|
|
}
|
|
|
|
bool GetIDOfName( const wchar_t *name, MEMBERID *id)
|
|
{
|
|
wchar_t *ucname = const_cast<wchar_t *>(name);
|
|
return SUCCEEDED(raw_()->GetIDsOfNames( &ucname, 1, id));
|
|
}
|
|
|
|
|
|
/// Get the documentation for the specified MEMBERID.
|
|
void GetDocumentation(MEMBERID memid, bstr_t *name, bstr_t *docString, DWORD *helpcontext, bstr_t *helpfile)
|
|
{
|
|
raw_()->GetDocumentation(memid, name?name->out():NULL, docString?docString->out():NULL,
|
|
helpcontext, helpfile? helpfile->out():NULL) | raise_exception;
|
|
}
|
|
/** Get the member name for the specified MEMBERID.
|
|
* This is a shortcut for GetDocumentation.
|
|
*/
|
|
|
|
bstr_t GetMemberName(MEMBERID memid)
|
|
{
|
|
bstr_t name;
|
|
raw_()->GetDocumentation(memid, name.out(), NULL, NULL, NULL) | raise_exception;
|
|
return name;
|
|
}
|
|
bstr_t GetName()
|
|
{
|
|
return GetMemberName(-1);
|
|
}
|
|
|
|
#if NOT_YET
|
|
/* [local] */ HRESULT GetDllEntry(
|
|
/* [in] */ MEMBERID memid,
|
|
/* [in] */ INVOKEKIND invKind,
|
|
/* [out] */ BSTR *pBstrDllName,
|
|
/* [out] */ BSTR *pBstrName,
|
|
/* [out] */ WORD *pwOrdinal) ;
|
|
#endif // NOT_YET
|
|
|
|
/** Get the referenced Type information.
|
|
*/
|
|
com_ptr<ITypeInfo> GetRefTypeInfo( HREFTYPE refType)
|
|
{
|
|
com_ptr<ITypeInfo> refinfo;
|
|
raw_()->GetRefTypeInfo( refType, refinfo.out()) | raise_exception;
|
|
return refinfo;
|
|
}
|
|
|
|
#if NOT_YET
|
|
/* [local] */ HRESULT AddressOfMember( /* [in] */ MEMBERID memid, /* [in] */ INVOKEKIND invKind,
|
|
/* [out] */ PVOID *ppv) ;
|
|
|
|
/* [local] */ HRESULT CreateInstance( /* [in] */ IUnknown *pUnkOuter, /* [in] */ REFIID riid,
|
|
/* [iid_is][out] */ PVOID *ppvObj) ;
|
|
|
|
HRESULT GetMops( /* [in] */ MEMBERID memid, /* [out] */ BSTR *pBstrMops) ;
|
|
#endif // NOT_YET
|
|
|
|
/** Get the typelib containing this definition.
|
|
* \return A pair containing the typelibrary and the index of the type description within the type library.
|
|
*/
|
|
std::pair< com_ptr<ITypeLib>, UINT > GetContainingTypeLib()
|
|
{
|
|
std::pair< com_ptr<ITypeLib>, UINT> result;
|
|
raw_()->GetContainingTypeLib( result.first.out(), &(result.second) ) | raise_exception;
|
|
return result;
|
|
}
|
|
};
|
|
//@}
|
|
|
|
template<>
|
|
struct wrap_t<ITypeInfo2> : wrap_t<ITypeInfo>
|
|
{
|
|
TYPEKIND GetTypeKind()
|
|
{
|
|
TYPEKIND tkind;
|
|
raw_()->GetTypeKind(&tkind) | raise_exception;
|
|
return tkind;
|
|
}
|
|
private:
|
|
inline ITypeInfo2 *raw_(){ return reinterpret_cast<ITypeInfo2 *>(this); }
|
|
};
|
|
|
|
|
|
/*! \addtogroup Interfaces
|
|
*/
|
|
//@{
|
|
|
|
/// Specialisation to handle TypeLibrary API.
|
|
template<>
|
|
struct wrap_t<ITypeLib>
|
|
{
|
|
inline ITypeLib *raw_(){ return reinterpret_cast<ITypeLib *>(this); }
|
|
unsigned int GetTypeInfoCount()
|
|
{
|
|
return raw_()->GetTypeInfoCount();
|
|
}
|
|
|
|
/// Get typeinfo at specified index.
|
|
com_ptr<ITypeInfo> GetTypeInfo( UINT index)
|
|
{
|
|
com_ptr<ITypeInfo> tinfo;
|
|
raw_()->GetTypeInfo( index, tinfo.out()) | raise_exception;
|
|
return tinfo;
|
|
}
|
|
|
|
/// Get type of information at specified index.
|
|
TYPEKIND GetTypeInfoType( UINT index)
|
|
{
|
|
TYPEKIND retval;
|
|
raw_()->GetTypeInfoType( index, &retval) | raise_exception;
|
|
return retval;
|
|
}
|
|
|
|
/// Get typeinfo given GUID.
|
|
com_ptr<ITypeInfo> GetTypeInfoOfGuid( const uuid_t &guid )
|
|
{
|
|
com_ptr<ITypeInfo> tinfo;
|
|
raw_()->GetTypeInfoOfGuid( guid, tinfo.out()) | raise_exception;
|
|
return tinfo;
|
|
}
|
|
/// Get Raw Typeinfo of guid.
|
|
HRESULT GetTypeInfoOfGuid( REFGUID guid, ITypeInfo **ppTinfo)
|
|
{
|
|
return raw_()->GetTypeInfoOfGuid( guid,ppTinfo);
|
|
}
|
|
|
|
/// Get attributes of the typelibrary.
|
|
tlibattr_t GetLibAttr()
|
|
{
|
|
TLIBATTR *attr;
|
|
raw_()->GetLibAttr( &attr) | raise_exception;
|
|
return tlibattr_t( raw_(), attr);
|
|
}
|
|
|
|
com_ptr<ITypeComp> GetTypeComp()
|
|
{
|
|
com_ptr<ITypeComp> typecomp;
|
|
raw_()->GetTypeComp( typecomp.out() ) | raise_exception;
|
|
return typecomp;
|
|
}
|
|
|
|
void GetDocumentation(int index, bstr_t *name, bstr_t *docString, DWORD *helpcontext, bstr_t *helpfile)
|
|
{
|
|
raw_()->GetDocumentation(index, name?name->out():NULL, docString?docString->out():NULL,
|
|
helpcontext, helpfile? helpfile->out():NULL) | raise_exception;
|
|
}
|
|
bstr_t GetItemName(int index)
|
|
{
|
|
bstr_t name;
|
|
raw_()->GetDocumentation(index, name.out(), NULL, NULL, NULL) | raise_exception;
|
|
return name;
|
|
}
|
|
bstr_t GetName()
|
|
{
|
|
return GetItemName(-1);
|
|
}
|
|
|
|
bool IsName( const bstr_t &name, unsigned long hashval )
|
|
{
|
|
BOOL ret;
|
|
raw_()->IsName( name.in(), hashval, &ret) | raise_exception;
|
|
return ret!=0;
|
|
}
|
|
|
|
std::pair<com_ptr<ITypeInfo>, MEMBERID> FindName( const bstr_t &name)
|
|
{
|
|
std::pair<com_ptr<ITypeInfo>, MEMBERID> result;
|
|
USHORT tofind = 1;
|
|
raw_()->FindName(name.in(), 0, result.first.out(), &result.second, &tofind) | raise_exception;
|
|
return result;
|
|
}
|
|
#ifdef NOT_YET
|
|
std::list<std::pair<com_ptr<ITypeInfo>, MEMBERID> >FindName( const bstr_t &name, int max)
|
|
{}
|
|
[local]
|
|
HRESULT FindName(
|
|
[in, out] LPOLESTR szNameBuf,
|
|
[in] ULONG lHashVal,
|
|
[out,size_is(*pcFound),length_is(*pcFound)] ITypeInfo **ppTInfo,
|
|
[out,size_is(*pcFound),length_is(*pcFound)] MEMBERID * rgMemId,
|
|
[in, out] USHORT * pcFound
|
|
);
|
|
#endif // LATER
|
|
|
|
|
|
};
|
|
|
|
/// Load typeinfo from a file.
|
|
namespace typeinfo
|
|
{
|
|
/** Whether to register the typelibrary on load.
|
|
* \relates typeinfo::LoadTypeLib
|
|
*/
|
|
enum regkind_t { reg_default = REGKIND_DEFAULT, reg_register = REGKIND_REGISTER, reg_none = REGKIND_NONE } ;
|
|
/// Load typeinfo from a file.
|
|
static inline com_ptr<ITypeLib> LoadTypeLib( const bstr_t &filename, regkind_t regkind= reg_default)
|
|
{
|
|
com_ptr<ITypeLib> tlib;
|
|
LoadTypeLibEx(filename.in(), (REGKIND)(regkind), tlib.out()) | raise_exception;
|
|
return tlib;
|
|
}
|
|
}
|
|
//@}
|
|
} // namespace comet
|
|
#endif /* COMET_TLIBINFO_H */
|