| /* |
| * Copyright 2001 Hidenori Takeshima |
| * |
| * FIXME - stub |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2.1 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public |
| * License along with this library; if not, write to the Free Software |
| * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| */ |
| |
| #include "config.h" |
| |
| #include "winerror.h" |
| #include "winnls.h" /* for PRIMARYLANGID */ |
| #include "winreg.h" /* for HKEY_LOCAL_MACHINE */ |
| #include "winuser.h" |
| #include "oleauto.h" |
| |
| #include "typelib.h" |
| |
| #include "wine/debug.h" |
| WINE_DEFAULT_DEBUG_CHANNEL(ole); |
| |
| typedef struct CTypeInfo2Impl |
| { |
| ICOM_VFIELD(ITypeInfo2); |
| UINT ref; |
| |
| INTERFACEDATA ifd; |
| LCID lcid; |
| } CTypeInfo2Impl; |
| |
| static OLECHAR* olestrdup(OLECHAR* psz) |
| { |
| OLECHAR* pret; |
| DWORD cb; |
| |
| cb = (lstrlenW(psz)+1) * sizeof(OLECHAR); |
| pret = (OLECHAR*)HeapAlloc( GetProcessHeap(), 0, cb ); |
| if ( pret != NULL ) |
| memcpy( pret, psz, cb ); |
| return pret; |
| } |
| |
| static HRESULT CTypeInfo2Impl_Construct( |
| CTypeInfo2Impl* This,INTERFACEDATA* pifd,LCID lcid) |
| { |
| DWORD n,k; |
| METHODDATA* pmdst; |
| const METHODDATA* pmsrc; |
| PARAMDATA* pPdst; |
| const PARAMDATA* pPsrc; |
| |
| This->ifd.pmethdata = (METHODDATA*)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(METHODDATA)*pifd->cMembers); |
| if ( This->ifd.pmethdata == NULL ) return E_OUTOFMEMORY; |
| This->ifd.cMembers = pifd->cMembers; |
| for ( n = 0; n < pifd->cMembers; n++ ) |
| { |
| pmdst = &This->ifd.pmethdata[n]; |
| pmsrc = &pifd->pmethdata[n]; |
| |
| pmdst->szName = olestrdup(pmsrc->szName); |
| if ( pmdst->szName == NULL ) return E_OUTOFMEMORY; |
| pmdst->ppdata = NULL; |
| pmdst->dispid = pmsrc->dispid; |
| pmdst->iMeth = pmsrc->iMeth; |
| pmdst->cc = pmsrc->cc; |
| pmdst->cArgs = pmsrc->cArgs; |
| pmdst->wFlags = pmsrc->wFlags; |
| pmdst->vtReturn = pmsrc->vtReturn; |
| |
| if ( pmsrc->cArgs <= 0 ) continue; |
| pmdst->ppdata = (PARAMDATA*)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(PARAMDATA)*pmsrc->cArgs); |
| if ( pmdst->ppdata == NULL ) return E_OUTOFMEMORY; |
| |
| for ( k = 0; k < pmsrc->cArgs; k++ ) |
| { |
| pPdst = &pmdst->ppdata[k]; |
| pPsrc = &pmsrc->ppdata[k]; |
| pPdst->szName = olestrdup(pPsrc->szName); |
| if ( pPdst->szName == NULL ) return E_OUTOFMEMORY; |
| pPdst->vt = pPsrc->vt; |
| } |
| } |
| |
| This->lcid = lcid; |
| |
| return S_OK; |
| } |
| |
| static void CTypeInfo2Impl_Destruct(CTypeInfo2Impl* This) |
| { |
| DWORD n,k; |
| METHODDATA* pm; |
| PARAMDATA* pP; |
| |
| if ( This->ifd.pmethdata != NULL ) |
| { |
| for ( n = 0; n < This->ifd.cMembers; n++ ) |
| { |
| pm = &This->ifd.pmethdata[n]; |
| if ( pm->szName != NULL ) |
| HeapFree(GetProcessHeap(),0,pm->szName); |
| if ( pm->ppdata == NULL ) continue; |
| |
| for ( k = 0; k < pm->cArgs; k++ ) |
| { |
| pP = &pm->ppdata[k]; |
| if ( pP->szName != NULL ) |
| HeapFree(GetProcessHeap(),0,pP->szName); |
| } |
| HeapFree(GetProcessHeap(),0,pm->ppdata); |
| } |
| HeapFree(GetProcessHeap(),0,This->ifd.pmethdata); |
| This->ifd.pmethdata = NULL; |
| } |
| } |
| |
| /****************************************************************************/ |
| |
| static const METHODDATA* CTypeInfo2Impl_SearchMethodByName( |
| CTypeInfo2Impl* This,const OLECHAR* pName) |
| { |
| DWORD n; |
| METHODDATA* pm; |
| |
| for ( n = 0; n < This->ifd.cMembers; n++ ) |
| { |
| pm = &This->ifd.pmethdata[n]; |
| if ( !lstrcmpiW(pm->szName,pName) ) |
| return pm; |
| } |
| |
| return NULL; |
| } |
| |
| static const METHODDATA* CTypeInfo2Impl_SearchMethodByDispIDAndFlags( |
| CTypeInfo2Impl* This,DISPID dispid,UINT16 wFlags) |
| { |
| DWORD n; |
| METHODDATA* pm; |
| |
| for ( n = 0; n < This->ifd.cMembers; n++ ) |
| { |
| pm = &This->ifd.pmethdata[n]; |
| if ( (pm->dispid == dispid) && (pm->wFlags & wFlags) ) |
| return pm; |
| } |
| |
| return NULL; |
| } |
| |
| |
| static int CTypeInfo2Impl_SearchParamByName( |
| const METHODDATA* pm,const OLECHAR* pName) |
| { |
| PARAMDATA* pP; |
| DWORD k; |
| |
| for ( k = 0; k < pm->cArgs; k++ ) |
| { |
| pP = &pm->ppdata[k]; |
| if ( !lstrcmpiW(pP->szName,pName) ) |
| return (int)k; |
| } |
| |
| return -1; |
| } |
| |
| |
| /****************************************************************************/ |
| |
| static HRESULT WINAPI CTypeInfo2Impl_fnQueryInterface( |
| ITypeInfo2* iface,REFIID riid,void** ppvobj) |
| { |
| ICOM_THIS(CTypeInfo2Impl,iface); |
| |
| TRACE("(%p)->(IID: %s)\n",This,debugstr_guid(riid)); |
| |
| *ppvobj = NULL; |
| if ( IsEqualIID(riid, &IID_IUnknown) || |
| IsEqualIID(riid, &IID_ITypeInfo) || |
| IsEqualIID(riid, &IID_ITypeInfo2) ) |
| { |
| *ppvobj = (void*)iface; |
| ITypeInfo2_AddRef(iface); |
| return S_OK; |
| } |
| |
| return E_NOINTERFACE; |
| } |
| |
| static ULONG WINAPI CTypeInfo2Impl_fnAddRef(ITypeInfo2* iface) |
| { |
| ICOM_THIS(CTypeInfo2Impl,iface); |
| |
| return ++ This->ref; |
| } |
| |
| static ULONG WINAPI CTypeInfo2Impl_fnRelease(ITypeInfo2* iface) |
| { |
| ICOM_THIS(CTypeInfo2Impl,iface); |
| |
| if ( -- This->ref > 0 ) return This->ref; |
| |
| ++ This->ref; |
| CTypeInfo2Impl_Destruct(This); |
| HeapFree(GetProcessHeap(),0,This); |
| return 0; |
| } |
| |
| static HRESULT WINAPI CTypeInfo2Impl_fnGetTypeAttr( |
| ITypeInfo2* iface,LPTYPEATTR* ppTypeAttr) |
| { |
| ICOM_THIS(CTypeInfo2Impl,iface); |
| TYPEATTR* pta; |
| |
| FIXME("(%p)\n",This); |
| |
| if ( ppTypeAttr == NULL ) |
| return E_POINTER; |
| pta = (TYPEATTR*)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(TYPEATTR)); |
| if ( pta == NULL ) return E_OUTOFMEMORY; |
| |
| /* FIXME!!! */ |
| pta->lcid = This->lcid; |
| pta->memidConstructor = MEMBERID_NIL; |
| pta->memidDestructor = MEMBERID_NIL; |
| pta->lpstrSchema = NULL; |
| pta->cbSizeInstance = 0; |
| pta->typekind = 0; |
| pta->cFuncs = This->ifd.cMembers; |
| pta->cVars = 0; |
| pta->cImplTypes = 1; |
| pta->cbSizeVft = sizeof(DWORD)*This->ifd.cMembers; |
| pta->cbAlignment = sizeof(DWORD); |
| pta->wTypeFlags = 0; |
| pta->wMajorVerNum = 1; |
| pta->wMinorVerNum = 0; |
| ZeroMemory( &pta->idldescType, sizeof(pta->idldescType) ); |
| |
| *ppTypeAttr = pta; |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI CTypeInfo2Impl_fnGetTypeComp( |
| ITypeInfo2* iface,ITypeComp** ppTComp) |
| { |
| ICOM_THIS(CTypeInfo2Impl,iface); |
| |
| FIXME("(%p) stub!\n",This); |
| |
| return E_NOTIMPL; |
| } |
| |
| static HRESULT WINAPI CTypeInfo2Impl_fnGetFuncDesc( |
| ITypeInfo2* iface,UINT index,LPFUNCDESC* ppFuncDesc) |
| { |
| ICOM_THIS(CTypeInfo2Impl,iface); |
| |
| FIXME("(%p) stub!\n",This); |
| |
| return E_NOTIMPL; |
| } |
| |
| static HRESULT WINAPI CTypeInfo2Impl_fnGetVarDesc( |
| ITypeInfo2* iface,UINT index,LPVARDESC* ppVarDesc) |
| { |
| ICOM_THIS(CTypeInfo2Impl,iface); |
| |
| FIXME("(%p) stub!\n",This); |
| |
| return E_NOTIMPL; |
| } |
| |
| static HRESULT WINAPI CTypeInfo2Impl_fnGetNames( |
| ITypeInfo2* iface, MEMBERID memid,BSTR* rgBstrNames, |
| UINT cMaxNames, UINT* pcNames) |
| { |
| ICOM_THIS(CTypeInfo2Impl,iface); |
| |
| FIXME("(%p) stub!\n",This); |
| |
| return E_NOTIMPL; |
| } |
| |
| static HRESULT WINAPI CTypeInfo2Impl_fnGetRefTypeOfImplType( |
| ITypeInfo2* iface,UINT index,HREFTYPE* pRefType) |
| { |
| ICOM_THIS(CTypeInfo2Impl,iface); |
| |
| FIXME("(%p) stub!\n",This); |
| |
| return E_NOTIMPL; |
| } |
| |
| static HRESULT WINAPI CTypeInfo2Impl_fnGetImplTypeFlags( |
| ITypeInfo2* iface,UINT index,INT* pImplTypeFlags) |
| { |
| ICOM_THIS(CTypeInfo2Impl,iface); |
| |
| FIXME("(%p) stub!\n",This); |
| |
| return E_NOTIMPL; |
| } |
| |
| static HRESULT WINAPI CTypeInfo2Impl_fnGetIDsOfNames( |
| ITypeInfo2* iface,LPOLESTR* rgszNames,UINT cNames,MEMBERID* pMemId) |
| { |
| ICOM_THIS(CTypeInfo2Impl,iface); |
| const METHODDATA* pm; |
| DWORD n; |
| int index; |
| |
| TRACE("(%p,%s,%u,%p)\n",This,debugstr_w(*rgszNames),cNames,pMemId); |
| |
| if ( rgszNames == NULL || pMemId == NULL ) return E_POINTER; |
| if ( cNames <= 0 ) return E_INVALIDARG; |
| for ( n = 0; n < cNames; n++ ) |
| { |
| if ( rgszNames[n] == NULL ) return E_POINTER; |
| } |
| |
| pm = CTypeInfo2Impl_SearchMethodByName(This,rgszNames[0]); |
| if ( pm == NULL ) return DISP_E_UNKNOWNNAME; |
| pMemId[0] = (MEMBERID)pm->dispid; |
| |
| for ( n = 1; n < cNames; n++ ) |
| { |
| index = CTypeInfo2Impl_SearchParamByName(pm,rgszNames[n]); |
| if ( index < 0 ) return DISP_E_UNKNOWNNAME; |
| pMemId[n] = (MEMBERID)index; |
| } |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI CTypeInfo2Impl_fnInvoke( |
| ITypeInfo2* iface,VOID* punk,MEMBERID memid, |
| UINT16 wFlags,DISPPARAMS* pDispParams,VARIANT* pVarResult, |
| EXCEPINFO* pExcepInfo,UINT* pArgErr) |
| { |
| ICOM_THIS(CTypeInfo2Impl,iface); |
| const METHODDATA* pm; |
| DWORD res; |
| HRESULT hr; |
| int n; |
| DWORD cargs; |
| DWORD* pargs = NULL; |
| VARIANT varError; |
| VARIANT varRet; |
| |
| FIXME("(%p,%p,%ld,%08x,%p,%p,%p,%p)\n", |
| This,punk,(long)memid,(int)wFlags, |
| pDispParams,pVarResult,pExcepInfo,pArgErr); |
| |
| if ( punk == NULL || pArgErr == NULL ) |
| return E_POINTER; |
| |
| pm = CTypeInfo2Impl_SearchMethodByDispIDAndFlags( |
| This,memid,wFlags); |
| if ( pm == NULL ) |
| { |
| ERR("did not find member id %ld, flags %d!\n", (long)memid, (int)wFlags); |
| return DISP_E_MEMBERNOTFOUND; |
| } |
| |
| cargs = pm->cArgs + 1; |
| pargs = (DWORD*)HeapAlloc(GetProcessHeap(), 0, sizeof(DWORD)*(pm->cArgs+2) ); |
| if ( pargs == NULL ) { hr = E_OUTOFMEMORY; goto err_invoke; } |
| |
| V_VT(&varError) = VT_ERROR; |
| pargs[0] = (DWORD)punk; |
| for ( n = 1; n <= (int)pm->cArgs; n++ ) |
| pargs[n] = (DWORD)&varError; /* FIXME? */ |
| |
| if ( (int)pDispParams->cArgs > (int)pm->cArgs ) |
| { |
| hr = E_FAIL; /* FIXME? */ |
| goto err_invoke; |
| } |
| |
| for ( n = 1; n <= (int)pm->cArgs; n++ ) |
| { |
| if ( n <= (int)pDispParams->cNamedArgs ) |
| { |
| /* FIXME - handle named args. */ |
| /* FIXME - check types. */ |
| |
| /* pDispParams->rgdispidNamedArgs */ |
| /* pDispParams->cNamedArgs */ |
| FIXME("named args - %d\n",n); |
| pargs[n] = V_UNION(&pDispParams->rgvarg[pDispParams->cArgs-n],lVal); |
| } |
| else |
| { |
| /* FIXME - check types. */ |
| pargs[n] = V_UNION(&pDispParams->rgvarg[pDispParams->cArgs-n],lVal); |
| } |
| } |
| |
| VariantInit( &varRet ); |
| if ( pm->vtReturn != VT_EMPTY && |
| (!(wFlags & (DISPATCH_PROPERTYPUT|DISPATCH_PROPERTYPUTREF))) ) |
| { |
| if ( pVarResult != NULL ) |
| { |
| pargs[cargs] = (DWORD)pVarResult; |
| } |
| else |
| { |
| pargs[cargs] = (DWORD)(&varRet); |
| } |
| cargs ++; |
| } |
| |
| res = _invoke( |
| (*(DWORD***)punk)[pm->iMeth], |
| pm->cc, cargs, pargs ); |
| VariantClear( &varRet ); |
| |
| if ( res == (DWORD)-1 ) /* FIXME? */ |
| { |
| hr = E_FAIL; |
| goto err_invoke; |
| } |
| |
| hr = S_OK; |
| err_invoke: |
| HeapFree( GetProcessHeap(), 0, pargs ); |
| |
| return hr; |
| } |
| |
| static HRESULT WINAPI CTypeInfo2Impl_fnGetDocumentation( |
| ITypeInfo2* iface, |
| MEMBERID memid, BSTR* pBstrName, BSTR* pBstrDocString, |
| DWORD* pdwHelpContext, BSTR* pBstrHelpFile) |
| { |
| ICOM_THIS(CTypeInfo2Impl,iface); |
| |
| FIXME("(%p) stub!\n",This); |
| |
| return E_NOTIMPL; |
| } |
| |
| static HRESULT WINAPI CTypeInfo2Impl_fnGetDllEntry( |
| ITypeInfo2* iface,MEMBERID memid, |
| INVOKEKIND invKind,BSTR* pBstrDllName,BSTR* pBstrName, |
| WORD* pwOrdinal) |
| { |
| ICOM_THIS(CTypeInfo2Impl,iface); |
| |
| FIXME("(%p) stub!\n",This); |
| |
| return E_NOTIMPL; |
| } |
| |
| static HRESULT WINAPI CTypeInfo2Impl_fnGetRefTypeInfo( |
| ITypeInfo2* iface,HREFTYPE hRefType,ITypeInfo** ppTInfo) |
| { |
| ICOM_THIS(CTypeInfo2Impl,iface); |
| |
| FIXME("(%p) stub!\n",This); |
| |
| return E_NOTIMPL; |
| } |
| |
| static HRESULT WINAPI CTypeInfo2Impl_fnAddressOfMember( |
| ITypeInfo2 *iface, |
| MEMBERID memid,INVOKEKIND invKind,PVOID* ppv) |
| { |
| ICOM_THIS(CTypeInfo2Impl,iface); |
| |
| FIXME("(%p) stub!\n",This); |
| |
| return E_NOTIMPL; |
| } |
| |
| static HRESULT WINAPI CTypeInfo2Impl_fnCreateInstance( |
| ITypeInfo2* iface, |
| IUnknown* punk,REFIID riid,VOID** ppvObj) |
| { |
| ICOM_THIS(CTypeInfo2Impl,iface); |
| |
| FIXME("(%p) stub!\n",This); |
| |
| return E_NOTIMPL; |
| } |
| |
| static HRESULT WINAPI CTypeInfo2Impl_fnGetMops( |
| ITypeInfo2* iface,MEMBERID memid,BSTR* pBstrMops) |
| { |
| ICOM_THIS(CTypeInfo2Impl,iface); |
| |
| FIXME("(%p) stub!\n",This); |
| |
| return E_NOTIMPL; |
| } |
| |
| static HRESULT WINAPI CTypeInfo2Impl_fnGetContainingTypeLib( |
| ITypeInfo2* iface,ITypeLib** ppTLib,UINT* pIndex) |
| { |
| ICOM_THIS(CTypeInfo2Impl,iface); |
| |
| FIXME("(%p) stub!\n",This); |
| |
| return E_NOTIMPL; |
| } |
| |
| static HRESULT WINAPI CTypeInfo2Impl_fnReleaseTypeAttr( |
| ITypeInfo2* iface,TYPEATTR* pTypeAttr) |
| { |
| ICOM_THIS(CTypeInfo2Impl,iface); |
| |
| FIXME("(%p)\n",This); |
| |
| if ( pTypeAttr != NULL ) |
| HeapFree(GetProcessHeap(),0,pTypeAttr); |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI CTypeInfo2Impl_fnReleaseFuncDesc( |
| ITypeInfo2* iface,FUNCDESC* pFuncDesc) |
| { |
| ICOM_THIS(CTypeInfo2Impl,iface); |
| |
| FIXME("(%p) stub!\n",This); |
| |
| return E_NOTIMPL; |
| } |
| |
| static HRESULT WINAPI CTypeInfo2Impl_fnReleaseVarDesc( |
| ITypeInfo2* iface,VARDESC* pVarDesc) |
| { |
| ICOM_THIS(CTypeInfo2Impl,iface); |
| |
| FIXME("(%p) stub!\n",This); |
| |
| return E_NOTIMPL; |
| } |
| |
| static HRESULT WINAPI CTypeInfo2Impl_fnGetTypeKind( |
| ITypeInfo2* iface,TYPEKIND* pTypeKind) |
| { |
| ICOM_THIS(CTypeInfo2Impl,iface); |
| |
| FIXME("(%p) stub!\n",This); |
| |
| return E_NOTIMPL; |
| } |
| |
| static HRESULT WINAPI CTypeInfo2Impl_fnGetTypeFlags( |
| ITypeInfo2* iface,UINT* pTypeFlags) |
| { |
| ICOM_THIS(CTypeInfo2Impl,iface); |
| |
| FIXME("(%p) stub!\n",This); |
| |
| return E_NOTIMPL; |
| } |
| |
| static HRESULT WINAPI CTypeInfo2Impl_fnGetFuncIndexOfMemId( |
| ITypeInfo2* iface, |
| MEMBERID memid,INVOKEKIND invKind,UINT* pFuncIndex) |
| { |
| ICOM_THIS(CTypeInfo2Impl,iface); |
| |
| FIXME("(%p) stub!\n",This); |
| |
| return E_NOTIMPL; |
| } |
| |
| static HRESULT WINAPI CTypeInfo2Impl_fnGetVarIndexOfMemId( |
| ITypeInfo2* iface, |
| MEMBERID memid,UINT* pVarIndex) |
| { |
| ICOM_THIS(CTypeInfo2Impl,iface); |
| |
| FIXME("(%p) stub!\n",This); |
| |
| return E_NOTIMPL; |
| } |
| |
| static HRESULT WINAPI CTypeInfo2Impl_fnGetCustData( |
| ITypeInfo2* iface,REFGUID guid,VARIANT* pVarVal) |
| { |
| ICOM_THIS(CTypeInfo2Impl,iface); |
| |
| FIXME("(%p) stub!\n",This); |
| |
| return E_NOTIMPL; |
| } |
| |
| static HRESULT WINAPI CTypeInfo2Impl_fnGetFuncCustData( |
| ITypeInfo2* iface,UINT index,REFGUID guid,VARIANT* pVarVal) |
| { |
| ICOM_THIS(CTypeInfo2Impl,iface); |
| |
| FIXME("(%p) stub!\n",This); |
| |
| return E_NOTIMPL; |
| } |
| |
| static HRESULT WINAPI CTypeInfo2Impl_fnGetParamCustData( |
| ITypeInfo2* iface,UINT indexFunc,UINT indexParam, |
| REFGUID guid,VARIANT* pVarVal) |
| { |
| ICOM_THIS(CTypeInfo2Impl,iface); |
| |
| FIXME("(%p) stub!\n",This); |
| |
| return E_NOTIMPL; |
| } |
| |
| static HRESULT WINAPI CTypeInfo2Impl_fnGetVarCustData( |
| ITypeInfo2* iface,UINT index,REFGUID guid,VARIANT* pVarVal) |
| { |
| ICOM_THIS(CTypeInfo2Impl,iface); |
| |
| FIXME("(%p) stub!\n",This); |
| |
| return E_NOTIMPL; |
| } |
| |
| static HRESULT WINAPI CTypeInfo2Impl_fnGetImplTypeCustData( |
| ITypeInfo2 * iface,UINT index,REFGUID guid,VARIANT* pVarVal) |
| { |
| ICOM_THIS(CTypeInfo2Impl,iface); |
| |
| FIXME("(%p) stub!\n",This); |
| |
| return E_NOTIMPL; |
| } |
| |
| static HRESULT WINAPI CTypeInfo2Impl_fnGetDocumentation2( |
| ITypeInfo2* iface,MEMBERID memid,LCID lcid, |
| BSTR* pbstrHelpString,DWORD* pdwHelpStringContext,BSTR* pbstrHelpStringDll) |
| { |
| ICOM_THIS(CTypeInfo2Impl,iface); |
| |
| FIXME("(%p) stub!\n",This); |
| |
| return E_NOTIMPL; |
| } |
| |
| static HRESULT WINAPI CTypeInfo2Impl_fnGetAllCustData( |
| ITypeInfo2* iface,CUSTDATA* pCustData) |
| { |
| ICOM_THIS(CTypeInfo2Impl,iface); |
| |
| FIXME("(%p) stub!\n",This); |
| |
| return E_NOTIMPL; |
| } |
| |
| static HRESULT WINAPI CTypeInfo2Impl_fnGetAllFuncCustData( |
| ITypeInfo2* iface,UINT index,CUSTDATA* pCustData) |
| { |
| ICOM_THIS(CTypeInfo2Impl,iface); |
| |
| FIXME("(%p) stub!\n",This); |
| |
| return E_NOTIMPL; |
| } |
| |
| static HRESULT WINAPI CTypeInfo2Impl_fnGetAllParamCustData( |
| ITypeInfo2* iface,UINT indexFunc,UINT indexParam,CUSTDATA* pCustData) |
| { |
| ICOM_THIS(CTypeInfo2Impl,iface); |
| |
| FIXME("(%p) stub!\n",This); |
| |
| return E_NOTIMPL; |
| } |
| |
| static HRESULT WINAPI CTypeInfo2Impl_fnGetAllVarCustData( |
| ITypeInfo2* iface,UINT index,CUSTDATA* pCustData) |
| { |
| ICOM_THIS(CTypeInfo2Impl,iface); |
| |
| FIXME("(%p) stub!\n",This); |
| |
| return E_NOTIMPL; |
| } |
| |
| static HRESULT WINAPI CTypeInfo2Impl_fnGetAllImplTypeCustData( |
| ITypeInfo2* iface,UINT index,CUSTDATA* pCustData) |
| { |
| ICOM_THIS(CTypeInfo2Impl,iface); |
| |
| FIXME("(%p) stub!\n",This); |
| |
| return E_NOTIMPL; |
| } |
| |
| static ICOM_VTABLE(ITypeInfo2) itypeinfo2 = |
| { |
| ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE |
| |
| /* IUnknown */ |
| CTypeInfo2Impl_fnQueryInterface, |
| CTypeInfo2Impl_fnAddRef, |
| CTypeInfo2Impl_fnRelease, |
| /* ITypeInfo */ |
| CTypeInfo2Impl_fnGetTypeAttr, |
| CTypeInfo2Impl_fnGetTypeComp, |
| CTypeInfo2Impl_fnGetFuncDesc, |
| CTypeInfo2Impl_fnGetVarDesc, |
| CTypeInfo2Impl_fnGetNames, |
| CTypeInfo2Impl_fnGetRefTypeOfImplType, |
| CTypeInfo2Impl_fnGetImplTypeFlags, |
| CTypeInfo2Impl_fnGetIDsOfNames, |
| CTypeInfo2Impl_fnInvoke, |
| CTypeInfo2Impl_fnGetDocumentation, |
| CTypeInfo2Impl_fnGetDllEntry, |
| CTypeInfo2Impl_fnGetRefTypeInfo, |
| CTypeInfo2Impl_fnAddressOfMember, |
| CTypeInfo2Impl_fnCreateInstance, |
| CTypeInfo2Impl_fnGetMops, |
| CTypeInfo2Impl_fnGetContainingTypeLib, |
| CTypeInfo2Impl_fnReleaseTypeAttr, |
| CTypeInfo2Impl_fnReleaseFuncDesc, |
| CTypeInfo2Impl_fnReleaseVarDesc, |
| /* ITypeInfo2 */ |
| CTypeInfo2Impl_fnGetTypeKind, |
| CTypeInfo2Impl_fnGetTypeFlags, |
| CTypeInfo2Impl_fnGetFuncIndexOfMemId, |
| CTypeInfo2Impl_fnGetVarIndexOfMemId, |
| CTypeInfo2Impl_fnGetCustData, |
| CTypeInfo2Impl_fnGetFuncCustData, |
| CTypeInfo2Impl_fnGetParamCustData, |
| CTypeInfo2Impl_fnGetVarCustData, |
| CTypeInfo2Impl_fnGetImplTypeCustData, |
| CTypeInfo2Impl_fnGetDocumentation2, |
| CTypeInfo2Impl_fnGetAllCustData, |
| CTypeInfo2Impl_fnGetAllFuncCustData, |
| CTypeInfo2Impl_fnGetAllParamCustData, |
| CTypeInfo2Impl_fnGetAllVarCustData, |
| CTypeInfo2Impl_fnGetAllImplTypeCustData, |
| }; |
| |
| /*****************************************************************************/ |
| |
| HRESULT WINAPI CreateDispTypeInfo( |
| INTERFACEDATA* pifd, |
| LCID lcid, |
| ITypeInfo** ppinfo ) |
| { |
| HRESULT hr; |
| CTypeInfo2Impl* This; |
| |
| if ( ppinfo == NULL ) |
| return E_POINTER; |
| |
| This = (CTypeInfo2Impl*)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(CTypeInfo2Impl)); |
| if ( This == NULL ) return E_OUTOFMEMORY; |
| ICOM_VTBL(This) = &itypeinfo2; |
| This->ref = 1; |
| |
| hr = CTypeInfo2Impl_Construct(This,pifd,lcid); |
| if ( FAILED(hr) ) |
| { |
| IUnknown_Release((IUnknown*)This); |
| return hr; |
| } |
| *ppinfo = (ITypeInfo*)This; |
| |
| return S_OK; |
| } |