ITypeInfo *GetObjectTypeInfoEx(LCID lcid,REFIID iid)
{
HRESULT hr;
ITypeInfo **ppTypeInfo;
if (iid==IID_IBands)
ppTypeInfo=&g_bandsTypeLib;
else if (iid==IID_IChildBands)
ppTypeInfo=&g_childbandsTypeLib;
else
return NULL;
if ((*ppTypeInfo)==NULL)
{ //Try to load typelibrary
ITypeLib *pTypeLib;
ITypeInfo *pTypeInfoTmp;
hr = LoadRegTypeLib(LIBID_PROJECT, 2, 0,lcid, &pTypeLib);
if (FAILED(hr))
{
return NULL;
}
hr = pTypeLib->GetTypeInfoOfGuid(iid, &pTypeInfoTmp);
*ppTypeInfo=pTypeInfoTmp;
pTypeLib->Release();
}
if ((*ppTypeInfo)==NULL)
return NULL;
(*ppTypeInfo)->AddRef();
return *ppTypeInfo;
}
//------------------------------------------------------------------------------
// CSimpleThermostatService::InitStdDispatch
// Creates the standard dispatch object that will be used when IDispatch
// is requested from this object. The UPnP device object will call this
// function immediately after instantiation of this object.
//------------------------------------------------------------------------------
HRESULT CSimpleThermostatService::InitStdDispatch()
{
HRESULT hr = S_OK;
ITypeLib* pTypeLib = NULL;
hr = LoadRegTypeLib(
LIBID_SimpleThermostatDeviceLib,
1,
0,
LANG_NEUTRAL,
&pTypeLib
);
if( S_OK == hr )
{
hr = pTypeLib->GetTypeInfoOfGuid(
__uuidof(ISimpleThermostat_UPnPService),
&m_pTypeInfo
);
pTypeLib->Release();
}
if( S_OK == hr )
{
hr = CreateStdDispatch(
reinterpret_cast<IUnknown*>(this),
this,
m_pTypeInfo,
&m_pUnkStdDispatch
);
}
return hr;
}// CSimpleThermostatService::InitStdDispatch
CiTunesEventHandler()
{
m_dwRefCount=0;
ITypeLib* pITypeLib = nullptr ;
HRESULT hr = ::LoadRegTypeLib(LIBID_iTunesLib, 1, 5, 0x00, &pITypeLib) ;
// Get type information for the interface of the object.
hr = pITypeLib->GetTypeInfoOfGuid(DIID__IiTunesEvents, &m_pITypeInfo) ;
pITypeLib->Release() ;
}
PyObject *PyITypeLib::GetTypeInfoOfGuid(REFGUID guid)
{
ITypeLib *pMyTypeLib = GetI(this);
if (pMyTypeLib==NULL) return NULL;
ITypeInfo *pti = NULL;
PY_INTERFACE_PRECALL;
HRESULT hr = pMyTypeLib->GetTypeInfoOfGuid(guid, &pti);
PY_INTERFACE_POSTCALL;
if (FAILED(hr))
return PyCom_BuildPyException(hr, pMyTypeLib, IID_ITypeLib);
return PyCom_PyObjectFromIUnknown(pti, IID_ITypeInfo);
}
static HRESULT maybeLoadTypeInfo()
{
if (!m_pTypeInfo)
{
ITypeLib* ptl;
if (SUCCEEDED( LoadRegTypeLib( LIBID_$$Safe_root$$, 1, 0, MAKELCID(0, SORT_DEFAULT), &ptl ) ))
{
ptl->GetTypeInfoOfGuid( IID_IControlSurface, &m_pTypeInfo );
ptl->Release();
}
else
return E_NOTIMPL;
}
return NOERROR;
}
STDMETHODIMP CJServer::GetTypeInfo(UINT itInfo, LCID lcid, ITypeInfo **ppITypeInfo)
{
HRESULT hr;
ITypeLib *pITypeLib;
ITypeInfo **ppITI=NULL;
if (0!=itInfo) return TYPE_E_ELEMENTNOTFOUND;
if (NULL==ppITypeInfo) return E_POINTER;
*ppITypeInfo=NULL;
switch (PRIMARYLANGID(lcid))
{
case LANG_NEUTRAL:
case LANG_ENGLISH:
ppITI=&m_pITINeutral;
break;
default:
return DISP_E_UNKNOWNLCID;
}
//Load a type lib if we don't have the information already.
if (NULL==*ppITI)
{
hr=LoadRegTypeLib(jlibid, atoi(jversion), 0, PRIMARYLANGID(lcid), &pITypeLib);
if (FAILED(hr)) return hr;
//Got the type lib, get type info for the interface we want
hr=pITypeLib->GetTypeInfoOfGuid(jiid, ppITI);
pITypeLib->Release();
if (FAILED(hr)) return hr;
}
// the type library is still loaded since we have an ITypeInfo from it.
(*ppITI)->AddRef();
*ppITypeInfo=*ppITI;
return NOERROR;
}
bool EventSink::create()
{
// Retrieve the type information for the _IiTiunesEvents base
// Requesting iTunes COM SDK version 1.12
VARIANT_BOOL compatible;
HRESULT result = controller_->itunes_->CheckVersion(1, 12, &compatible);
if (FAILED(result))
{
controller_->comError("Cannot query iTunes COM SDK version");
return false;
}
if (!compatible)
{
controller_->comError("iTunes is not compatible with iTunes COM SDK version 1.12 (it is too old)");
return false;
}
ITypeLib *typeLib = NULL ;
result = ::LoadRegTypeLib(LIBID_iTunesLib, 1, 12, 0, &typeLib);
if (FAILED(result))
{
controller_->comError("Could not load iTunes COM SDK version 1.12");
return false;
}
result = typeLib->GetTypeInfoOfGuid(DIID__IiTunesEvents, &typeInfo_) ;
typeLib->Release();
if (FAILED(result))
{
controller_->comError("Could not retrieve iTunes COM SDK type info");
return false;
}
return true;
}
ITypeInfo *tCOMUtil::GetDispatchTypeInfo(IDispatch* pdisp)
{
ITypeInfo* typeinfo = NULL;
HRESULT hr = pdisp->GetTypeInfo(0, LOCALE_SYSTEM_DEFAULT, &typeinfo);
if(FAILED(hr))
return NULL;
TYPEATTR *ptypeattr = NULL;
typeinfo->GetTypeAttr(&ptypeattr);
TYPEKIND typekind = ptypeattr->typekind;
if(typekind == TKIND_DISPATCH)
{
typeinfo->ReleaseTypeAttr(ptypeattr);
return typeinfo;
}
// tries to find another description of the same
// interface in the typelib with TKIND_DISPATCH
ITypeLib *ptypelib = NULL;
unsigned int dumb = 0;
IID iid = ptypeattr->guid;
hr = typeinfo->GetContainingTypeLib(&ptypelib, &dumb);
typeinfo->ReleaseTypeAttr(ptypeattr);
// if there's no containing type lib, we have to
// trust this one is the right type info
if(FAILED(hr))
return typeinfo;
// obtem a typeinfo do iid fornecido
// caso haja uma implementacao dispinterface,
// esta' e' que sera' retornada (segundo
// documentacao do ActiveX
ITypeInfo* typeinfo_guid = NULL;
hr = ptypelib->GetTypeInfoOfGuid(iid, &typeinfo_guid);
if(FAILED(hr))
{
ptypelib->Release();
return typeinfo;
}
// verifica se e' dispinterface
TYPEATTR *ptypeattr_iface = NULL;
hr = typeinfo_guid->GetTypeAttr(&ptypeattr_iface);
TYPEKIND typekind_iface = ptypeattr_iface->typekind;
typeinfo_guid->ReleaseTypeAttr(ptypeattr_iface);
if(typekind_iface == TKIND_DISPATCH)
{
// releases original type information
COM_RELEASE(typeinfo);
return typeinfo_guid;
}
else
{
COM_RELEASE(typeinfo_guid);
// returns original type info
return typeinfo;
}
}
STDMETHODIMP
CBaseDispatch::GetTypeInfo(
REFIID riid,
UINT itinfo,
LCID lcid,
ITypeInfo ** pptinfo)
{
CheckPointer(pptinfo,E_POINTER);
ValidateReadWritePtr(pptinfo,sizeof(ITypeInfo *));
HRESULT hr;
*pptinfo = NULL;
// we only support one type element
if (0 != itinfo) {
return TYPE_E_ELEMENTNOTFOUND;
}
if (NULL == pptinfo) {
return E_POINTER;
}
// always look for neutral
if (NULL == m_pti) {
LPLOADTYPELIB lpfnLoadTypeLib;
LPLOADREGTYPELIB lpfnLoadRegTypeLib;
ITypeLib *ptlib;
HINSTANCE hInst;
static const char szTypeLib[] = "LoadTypeLib";
static const char szRegTypeLib[] = "LoadRegTypeLib";
static const WCHAR szControl[] = L"control.tlb";
//
// Try to get the Ole32Aut.dll module handle.
//
hInst = LoadOLEAut32();
if (hInst == NULL) {
DWORD dwError = GetLastError();
return AmHresultFromWin32(dwError);
}
lpfnLoadRegTypeLib = (LPLOADREGTYPELIB)GetProcAddress(hInst,
szRegTypeLib);
if (lpfnLoadRegTypeLib == NULL) {
DWORD dwError = GetLastError();
return AmHresultFromWin32(dwError);
}
hr = (*lpfnLoadRegTypeLib)(LIBID_QuartzTypeLib, 1, 0, // version 1.0
lcid, &ptlib);
if (FAILED(hr)) {
// attempt to load directly - this will fill the
// registry in if it finds it
lpfnLoadTypeLib = (LPLOADTYPELIB)GetProcAddress(hInst, szTypeLib);
if (lpfnLoadTypeLib == NULL) {
DWORD dwError = GetLastError();
return AmHresultFromWin32(dwError);
}
hr = (*lpfnLoadTypeLib)(szControl, &ptlib);
if (FAILED(hr)) {
return hr;
}
}
hr = ptlib->GetTypeInfoOfGuid(
riid,
&m_pti);
ptlib->Release();
if (FAILED(hr)) {
return hr;
}
}
*pptinfo = m_pti;
m_pti->AddRef();
return S_OK;
}
HRESULT ff::ComBaseEx::_GetClassInfo(ITypeInfo **typeInfo) const
{
assertRetVal(typeInfo, E_INVALIDARG);
ITypeLib *typeLib = _GetSourceModule().GetTypeLib(_GetTypeLibIndex());
return typeLib != nullptr ? typeLib->GetTypeInfoOfGuid(_GetClassID(), typeInfo) : E_FAIL;
}
