From 6463e3823af284f0014034e2a9149595df23b7eb Mon Sep 17 00:00:00 2001 From: Ove Kaaven Date: Sun, 5 Jan 2003 20:31:51 +0000 Subject: [PATCH] Wrote a new oaidl.idl to replace include/wine/obj_oleaut.h and include/wine/obj_errorinfo.h. --- include/Makefile.in | 4 +- include/oaidl.h | 5035 +++++++++++++++++++++++++++++++++- include/oaidl.idl | 1573 +++++++++++ include/wine/obj_errorinfo.h | 110 - include/wine/obj_oleaut.h | 846 ------ 5 files changed, 6579 insertions(+), 989 deletions(-) create mode 100644 include/oaidl.idl delete mode 100644 include/wine/obj_errorinfo.h delete mode 100644 include/wine/obj_oleaut.h diff --git a/include/Makefile.in b/include/Makefile.in index ca23ac69737..3bac23b4fd0 100644 --- a/include/Makefile.in +++ b/include/Makefile.in @@ -5,6 +5,7 @@ VPATH = @srcdir@ MODULE = none IDL_SRCS = \ + oaidl.idl \ objidl.idl \ unknwn.idl \ wtypes.idl @@ -88,7 +89,6 @@ WINDOWS_INCLUDES = \ ntddstor.h \ ntsecapi.h \ ntstatus.h \ - oaidl.h \ objbase.h \ ocidl.h \ ole2.h \ @@ -214,10 +214,8 @@ WINE_INCLUDES = \ obj_dragdrophelper.h \ obj_enumguid.h \ obj_enumidlist.h \ - obj_errorinfo.h \ obj_extracticon.h \ obj_inplace.h \ - obj_oleaut.h \ obj_olefont.h \ obj_oleobj.h \ obj_oleundo.h \ diff --git a/include/oaidl.h b/include/oaidl.h index 24f7c91fdf4..a957830e54c 100644 --- a/include/oaidl.h +++ b/include/oaidl.h @@ -1,38 +1,5013 @@ -/* - * Copyright (C) 1999 Francis Beaudet - * - * 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 - */ - +/*** Autogenerated by WIDL 0.1 from oaidl.idl - Do not edit ***/ #include "rpc.h" #include "rpcndr.h" -#ifndef COM_NO_WINDOWS_H -#include "windows.h" -#include "ole2.h" + +#ifndef __WIDL_OAIDL_H +#define __WIDL_OAIDL_H +#ifdef __cplusplus +extern "C" { +#endif +#include "objidl.h" +typedef struct IDispatch IDispatch; +typedef struct ITypeInfo ITypeInfo; +typedef struct ITypeLib ITypeLib; +typedef struct IRecordInfo IRecordInfo; +typedef CY CURRENCY; + +typedef struct tagSAFEARRAYBOUND { + ULONG cElements; + LONG lLbound; +} SAFEARRAYBOUND, *LPSAFEARRAYBOUND; + +typedef struct _wireVARIANT *wireVARIANT; + +typedef struct _wireBRECORD *wireBRECORD; + +typedef struct _wireSAFEARR_BSTR { + ULONG Size; + wireBSTR *aBstr; +} SAFEARR_BSTR; + +typedef struct _wireSAFEARR_UNKNOWN { + ULONG Size; + IUnknown **apUnknown; +} SAFEARR_UNKNOWN; + +typedef struct _wireSAFEARR_DISPATCH { + ULONG Size; + IDispatch **apDispatch; +} SAFEARR_DISPATCH; + +typedef struct _wireSAFEARR_VARIANT { + ULONG Size; + wireVARIANT *aVariant; +} SAFEARR_VARIANT; + +typedef struct _wireSAFEARR_BRECORD { + ULONG Size; + wireBRECORD *aRecord; +} SAFEARR_BRECORD; + +typedef struct _wireSAFEARR_HAVEIID { + ULONG Size; + IUnknown **apUnknown; + IID iid; +} SAFEARR_HAVEIID; + +typedef enum tagSF_TYPE { + SF_ERROR = VT_ERROR, + SF_I1 = VT_I1, + SF_I2 = VT_I2, + SF_I4 = VT_I4, + SF_I8 = VT_I8, + SF_BSTR = VT_BSTR, + SF_UNKNOWN = VT_UNKNOWN, + SF_DISPATCH = VT_DISPATCH, + SF_VARIANT = VT_VARIANT, + SF_RECORD = VT_RECORD, + SF_HAVEIID = VT_UNKNOWN | VT_RESERVED +} SF_TYPE; + +typedef struct _wireSAFEARRAY_UNION { + ULONG sfType; + union { + SAFEARR_BSTR BstrStr; + SAFEARR_UNKNOWN UnknownStr; + SAFEARR_DISPATCH DispatchStr; + SAFEARR_VARIANT VariantStr; + SAFEARR_BRECORD RecordStr; + SAFEARR_HAVEIID HaveIidStr; + BYTE_SIZEDARR ByteStr; + WORD_SIZEDARR WordStr; + DWORD_SIZEDARR LongStr; + HYPER_SIZEDARR HyperStr; + } u; +} SAFEARRAYUNION; + +typedef struct _wireSAFEARRAY { + USHORT cDims; + USHORT fFeatures; + ULONG cbElements; + ULONG cLocks; + SAFEARRAYUNION uArrayStructs; + SAFEARRAYBOUND rgsabound[1]; +} *wireSAFEARRAY; + +typedef wireSAFEARRAY *wirePSAFEARRAY; + +typedef struct tagSAFEARRAY { + USHORT cDims; + USHORT fFeatures; + ULONG cbElements; + ULONG cLocks; + PVOID pvData; + SAFEARRAYBOUND rgsabound[1]; +} SAFEARRAY; + +typedef SAFEARRAY *LPSAFEARRAY; + +#define FADF_AUTO (0x1) + +#define FADF_STATIC (0x2) + +#define FADF_EMBEDDED (0x4) + +#define FADF_FIXEDSIZE (0x10) + +#define FADF_RECORD (0x20) + +#define FADF_HAVEIID (0x40) + +#define FADF_HAVEVARTYPE (0x80) + +#define FADF_BSTR (0x100) + +#define FADF_UNKNOWN (0x200) + +#define FADF_DISPATCH (0x400) + +#define FADF_VARIANT (0x800) + +#define FADF_RESERVED (0xf008) + +#define FADF_CREATEVECTOR (0x2000) + +#if (__STDC__ && !defined(_FORCENAMELESSUNION)) || defined(NONAMELESSUNION) +#define __VARIANT_NAME_1 n1 +#define __VARIANT_NAME_2 n2 +#define __VARIANT_NAME_3 n3 +#define __VARIANT_NAME_4 brecVal +#else +#define __tagVARIANT +#define __VARIANT_NAME_1 +#define __VARIANT_NAME_2 +#define __VARIANT_NAME_3 +#define __tagBRECORD +#define __VARIANT_NAME_4 +#endif +typedef struct tagVARIANT VARIANT; + +struct tagVARIANT { + union { + struct __tagVARIANT { + VARTYPE vt; + WORD wReserved1; + WORD wReserved2; + WORD wReserved3; + union { + CHAR cVal; + USHORT uiVal; + ULONG ulVal; + INT intVal; + UINT uintVal; + BYTE bVal; + SHORT iVal; + LONG lVal; + FLOAT fltVal; + DOUBLE dblVal; + VARIANT_BOOL boolVal; + SCODE scode; + DATE date; + BSTR bstrVal; + CY cyVal; + IUnknown *punkVal; + IDispatch *pdispVal; + SAFEARRAY *parray; + CHAR *pcVal; + USHORT *puiVal; + ULONG *pulVal; + INT *pintVal; + UINT *puintVal; + BYTE *pbVal; + SHORT *piVal; + LONG *plVal; + FLOAT *pfltVal; + DOUBLE *pdblVal; + VARIANT_BOOL *pboolVal; + SCODE *pscode; + DATE *pdate; + BSTR *pbstrVal; + VARIANT *pvarVal; + PVOID byref; + CY *pcyVal; + DECIMAL *pdecVal; + IUnknown **ppunkVal; + IDispatch **ppdispVal; + SAFEARRAY **pparray; + struct __tagBRECORD { + PVOID pvRecord; + IRecordInfo *pRecInfo; + } __VARIANT_NAME_4; + } __VARIANT_NAME_3; + } __VARIANT_NAME_2; + DECIMAL decVal; + } __VARIANT_NAME_1; +}; + +typedef VARIANT *LPVARIANT; + +typedef VARIANT VARIANTARG; + +typedef VARIANTARG *LPVARIANTARG; + +struct _wireBRECORD { + ULONG fFlags; + ULONG clSize; + IRecordInfo *pRecInfo; + byte *pRecord; +}; + +struct _wireVARIANT { + DWORD clSize; + DWORD rpcReserved; + USHORT vt; + USHORT wReserved1; + USHORT wReserved2; + USHORT wReserved3; + union { + CHAR cVal; + USHORT uiVal; + ULONG ulVal; + INT intVal; + UINT uintVal; + BYTE bVal; + SHORT iVal; + LONG lVal; + FLOAT fltVal; + DOUBLE dblVal; + VARIANT_BOOL boolVal; + SCODE scode; + DATE date; + wireBSTR bstrVal; + CY cyVal; + DECIMAL decVal; + IUnknown *punkVal; + IDispatch *pdispVal; + wireSAFEARRAY parray; + CHAR *pcVal; + USHORT *puiVal; + ULONG *pulVal; + INT *pintVal; + UINT *puintVal; + BYTE *pbVal; + SHORT *piVal; + LONG *plVal; + FLOAT *pfltVal; + DOUBLE *pdblVal; + VARIANT_BOOL *pboolVal; + SCODE *pscode; + DATE *pdate; + wireBSTR *pbstrVal; + wireVARIANT *pvarVal; + CY *pcyVal; + DECIMAL *pdecVal; + IUnknown **ppunkVal; + IDispatch **ppdispVal; + wireSAFEARRAY *pparray; + wireBRECORD brecVal; + } DUMMYUNIONNAME; +}; + +typedef LONG DISPID; + +typedef DWORD HREFTYPE; + +typedef DISPID MEMBERID; + +typedef enum tagTYPEKIND { + TKIND_ENUM = 0, + TKIND_RECORD, + TKIND_MODULE, + TKIND_INTERFACE, + TKIND_DISPATCH, + TKIND_COCLASS, + TKIND_ALIAS, + TKIND_UNION, + TKIND_MAX +} TYPEKIND; + +typedef struct tagTYPEDESC { + union { + struct tagTYPEDESC *lptdesc; + struct tagARRAYDESC *lpadesc; + HREFTYPE hreftype; + } DUMMYUNIONNAME; + VARTYPE vt; +} TYPEDESC; + +typedef struct tagARRAYDESC { + TYPEDESC tdescElem; + USHORT cDims; + SAFEARRAYBOUND rgbounds[1]; +} ARRAYDESC; + +typedef struct tagPARAMDESCEX { + ULONG cBytes; + VARIANTARG varDefaultValue; +} PARAMDESCEX, *LPPARAMDESCEX; + +typedef struct tagPARAMDESC { + LPPARAMDESCEX pparamdescex; + USHORT wParamFlags; +} PARAMDESC, *LPPARAMDESC; + +#define PARAMFLAG_NONE (0x0) + +#define PARAMFLAG_FIN (0x1) + +#define PARAMFLAG_FOUT (0x2) + +#define PARAMFLAG_FLCID (0x4) + +#define PARAMFLAG_FRETVAL (0x8) + +#define PARAMFLAG_FOPT (0x10) + +#define PARAMFLAG_FHASDEFAULT (0x20) + +#define PARAMFLAG_FHASCUSTDATA (0x40) + +typedef struct tagIDLDESC { + ULONG dwReserved; + USHORT wIDLFlags; +} IDLDESC, *LPIDLDESC; + +#define IDLFLAG_NONE (PARAMFLAG_NONE) + +#define IDLFLAG_FIN (PARAMFLAG_FIN) + +#define IDLFLAG_FOUT (PARAMFLAG_FOUT) + +#define IDLFLAG_FLCID (PARAMFLAG_FLCID) + +#define IDLFLAG_FRETVAL (PARAMFLAG_FRETVAL) + +#if 0 +typedef struct tagELEMDESC { + TYPEDESC tdesc; + PARAMDESC paramdesc; +} ELEMDESC; + +#else +typedef struct tagELEMDESC { + TYPEDESC tdesc; + union { + IDLDESC idldesc; + PARAMDESC paramdesc; + } DUMMYUNIONNAME; +} ELEMDESC, *LPELEMDESC; +#endif +typedef struct tagTYPEATTR { + GUID guid; + LCID lcid; + DWORD dwReserved; + MEMBERID memidConstructor; + MEMBERID memidDestructor; + LPOLESTR lpstrSchema; + ULONG cbSizeInstance; + TYPEKIND typekind; + WORD cFuncs; + WORD cVars; + WORD cImplTypes; + WORD cbSizeVft; + WORD cbAlignment; + WORD wTypeFlags; + WORD wMajorVerNum; + WORD wMinorVerNum; + TYPEDESC tdescAlias; + IDLDESC idldescType; +} TYPEATTR, *LPTYPEATTR; + +typedef struct tagDISPPARAMS { + VARIANTARG *rgvarg; + DISPID *rgdispidNamedArgs; + UINT cArgs; + UINT cNamedArgs; +} DISPPARAMS; + +#if 0 +typedef struct tagEXCEPINFO { + WORD wCode; + WORD wReserved; + BSTR bstrSource; + BSTR bstrDescription; + BSTR bstrHelpFile; + DWORD dwHelpContext; + ULONG pvReserved; + ULONG pfnDeferredFillIn; + SCODE scode; +} EXCEPINFO; + +#else +typedef struct tagEXCEPINFO { + WORD wCode; + WORD wReserved; + BSTR bstrSource; + BSTR bstrDescription; + BSTR bstrHelpFile; + DWORD dwHelpContext; + PVOID pvReserved; + HRESULT (__stdcall *pfnDeferredFillIn)(struct tagEXCEPINFO *); + SCODE scode; +} EXCEPINFO, *LPEXCEPINFO; +#endif +typedef enum tagCALLCONV { + CC_FASTCALL = 0, + CC_CDECL = 1, + CC_MSCPASCAL, + CC_PASCAL = CC_MSCPASCAL, + CC_MACPASCAL, + CC_STDCALL, + CC_FPFASTCALL, + CC_SYSCALL, + CC_MPWCDECL, + CC_MPWPASCAL, + CC_MAX +} CALLCONV; + +typedef enum tagFUNCKIND { + FUNC_VIRTUAL, + FUNC_PUREVIRTUAL, + FUNC_NONVIRTUAL, + FUNC_STATIC, + FUNC_DISPATCH +} FUNCKIND; + +typedef enum tagINVOKEKIND { + INVOKE_FUNC = 1, + INVOKE_PROPERTYGET = 2, + INVOKE_PROPERTYPUT = 4, + INVOKE_PROPERTYPUTREF = 8 +} INVOKEKIND; + +typedef struct tagFUNCDESC { + MEMBERID memid; + SCODE *lprgscode; + ELEMDESC *lprgelemdescParam; + FUNCKIND funckind; + INVOKEKIND invkind; + CALLCONV callconv; + SHORT cParams; + SHORT cParamsOpt; + SHORT oVft; + SHORT cScodes; + ELEMDESC elemdescFunc; + WORD wFuncFlags; +} FUNCDESC, *LPFUNCDESC; + +typedef enum tagVARKIND { + VAR_PERINSTANCE, + VAR_STATIC, + VAR_CONST, + VAR_DISPATCH +} VARKIND; + +#define IMPLTYPEFLAG_FDEFAULT (0x1) + +#define IMPLTYPEFLAG_FSOURCE (0x2) + +#define IMPLTYPEFLAG_FRESTRICTED (0x4) + +#define IMPLTYPEFLAG_FDEFAULTVTABLE (0x8) + +typedef struct tagVARDESC { + MEMBERID memid; + LPOLESTR lpstrSchema; + union { + ULONG oInst; + VARIANT *lpvarValue; + } DUMMYUNIONNAME; + ELEMDESC elemdescVar; + WORD wVarFlags; + VARKIND varkind; +} VARDESC, *LPVARDESC; + +typedef enum tagTYPEFLAGS { + TYPEFLAG_FAPPOBJECT = 0x1, + TYPEFLAG_FCANCREATE = 0x2, + TYPEFLAG_FLICENSED = 0x4, + TYPEFLAG_FPREDECLID = 0x8, + TYPEFLAG_FHIDDEN = 0x10, + TYPEFLAG_FCONTROL = 0x20, + TYPEFLAG_FDUAL = 0x40, + TYPEFLAG_FNONEXTENSIBLE = 0x80, + TYPEFLAG_FOLEAUTOMATION = 0x100, + TYPEFLAG_FRESTRICTED = 0x200, + TYPEFLAG_FAGGREGATABLE = 0x400, + TYPEFLAG_FREPLACEABLE = 0x800, + TYPEFLAG_FDISPATCHABLE = 0x1000, + TYPEFLAG_FREVERSEBIND = 0x2000, + TYPEFLAG_FPROXY = 0x4000 +} TYPEFLAGS; + +typedef enum tagFUNCFLAGS { + FUNCFLAG_FRESTRICTED = 0x1, + FUNCFLAG_FSOURCE = 0x2, + FUNCFLAG_FBINDABLE = 0x4, + FUNCFLAG_FREQUESTEDIT = 0x8, + FUNCFLAG_FDISPLAYBIND = 0x10, + FUNCFLAG_FDEFAULTBIND = 0x20, + FUNCFLAG_FHIDDEN = 0x40, + FUNCFLAG_FUSESGETLASTERROR = 0x80, + FUNCFLAG_FDEFAULTCOLLELEM = 0x100, + FUNCFLAG_FUIDEFAULT = 0x200, + FUNCFLAG_FNONBROWSABLE = 0x400, + FUNCFLAG_FREPLACEABLE = 0x800, + FUNCFLAG_FIMMEDIATEBIND = 0x1000 +} FUNCFLAGS; + +typedef enum tagVARFLAGS { + VARFLAG_FREADONLY = 0x1, + VARFLAG_FSOURCE = 0x2, + VARFLAG_FBINDABLE = 0x4, + VARFLAG_FREQUESTEDIT = 0x8, + VARFLAG_FDISPLAYBIND = 0x10, + VARFLAG_FDEFAULTBIND = 0x20, + VARFLAG_FHIDDEN = 0x40, + VARFLAG_FRESTRICTED = 0x80, + VARFLAG_FDEFAULTCOLLELEM = 0x100, + VARFLAG_FUIDEFAULT = 0x200, + VARFLAG_FNONBROWSABLE = 0x400, + VARFLAG_FREPLACEABLE = 0x800, + VARFLAG_FIMMEDIATEBIND = 0x1000 +} VARFLAGS; + +typedef struct tagCLEANLOCALSTORAGE { + IUnknown *pInterface; + PVOID pStorage; + DWORD flags; +} CLEANLOCALSTORAGE; + +typedef struct tagCUSTDATAITEM { + GUID guid; + VARIANTARG varValue; +} CUSTDATAITEM, *LPCUSTDATAITEM; + +typedef struct tagCUSTDATA { + DWORD cCustData; + LPCUSTDATAITEM prgCustData; +} CUSTDATA, *LPCUSTDATA; + +typedef IDispatch *LPDISPATCH; + +#define DISPID_UNKNOWN (-1) + +#define DISPID_VALUE (0) + +#define DISPID_PROPERTYPUT (-3) + +#define DISPID_NEWENUM (-4) + +#define DISPID_EVALUATE (-5) + +#define DISPID_CONSTRUCTOR (-6) + +#define DISPID_DESTRUCTOR (-7) + +#define DISPID_COLLECT (-8) + +/***************************************************************************** + * IDispatch interface + */ +DEFINE_GUID(IID_IDispatch, 0x00020400, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IDispatch: IUnknown { + + virtual HRESULT CALLBACK GetTypeInfoCount( + UINT* pctinfo) = 0; + + virtual HRESULT CALLBACK GetTypeInfo( + UINT iTInfo, + LCID lcid, + ITypeInfo** ppTInfo) = 0; + + virtual HRESULT CALLBACK GetIDsOfNames( + REFIID riid, + LPOLESTR* rgszNames, + UINT cNames, + LCID lcid, + DISPID* rgDispId) = 0; + + virtual HRESULT CALLBACK Invoke( + DISPID dispIdMember, + REFIID riid, + LCID lcid, + WORD wFlags, + DISPPARAMS* pDispParams, + VARIANT* pVarResult, + EXCEPINFO* pExcepInfo, + UINT* puArgErr) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct IDispatchVtbl IDispatchVtbl; +struct IDispatch { + const IDispatchVtbl* lpVtbl; +}; +struct IDispatchVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + IDispatch* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + IDispatch* This); + + ULONG (CALLBACK *Release)( + IDispatch* This); + + /*** IDispatch methods ***/ + HRESULT (CALLBACK *GetTypeInfoCount)( + IDispatch* This, + UINT* pctinfo); + + HRESULT (CALLBACK *GetTypeInfo)( + IDispatch* This, + UINT iTInfo, + LCID lcid, + ITypeInfo** ppTInfo); + + HRESULT (CALLBACK *GetIDsOfNames)( + IDispatch* This, + REFIID riid, + LPOLESTR* rgszNames, + UINT cNames, + LCID lcid, + DISPID* rgDispId); + + HRESULT (CALLBACK *Invoke)( + IDispatch* This, + DISPID dispIdMember, + REFIID riid, + LCID lcid, + WORD wFlags, + DISPPARAMS* pDispParams, + VARIANT* pVarResult, + EXCEPINFO* pExcepInfo, + UINT* puArgErr); + +}; + +#define IDispatch_IMETHODS \ + IUnknown_IMETHODS \ + ICOM_METHOD1 (HRESULT,GetTypeInfoCount,UINT*,pctinfo) \ + ICOM_METHOD3 (HRESULT,GetTypeInfo,UINT,iTInfo,LCID,lcid,ITypeInfo**,ppTInfo) \ + ICOM_METHOD5 (HRESULT,GetIDsOfNames,REFIID,riid,LPOLESTR*,rgszNames,UINT,cNames,LCID,lcid,DISPID*,rgDispId) \ + ICOM_METHOD8 (HRESULT,Invoke,DISPID,dispIdMember,REFIID,riid,LCID,lcid,WORD,wFlags,DISPPARAMS*,pDispParams,VARIANT*,pVarResult,EXCEPINFO*,pExcepInfo,UINT*,puArgErr) + +/*** IUnknown methods ***/ +#define IDispatch_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDispatch_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDispatch_Release(p) (p)->lpVtbl->Release(p) +/*** IDispatch methods ***/ +#define IDispatch_GetTypeInfoCount(p,a) (p)->lpVtbl->GetTypeInfoCount(p,a) +#define IDispatch_GetTypeInfo(p,a,b,c) (p)->lpVtbl->GetTypeInfo(p,a,b,c) +#define IDispatch_GetIDsOfNames(p,a,b,c,d,e) (p)->lpVtbl->GetIDsOfNames(p,a,b,c,d,e) +#define IDispatch_Invoke(p,a,b,c,d,e,f,g,h) (p)->lpVtbl->Invoke(p,a,b,c,d,e,f,g,h) + #endif -#ifndef __WINE_OAIDL_H -#define __WINE_OAIDL_H +HRESULT CALLBACK IDispatch_GetTypeInfoCount_Proxy( + IDispatch* This, + UINT* pctinfo); +void __RPC_STUB IDispatch_GetTypeInfoCount_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IDispatch_GetTypeInfo_Proxy( + IDispatch* This, + UINT iTInfo, + LCID lcid, + ITypeInfo** ppTInfo); +void __RPC_STUB IDispatch_GetTypeInfo_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IDispatch_GetIDsOfNames_Proxy( + IDispatch* This, + REFIID riid, + LPOLESTR* rgszNames, + UINT cNames, + LCID lcid, + DISPID* rgDispId); +void __RPC_STUB IDispatch_GetIDsOfNames_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IDispatch_RemoteInvoke_Proxy( + IDispatch* This, + DISPID dispIdMember, + REFIID riid, + LCID lcid, + DWORD dwFlags, + DISPPARAMS* pDispParams, + VARIANT* pVarResult, + EXCEPINFO* pExcepInfo, + UINT* pArgErr, + UINT cVarRef, + UINT* rgVarRefIdx, + VARIANTARG* rgVarRef); +void __RPC_STUB IDispatch_RemoteInvoke_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IDispatch_Invoke_Proxy( + IDispatch* This, + DISPID dispIdMember, + REFIID riid, + LCID lcid, + WORD wFlags, + DISPPARAMS* pDispParams, + VARIANT* pVarResult, + EXCEPINFO* pExcepInfo, + UINT* puArgErr); +HRESULT __RPC_STUB IDispatch_Invoke_Stub( + IDispatch* This, + DISPID dispIdMember, + REFIID riid, + LCID lcid, + DWORD dwFlags, + DISPPARAMS* pDispParams, + VARIANT* pVarResult, + EXCEPINFO* pExcepInfo, + UINT* pArgErr, + UINT cVarRef, + UINT* rgVarRefIdx, + VARIANTARG* rgVarRef); + +typedef struct IEnumVARIANT IEnumVARIANT; +typedef IEnumVARIANT *LPENUMVARIANT; + +/***************************************************************************** + * IEnumVARIANT interface + */ +DEFINE_GUID(IID_IEnumVARIANT, 0x00020404, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IEnumVARIANT: IUnknown { + + virtual HRESULT CALLBACK Next( + ULONG celt, + VARIANT* rgVar, + ULONG* pCeltFetched) = 0; + + virtual HRESULT CALLBACK Skip( + ULONG celt) = 0; + + virtual HRESULT CALLBACK Reset( + ) = 0; + + virtual HRESULT CALLBACK Clone( + IEnumVARIANT** ppEnum) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct IEnumVARIANTVtbl IEnumVARIANTVtbl; +struct IEnumVARIANT { + const IEnumVARIANTVtbl* lpVtbl; +}; +struct IEnumVARIANTVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + IEnumVARIANT* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + IEnumVARIANT* This); + + ULONG (CALLBACK *Release)( + IEnumVARIANT* This); + + /*** IEnumVARIANT methods ***/ + HRESULT (CALLBACK *Next)( + IEnumVARIANT* This, + ULONG celt, + VARIANT* rgVar, + ULONG* pCeltFetched); + + HRESULT (CALLBACK *Skip)( + IEnumVARIANT* This, + ULONG celt); + + HRESULT (CALLBACK *Reset)( + IEnumVARIANT* This); + + HRESULT (CALLBACK *Clone)( + IEnumVARIANT* This, + IEnumVARIANT** ppEnum); + +}; + +#define IEnumVARIANT_IMETHODS \ + IUnknown_IMETHODS \ + ICOM_METHOD3 (HRESULT,Next,ULONG,celt,VARIANT*,rgVar,ULONG*,pCeltFetched) \ + ICOM_METHOD1 (HRESULT,Skip,ULONG,celt) \ + ICOM_METHOD (HRESULT,Reset) \ + ICOM_METHOD1 (HRESULT,Clone,IEnumVARIANT**,ppEnum) + +/*** IUnknown methods ***/ +#define IEnumVARIANT_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IEnumVARIANT_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IEnumVARIANT_Release(p) (p)->lpVtbl->Release(p) +/*** IEnumVARIANT methods ***/ +#define IEnumVARIANT_Next(p,a,b,c) (p)->lpVtbl->Next(p,a,b,c) +#define IEnumVARIANT_Skip(p,a) (p)->lpVtbl->Skip(p,a) +#define IEnumVARIANT_Reset(p) (p)->lpVtbl->Reset(p) +#define IEnumVARIANT_Clone(p,a) (p)->lpVtbl->Clone(p,a) -#if defined(__WINESRC__) && !defined(INITGUID) && !defined(__WINE_INCLUDE_OAIDL) -#error DO NOT INCLUDE DIRECTLY #endif -#include "objbase.h" -/* the following depend only on obj_base.h */ -#include "wine/obj_oleaut.h" -#include "wine/obj_errorinfo.h" +HRESULT CALLBACK IEnumVARIANT_RemoteNext_Proxy( + IEnumVARIANT* This, + ULONG celt, + VARIANT* rgVar, + ULONG* pCeltFetched); +void __RPC_STUB IEnumVARIANT_RemoteNext_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IEnumVARIANT_Next_Proxy( + IEnumVARIANT* This, + ULONG celt, + VARIANT* rgVar, + ULONG* pCeltFetched); +HRESULT __RPC_STUB IEnumVARIANT_Next_Stub( + IEnumVARIANT* This, + ULONG celt, + VARIANT* rgVar, + ULONG* pCeltFetched); +HRESULT CALLBACK IEnumVARIANT_Skip_Proxy( + IEnumVARIANT* This, + ULONG celt); +void __RPC_STUB IEnumVARIANT_Skip_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IEnumVARIANT_Reset_Proxy( + IEnumVARIANT* This); +void __RPC_STUB IEnumVARIANT_Reset_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IEnumVARIANT_Clone_Proxy( + IEnumVARIANT* This, + IEnumVARIANT** ppEnum); +void __RPC_STUB IEnumVARIANT_Clone_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); -#endif /* _WINE_OAIDL_H */ +typedef struct ITypeComp ITypeComp; +typedef ITypeComp *LPTYPECOMP; + +typedef enum tagDESCKIND { + DESCKIND_NONE = 0, + DESCKIND_FUNCDESC, + DESCKIND_VARDESC, + DESCKIND_TYPECOMP, + DESCKIND_IMPLICITAPPOBJ, + DESCKIND_MAX +} DESCKIND; + +typedef union tagBINDPTR { + FUNCDESC *lpfuncdesc; + VARDESC *lpvardesc; + ITypeComp *lptcomp; +} BINDPTR, *LPBINDPTR; + +/***************************************************************************** + * ITypeComp interface + */ +DEFINE_GUID(IID_ITypeComp, 0x00020403, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct ITypeComp: IUnknown { + + virtual HRESULT CALLBACK Bind( + LPOLESTR szName, + ULONG lHashVal, + WORD wFlags, + ITypeInfo** ppTInfo, + DESCKIND* pDescKind, + BINDPTR* pBindPtr) = 0; + + virtual HRESULT CALLBACK BindType( + LPOLESTR szName, + ULONG lHashVal, + ITypeInfo** ppTInfo, + ITypeComp** ppTComp) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct ITypeCompVtbl ITypeCompVtbl; +struct ITypeComp { + const ITypeCompVtbl* lpVtbl; +}; +struct ITypeCompVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + ITypeComp* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + ITypeComp* This); + + ULONG (CALLBACK *Release)( + ITypeComp* This); + + /*** ITypeComp methods ***/ + HRESULT (CALLBACK *Bind)( + ITypeComp* This, + LPOLESTR szName, + ULONG lHashVal, + WORD wFlags, + ITypeInfo** ppTInfo, + DESCKIND* pDescKind, + BINDPTR* pBindPtr); + + HRESULT (CALLBACK *BindType)( + ITypeComp* This, + LPOLESTR szName, + ULONG lHashVal, + ITypeInfo** ppTInfo, + ITypeComp** ppTComp); + +}; + +#define ITypeComp_IMETHODS \ + IUnknown_IMETHODS \ + ICOM_METHOD6 (HRESULT,Bind,LPOLESTR,szName,ULONG,lHashVal,WORD,wFlags,ITypeInfo**,ppTInfo,DESCKIND*,pDescKind,BINDPTR*,pBindPtr) \ + ICOM_METHOD4 (HRESULT,BindType,LPOLESTR,szName,ULONG,lHashVal,ITypeInfo**,ppTInfo,ITypeComp**,ppTComp) + +/*** IUnknown methods ***/ +#define ITypeComp_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define ITypeComp_AddRef(p) (p)->lpVtbl->AddRef(p) +#define ITypeComp_Release(p) (p)->lpVtbl->Release(p) +/*** ITypeComp methods ***/ +#define ITypeComp_Bind(p,a,b,c,d,e,f) (p)->lpVtbl->Bind(p,a,b,c,d,e,f) +#define ITypeComp_BindType(p,a,b,c,d) (p)->lpVtbl->BindType(p,a,b,c,d) + +#endif + +HRESULT CALLBACK ITypeComp_RemoteBind_Proxy( + ITypeComp* This, + LPOLESTR szName, + ULONG lHashVal, + WORD wFlags, + ITypeInfo** ppTInfo, + DESCKIND* pDescKind, + LPFUNCDESC* ppFuncDesc, + LPVARDESC* ppVarDesc, + ITypeComp** ppTypeComp, + CLEANLOCALSTORAGE* pDummy); +void __RPC_STUB ITypeComp_RemoteBind_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ITypeComp_Bind_Proxy( + ITypeComp* This, + LPOLESTR szName, + ULONG lHashVal, + WORD wFlags, + ITypeInfo** ppTInfo, + DESCKIND* pDescKind, + BINDPTR* pBindPtr); +HRESULT __RPC_STUB ITypeComp_Bind_Stub( + ITypeComp* This, + LPOLESTR szName, + ULONG lHashVal, + WORD wFlags, + ITypeInfo** ppTInfo, + DESCKIND* pDescKind, + LPFUNCDESC* ppFuncDesc, + LPVARDESC* ppVarDesc, + ITypeComp** ppTypeComp, + CLEANLOCALSTORAGE* pDummy); +HRESULT CALLBACK ITypeComp_RemoteBindType_Proxy( + ITypeComp* This, + LPOLESTR szName, + ULONG lHashVal, + ITypeInfo** ppTInfo); +void __RPC_STUB ITypeComp_RemoteBindType_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ITypeComp_BindType_Proxy( + ITypeComp* This, + LPOLESTR szName, + ULONG lHashVal, + ITypeInfo** ppTInfo, + ITypeComp** ppTComp); +HRESULT __RPC_STUB ITypeComp_BindType_Stub( + ITypeComp* This, + LPOLESTR szName, + ULONG lHashVal, + ITypeInfo** ppTInfo); + +typedef ITypeInfo *LPTYPEINFO; + +/***************************************************************************** + * ITypeInfo interface + */ +DEFINE_GUID(IID_ITypeInfo, 0x00020401, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct ITypeInfo: IUnknown { + + virtual HRESULT CALLBACK GetTypeAttr( + TYPEATTR** ppTypeAttr) = 0; + + virtual HRESULT CALLBACK GetTypeComp( + ITypeComp** ppTComp) = 0; + + virtual HRESULT CALLBACK GetFuncDesc( + UINT index, + FUNCDESC** ppFuncDesc) = 0; + + virtual HRESULT CALLBACK GetVarDesc( + UINT index, + VARDESC** ppVarDesc) = 0; + + virtual HRESULT CALLBACK GetNames( + MEMBERID memid, + BSTR* rgBstrNames, + UINT cMaxNames, + UINT* pcNames) = 0; + + virtual HRESULT CALLBACK GetRefTypeOfImplType( + UINT index, + HREFTYPE* pRefType) = 0; + + virtual HRESULT CALLBACK GetImplTypeFlags( + UINT index, + INT* pImplTypeFlags) = 0; + + virtual HRESULT CALLBACK GetIDsOfNames( + LPOLESTR* rgszNames, + UINT cNames, + MEMBERID* pMemId) = 0; + + virtual HRESULT CALLBACK Invoke( + PVOID pvInstance, + MEMBERID memid, + WORD wFlags, + DISPPARAMS* pDispParams, + VARIANT* pVarResult, + EXCEPINFO* pExcepInfo, + UINT* puArgErr) = 0; + + virtual HRESULT CALLBACK GetDocumentation( + MEMBERID memid, + BSTR* pBstrName, + BSTR* pBstrDocString, + DWORD* pdwHelpContext, + BSTR* pBstrHelpFile) = 0; + + virtual HRESULT CALLBACK GetDllEntry( + MEMBERID memid, + INVOKEKIND invKind, + BSTR* pBstrDllName, + BSTR* pBstrName, + WORD* pwOrdinal) = 0; + + virtual HRESULT CALLBACK GetRefTypeInfo( + HREFTYPE hRefType, + ITypeInfo** ppTInfo) = 0; + + virtual HRESULT CALLBACK AddressOfMember( + MEMBERID memid, + INVOKEKIND invKind, + PVOID* ppv) = 0; + + virtual HRESULT CALLBACK CreateInstance( + IUnknown* pUnkOuter, + REFIID riid, + PVOID* ppvObj) = 0; + + virtual HRESULT CALLBACK GetMops( + MEMBERID memid, + BSTR* pBstrMops) = 0; + + virtual HRESULT CALLBACK GetContainingTypeLib( + ITypeLib** ppTLib, + UINT* pIndex) = 0; + + virtual void CALLBACK ReleaseTypeAttr( + TYPEATTR* pTypeAttr) = 0; + + virtual void CALLBACK ReleaseFuncDesc( + FUNCDESC* pFuncDesc) = 0; + + virtual void CALLBACK ReleaseVarDesc( + VARDESC* pVarDesc) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct ITypeInfoVtbl ITypeInfoVtbl; +struct ITypeInfo { + const ITypeInfoVtbl* lpVtbl; +}; +struct ITypeInfoVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + ITypeInfo* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + ITypeInfo* This); + + ULONG (CALLBACK *Release)( + ITypeInfo* This); + + /*** ITypeInfo methods ***/ + HRESULT (CALLBACK *GetTypeAttr)( + ITypeInfo* This, + TYPEATTR** ppTypeAttr); + + HRESULT (CALLBACK *GetTypeComp)( + ITypeInfo* This, + ITypeComp** ppTComp); + + HRESULT (CALLBACK *GetFuncDesc)( + ITypeInfo* This, + UINT index, + FUNCDESC** ppFuncDesc); + + HRESULT (CALLBACK *GetVarDesc)( + ITypeInfo* This, + UINT index, + VARDESC** ppVarDesc); + + HRESULT (CALLBACK *GetNames)( + ITypeInfo* This, + MEMBERID memid, + BSTR* rgBstrNames, + UINT cMaxNames, + UINT* pcNames); + + HRESULT (CALLBACK *GetRefTypeOfImplType)( + ITypeInfo* This, + UINT index, + HREFTYPE* pRefType); + + HRESULT (CALLBACK *GetImplTypeFlags)( + ITypeInfo* This, + UINT index, + INT* pImplTypeFlags); + + HRESULT (CALLBACK *GetIDsOfNames)( + ITypeInfo* This, + LPOLESTR* rgszNames, + UINT cNames, + MEMBERID* pMemId); + + HRESULT (CALLBACK *Invoke)( + ITypeInfo* This, + PVOID pvInstance, + MEMBERID memid, + WORD wFlags, + DISPPARAMS* pDispParams, + VARIANT* pVarResult, + EXCEPINFO* pExcepInfo, + UINT* puArgErr); + + HRESULT (CALLBACK *GetDocumentation)( + ITypeInfo* This, + MEMBERID memid, + BSTR* pBstrName, + BSTR* pBstrDocString, + DWORD* pdwHelpContext, + BSTR* pBstrHelpFile); + + HRESULT (CALLBACK *GetDllEntry)( + ITypeInfo* This, + MEMBERID memid, + INVOKEKIND invKind, + BSTR* pBstrDllName, + BSTR* pBstrName, + WORD* pwOrdinal); + + HRESULT (CALLBACK *GetRefTypeInfo)( + ITypeInfo* This, + HREFTYPE hRefType, + ITypeInfo** ppTInfo); + + HRESULT (CALLBACK *AddressOfMember)( + ITypeInfo* This, + MEMBERID memid, + INVOKEKIND invKind, + PVOID* ppv); + + HRESULT (CALLBACK *CreateInstance)( + ITypeInfo* This, + IUnknown* pUnkOuter, + REFIID riid, + PVOID* ppvObj); + + HRESULT (CALLBACK *GetMops)( + ITypeInfo* This, + MEMBERID memid, + BSTR* pBstrMops); + + HRESULT (CALLBACK *GetContainingTypeLib)( + ITypeInfo* This, + ITypeLib** ppTLib, + UINT* pIndex); + + void (CALLBACK *ReleaseTypeAttr)( + ITypeInfo* This, + TYPEATTR* pTypeAttr); + + void (CALLBACK *ReleaseFuncDesc)( + ITypeInfo* This, + FUNCDESC* pFuncDesc); + + void (CALLBACK *ReleaseVarDesc)( + ITypeInfo* This, + VARDESC* pVarDesc); + +}; + +#define ITypeInfo_IMETHODS \ + IUnknown_IMETHODS \ + ICOM_METHOD1 (HRESULT,GetTypeAttr,TYPEATTR**,ppTypeAttr) \ + ICOM_METHOD1 (HRESULT,GetTypeComp,ITypeComp**,ppTComp) \ + ICOM_METHOD2 (HRESULT,GetFuncDesc,UINT,index,FUNCDESC**,ppFuncDesc) \ + ICOM_METHOD2 (HRESULT,GetVarDesc,UINT,index,VARDESC**,ppVarDesc) \ + ICOM_METHOD4 (HRESULT,GetNames,MEMBERID,memid,BSTR*,rgBstrNames,UINT,cMaxNames,UINT*,pcNames) \ + ICOM_METHOD2 (HRESULT,GetRefTypeOfImplType,UINT,index,HREFTYPE*,pRefType) \ + ICOM_METHOD2 (HRESULT,GetImplTypeFlags,UINT,index,INT*,pImplTypeFlags) \ + ICOM_METHOD3 (HRESULT,GetIDsOfNames,LPOLESTR*,rgszNames,UINT,cNames,MEMBERID*,pMemId) \ + ICOM_METHOD7 (HRESULT,Invoke,PVOID,pvInstance,MEMBERID,memid,WORD,wFlags,DISPPARAMS*,pDispParams,VARIANT*,pVarResult,EXCEPINFO*,pExcepInfo,UINT*,puArgErr) \ + ICOM_METHOD5 (HRESULT,GetDocumentation,MEMBERID,memid,BSTR*,pBstrName,BSTR*,pBstrDocString,DWORD*,pdwHelpContext,BSTR*,pBstrHelpFile) \ + ICOM_METHOD5 (HRESULT,GetDllEntry,MEMBERID,memid,INVOKEKIND,invKind,BSTR*,pBstrDllName,BSTR*,pBstrName,WORD*,pwOrdinal) \ + ICOM_METHOD2 (HRESULT,GetRefTypeInfo,HREFTYPE,hRefType,ITypeInfo**,ppTInfo) \ + ICOM_METHOD3 (HRESULT,AddressOfMember,MEMBERID,memid,INVOKEKIND,invKind,PVOID*,ppv) \ + ICOM_METHOD3 (HRESULT,CreateInstance,IUnknown*,pUnkOuter,REFIID,riid,PVOID*,ppvObj) \ + ICOM_METHOD2 (HRESULT,GetMops,MEMBERID,memid,BSTR*,pBstrMops) \ + ICOM_METHOD2 (HRESULT,GetContainingTypeLib,ITypeLib**,ppTLib,UINT*,pIndex) \ + ICOM_VMETHOD1(ReleaseTypeAttr,TYPEATTR*,pTypeAttr) \ + ICOM_VMETHOD1(ReleaseFuncDesc,FUNCDESC*,pFuncDesc) \ + ICOM_VMETHOD1(ReleaseVarDesc,VARDESC*,pVarDesc) + +/*** IUnknown methods ***/ +#define ITypeInfo_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define ITypeInfo_AddRef(p) (p)->lpVtbl->AddRef(p) +#define ITypeInfo_Release(p) (p)->lpVtbl->Release(p) +/*** ITypeInfo methods ***/ +#define ITypeInfo_GetTypeAttr(p,a) (p)->lpVtbl->GetTypeAttr(p,a) +#define ITypeInfo_GetTypeComp(p,a) (p)->lpVtbl->GetTypeComp(p,a) +#define ITypeInfo_GetFuncDesc(p,a,b) (p)->lpVtbl->GetFuncDesc(p,a,b) +#define ITypeInfo_GetVarDesc(p,a,b) (p)->lpVtbl->GetVarDesc(p,a,b) +#define ITypeInfo_GetNames(p,a,b,c,d) (p)->lpVtbl->GetNames(p,a,b,c,d) +#define ITypeInfo_GetRefTypeOfImplType(p,a,b) (p)->lpVtbl->GetRefTypeOfImplType(p,a,b) +#define ITypeInfo_GetImplTypeFlags(p,a,b) (p)->lpVtbl->GetImplTypeFlags(p,a,b) +#define ITypeInfo_GetIDsOfNames(p,a,b,c) (p)->lpVtbl->GetIDsOfNames(p,a,b,c) +#define ITypeInfo_Invoke(p,a,b,c,d,e,f,g) (p)->lpVtbl->Invoke(p,a,b,c,d,e,f,g) +#define ITypeInfo_GetDocumentation(p,a,b,c,d,e) (p)->lpVtbl->GetDocumentation(p,a,b,c,d,e) +#define ITypeInfo_GetDllEntry(p,a,b,c,d,e) (p)->lpVtbl->GetDllEntry(p,a,b,c,d,e) +#define ITypeInfo_GetRefTypeInfo(p,a,b) (p)->lpVtbl->GetRefTypeInfo(p,a,b) +#define ITypeInfo_AddressOfMember(p,a,b,c) (p)->lpVtbl->AddressOfMember(p,a,b,c) +#define ITypeInfo_CreateInstance(p,a,b,c) (p)->lpVtbl->CreateInstance(p,a,b,c) +#define ITypeInfo_GetMops(p,a,b) (p)->lpVtbl->GetMops(p,a,b) +#define ITypeInfo_GetContainingTypeLib(p,a,b) (p)->lpVtbl->GetContainingTypeLib(p,a,b) +#define ITypeInfo_ReleaseTypeAttr(p,a) (p)->lpVtbl->ReleaseTypeAttr(p,a) +#define ITypeInfo_ReleaseFuncDesc(p,a) (p)->lpVtbl->ReleaseFuncDesc(p,a) +#define ITypeInfo_ReleaseVarDesc(p,a) (p)->lpVtbl->ReleaseVarDesc(p,a) + +#endif + +HRESULT CALLBACK ITypeInfo_RemoteGetTypeAttr_Proxy( + ITypeInfo* This, + LPTYPEATTR* ppTypeAttr, + CLEANLOCALSTORAGE* pDummy); +void __RPC_STUB ITypeInfo_RemoteGetTypeAttr_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ITypeInfo_GetTypeAttr_Proxy( + ITypeInfo* This, + TYPEATTR** ppTypeAttr); +HRESULT __RPC_STUB ITypeInfo_GetTypeAttr_Stub( + ITypeInfo* This, + LPTYPEATTR* ppTypeAttr, + CLEANLOCALSTORAGE* pDummy); +HRESULT CALLBACK ITypeInfo_GetTypeComp_Proxy( + ITypeInfo* This, + ITypeComp** ppTComp); +void __RPC_STUB ITypeInfo_GetTypeComp_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ITypeInfo_RemoteGetFuncDesc_Proxy( + ITypeInfo* This, + UINT index, + LPFUNCDESC* ppFuncDesc, + CLEANLOCALSTORAGE* pDummy); +void __RPC_STUB ITypeInfo_RemoteGetFuncDesc_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ITypeInfo_GetFuncDesc_Proxy( + ITypeInfo* This, + UINT index, + FUNCDESC** ppFuncDesc); +HRESULT __RPC_STUB ITypeInfo_GetFuncDesc_Stub( + ITypeInfo* This, + UINT index, + LPFUNCDESC* ppFuncDesc, + CLEANLOCALSTORAGE* pDummy); +HRESULT CALLBACK ITypeInfo_RemoteGetVarDesc_Proxy( + ITypeInfo* This, + UINT index, + LPVARDESC* ppVarDesc, + CLEANLOCALSTORAGE* pDummy); +void __RPC_STUB ITypeInfo_RemoteGetVarDesc_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ITypeInfo_GetVarDesc_Proxy( + ITypeInfo* This, + UINT index, + VARDESC** ppVarDesc); +HRESULT __RPC_STUB ITypeInfo_GetVarDesc_Stub( + ITypeInfo* This, + UINT index, + LPVARDESC* ppVarDesc, + CLEANLOCALSTORAGE* pDummy); +HRESULT CALLBACK ITypeInfo_RemoteGetNames_Proxy( + ITypeInfo* This, + MEMBERID memid, + BSTR* rgBstrNames, + UINT cMaxNames, + UINT* pcNames); +void __RPC_STUB ITypeInfo_RemoteGetNames_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ITypeInfo_GetNames_Proxy( + ITypeInfo* This, + MEMBERID memid, + BSTR* rgBstrNames, + UINT cMaxNames, + UINT* pcNames); +HRESULT __RPC_STUB ITypeInfo_GetNames_Stub( + ITypeInfo* This, + MEMBERID memid, + BSTR* rgBstrNames, + UINT cMaxNames, + UINT* pcNames); +HRESULT CALLBACK ITypeInfo_GetRefTypeOfImplType_Proxy( + ITypeInfo* This, + UINT index, + HREFTYPE* pRefType); +void __RPC_STUB ITypeInfo_GetRefTypeOfImplType_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ITypeInfo_GetImplTypeFlags_Proxy( + ITypeInfo* This, + UINT index, + INT* pImplTypeFlags); +void __RPC_STUB ITypeInfo_GetImplTypeFlags_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ITypeInfo_LocalGetIDsOfNames_Proxy( + ITypeInfo* This); +void __RPC_STUB ITypeInfo_LocalGetIDsOfNames_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ITypeInfo_GetIDsOfNames_Proxy( + ITypeInfo* This, + LPOLESTR* rgszNames, + UINT cNames, + MEMBERID* pMemId); +HRESULT __RPC_STUB ITypeInfo_GetIDsOfNames_Stub( + ITypeInfo* This); +HRESULT CALLBACK ITypeInfo_LocalInvoke_Proxy( + ITypeInfo* This); +void __RPC_STUB ITypeInfo_LocalInvoke_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ITypeInfo_Invoke_Proxy( + ITypeInfo* This, + PVOID pvInstance, + MEMBERID memid, + WORD wFlags, + DISPPARAMS* pDispParams, + VARIANT* pVarResult, + EXCEPINFO* pExcepInfo, + UINT* puArgErr); +HRESULT __RPC_STUB ITypeInfo_Invoke_Stub( + ITypeInfo* This); +HRESULT CALLBACK ITypeInfo_RemoteGetDocumentation_Proxy( + ITypeInfo* This, + MEMBERID memid, + DWORD refPtrFlags, + BSTR* pBstrName, + BSTR* pBstrDocString, + DWORD* pdwHelpContext, + BSTR* pBstrHelpFile); +void __RPC_STUB ITypeInfo_RemoteGetDocumentation_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ITypeInfo_GetDocumentation_Proxy( + ITypeInfo* This, + MEMBERID memid, + BSTR* pBstrName, + BSTR* pBstrDocString, + DWORD* pdwHelpContext, + BSTR* pBstrHelpFile); +HRESULT __RPC_STUB ITypeInfo_GetDocumentation_Stub( + ITypeInfo* This, + MEMBERID memid, + DWORD refPtrFlags, + BSTR* pBstrName, + BSTR* pBstrDocString, + DWORD* pdwHelpContext, + BSTR* pBstrHelpFile); +HRESULT CALLBACK ITypeInfo_RemoteGetDllEntry_Proxy( + ITypeInfo* This, + MEMBERID memid, + INVOKEKIND invKind, + DWORD refPtrFlags, + BSTR* pBstrDllName, + BSTR* pBstrName, + WORD* pwOrdinal); +void __RPC_STUB ITypeInfo_RemoteGetDllEntry_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ITypeInfo_GetDllEntry_Proxy( + ITypeInfo* This, + MEMBERID memid, + INVOKEKIND invKind, + BSTR* pBstrDllName, + BSTR* pBstrName, + WORD* pwOrdinal); +HRESULT __RPC_STUB ITypeInfo_GetDllEntry_Stub( + ITypeInfo* This, + MEMBERID memid, + INVOKEKIND invKind, + DWORD refPtrFlags, + BSTR* pBstrDllName, + BSTR* pBstrName, + WORD* pwOrdinal); +HRESULT CALLBACK ITypeInfo_GetRefTypeInfo_Proxy( + ITypeInfo* This, + HREFTYPE hRefType, + ITypeInfo** ppTInfo); +void __RPC_STUB ITypeInfo_GetRefTypeInfo_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ITypeInfo_LocalAddressOfMember_Proxy( + ITypeInfo* This); +void __RPC_STUB ITypeInfo_LocalAddressOfMember_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ITypeInfo_AddressOfMember_Proxy( + ITypeInfo* This, + MEMBERID memid, + INVOKEKIND invKind, + PVOID* ppv); +HRESULT __RPC_STUB ITypeInfo_AddressOfMember_Stub( + ITypeInfo* This); +HRESULT CALLBACK ITypeInfo_RemoteCreateInstance_Proxy( + ITypeInfo* This, + REFIID riid, + IUnknown** ppvObj); +void __RPC_STUB ITypeInfo_RemoteCreateInstance_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ITypeInfo_CreateInstance_Proxy( + ITypeInfo* This, + IUnknown* pUnkOuter, + REFIID riid, + PVOID* ppvObj); +HRESULT __RPC_STUB ITypeInfo_CreateInstance_Stub( + ITypeInfo* This, + REFIID riid, + IUnknown** ppvObj); +HRESULT CALLBACK ITypeInfo_GetMops_Proxy( + ITypeInfo* This, + MEMBERID memid, + BSTR* pBstrMops); +void __RPC_STUB ITypeInfo_GetMops_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ITypeInfo_RemoteGetContainingTypeLib_Proxy( + ITypeInfo* This, + ITypeLib** ppTLib, + UINT* pIndex); +void __RPC_STUB ITypeInfo_RemoteGetContainingTypeLib_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ITypeInfo_GetContainingTypeLib_Proxy( + ITypeInfo* This, + ITypeLib** ppTLib, + UINT* pIndex); +HRESULT __RPC_STUB ITypeInfo_GetContainingTypeLib_Stub( + ITypeInfo* This, + ITypeLib** ppTLib, + UINT* pIndex); +HRESULT CALLBACK ITypeInfo_LocalReleaseTypeAttr_Proxy( + ITypeInfo* This); +void __RPC_STUB ITypeInfo_LocalReleaseTypeAttr_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +void CALLBACK ITypeInfo_ReleaseTypeAttr_Proxy( + ITypeInfo* This, + TYPEATTR* pTypeAttr); +HRESULT __RPC_STUB ITypeInfo_ReleaseTypeAttr_Stub( + ITypeInfo* This); +HRESULT CALLBACK ITypeInfo_LocalReleaseFuncDesc_Proxy( + ITypeInfo* This); +void __RPC_STUB ITypeInfo_LocalReleaseFuncDesc_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +void CALLBACK ITypeInfo_ReleaseFuncDesc_Proxy( + ITypeInfo* This, + FUNCDESC* pFuncDesc); +HRESULT __RPC_STUB ITypeInfo_ReleaseFuncDesc_Stub( + ITypeInfo* This); +HRESULT CALLBACK ITypeInfo_LocalReleaseVarDesc_Proxy( + ITypeInfo* This); +void __RPC_STUB ITypeInfo_LocalReleaseVarDesc_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +void CALLBACK ITypeInfo_ReleaseVarDesc_Proxy( + ITypeInfo* This, + VARDESC* pVarDesc); +HRESULT __RPC_STUB ITypeInfo_ReleaseVarDesc_Stub( + ITypeInfo* This); + +typedef struct ITypeInfo2 ITypeInfo2; +typedef ITypeInfo2 *LPTYPEINFO2; + +/***************************************************************************** + * ITypeInfo2 interface + */ +DEFINE_GUID(IID_ITypeInfo2, 0x00020412, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct ITypeInfo2: ITypeInfo { + + virtual HRESULT CALLBACK GetTypeKind( + TYPEKIND* pTypeKind) = 0; + + virtual HRESULT CALLBACK GetTypeFlags( + ULONG* pTypeFlags) = 0; + + virtual HRESULT CALLBACK GetFuncIndexOfMemId( + MEMBERID memid, + INVOKEKIND invKind, + UINT* pFuncIndex) = 0; + + virtual HRESULT CALLBACK GetVarIndexOfMemId( + MEMBERID memid, + UINT* pVarIndex) = 0; + + virtual HRESULT CALLBACK GetCustData( + REFGUID guid, + VARIANT* pVarVal) = 0; + + virtual HRESULT CALLBACK GetFuncCustData( + UINT index, + REFGUID guid, + VARIANT* pVarVal) = 0; + + virtual HRESULT CALLBACK GetParamCustData( + UINT indexFunc, + UINT indexParam, + REFGUID guid, + VARIANT* pVarVal) = 0; + + virtual HRESULT CALLBACK GetVarCustData( + UINT index, + REFGUID guid, + VARIANT* pVarVal) = 0; + + virtual HRESULT CALLBACK GetImplTypeCustData( + UINT index, + REFGUID guid, + VARIANT* pVarVal) = 0; + + virtual HRESULT CALLBACK GetDocumentation2( + MEMBERID memid, + LCID lcid, + BSTR* pbstrHelpString, + DWORD* pdwHelpStringContext, + BSTR* pbstrHelpStringDll) = 0; + + virtual HRESULT CALLBACK GetAllCustData( + CUSTDATA* pCustData) = 0; + + virtual HRESULT CALLBACK GetAllFuncCustData( + UINT index, + CUSTDATA* pCustData) = 0; + + virtual HRESULT CALLBACK GetAllParamCustData( + UINT indexFunc, + UINT indexParam, + CUSTDATA* pCustData) = 0; + + virtual HRESULT CALLBACK GetAllVarCustData( + UINT index, + CUSTDATA* pCustData) = 0; + + virtual HRESULT CALLBACK GetAllImplTypeCustData( + UINT index, + CUSTDATA* pCustData) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct ITypeInfo2Vtbl ITypeInfo2Vtbl; +struct ITypeInfo2 { + const ITypeInfo2Vtbl* lpVtbl; +}; +struct ITypeInfo2Vtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + ITypeInfo2* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + ITypeInfo2* This); + + ULONG (CALLBACK *Release)( + ITypeInfo2* This); + + /*** ITypeInfo methods ***/ + HRESULT (CALLBACK *GetTypeAttr)( + ITypeInfo2* This, + TYPEATTR** ppTypeAttr); + + HRESULT (CALLBACK *GetTypeComp)( + ITypeInfo2* This, + ITypeComp** ppTComp); + + HRESULT (CALLBACK *GetFuncDesc)( + ITypeInfo2* This, + UINT index, + FUNCDESC** ppFuncDesc); + + HRESULT (CALLBACK *GetVarDesc)( + ITypeInfo2* This, + UINT index, + VARDESC** ppVarDesc); + + HRESULT (CALLBACK *GetNames)( + ITypeInfo2* This, + MEMBERID memid, + BSTR* rgBstrNames, + UINT cMaxNames, + UINT* pcNames); + + HRESULT (CALLBACK *GetRefTypeOfImplType)( + ITypeInfo2* This, + UINT index, + HREFTYPE* pRefType); + + HRESULT (CALLBACK *GetImplTypeFlags)( + ITypeInfo2* This, + UINT index, + INT* pImplTypeFlags); + + HRESULT (CALLBACK *GetIDsOfNames)( + ITypeInfo2* This, + LPOLESTR* rgszNames, + UINT cNames, + MEMBERID* pMemId); + + HRESULT (CALLBACK *Invoke)( + ITypeInfo2* This, + PVOID pvInstance, + MEMBERID memid, + WORD wFlags, + DISPPARAMS* pDispParams, + VARIANT* pVarResult, + EXCEPINFO* pExcepInfo, + UINT* puArgErr); + + HRESULT (CALLBACK *GetDocumentation)( + ITypeInfo2* This, + MEMBERID memid, + BSTR* pBstrName, + BSTR* pBstrDocString, + DWORD* pdwHelpContext, + BSTR* pBstrHelpFile); + + HRESULT (CALLBACK *GetDllEntry)( + ITypeInfo2* This, + MEMBERID memid, + INVOKEKIND invKind, + BSTR* pBstrDllName, + BSTR* pBstrName, + WORD* pwOrdinal); + + HRESULT (CALLBACK *GetRefTypeInfo)( + ITypeInfo2* This, + HREFTYPE hRefType, + ITypeInfo** ppTInfo); + + HRESULT (CALLBACK *AddressOfMember)( + ITypeInfo2* This, + MEMBERID memid, + INVOKEKIND invKind, + PVOID* ppv); + + HRESULT (CALLBACK *CreateInstance)( + ITypeInfo2* This, + IUnknown* pUnkOuter, + REFIID riid, + PVOID* ppvObj); + + HRESULT (CALLBACK *GetMops)( + ITypeInfo2* This, + MEMBERID memid, + BSTR* pBstrMops); + + HRESULT (CALLBACK *GetContainingTypeLib)( + ITypeInfo2* This, + ITypeLib** ppTLib, + UINT* pIndex); + + void (CALLBACK *ReleaseTypeAttr)( + ITypeInfo2* This, + TYPEATTR* pTypeAttr); + + void (CALLBACK *ReleaseFuncDesc)( + ITypeInfo2* This, + FUNCDESC* pFuncDesc); + + void (CALLBACK *ReleaseVarDesc)( + ITypeInfo2* This, + VARDESC* pVarDesc); + + /*** ITypeInfo2 methods ***/ + HRESULT (CALLBACK *GetTypeKind)( + ITypeInfo2* This, + TYPEKIND* pTypeKind); + + HRESULT (CALLBACK *GetTypeFlags)( + ITypeInfo2* This, + ULONG* pTypeFlags); + + HRESULT (CALLBACK *GetFuncIndexOfMemId)( + ITypeInfo2* This, + MEMBERID memid, + INVOKEKIND invKind, + UINT* pFuncIndex); + + HRESULT (CALLBACK *GetVarIndexOfMemId)( + ITypeInfo2* This, + MEMBERID memid, + UINT* pVarIndex); + + HRESULT (CALLBACK *GetCustData)( + ITypeInfo2* This, + REFGUID guid, + VARIANT* pVarVal); + + HRESULT (CALLBACK *GetFuncCustData)( + ITypeInfo2* This, + UINT index, + REFGUID guid, + VARIANT* pVarVal); + + HRESULT (CALLBACK *GetParamCustData)( + ITypeInfo2* This, + UINT indexFunc, + UINT indexParam, + REFGUID guid, + VARIANT* pVarVal); + + HRESULT (CALLBACK *GetVarCustData)( + ITypeInfo2* This, + UINT index, + REFGUID guid, + VARIANT* pVarVal); + + HRESULT (CALLBACK *GetImplTypeCustData)( + ITypeInfo2* This, + UINT index, + REFGUID guid, + VARIANT* pVarVal); + + HRESULT (CALLBACK *GetDocumentation2)( + ITypeInfo2* This, + MEMBERID memid, + LCID lcid, + BSTR* pbstrHelpString, + DWORD* pdwHelpStringContext, + BSTR* pbstrHelpStringDll); + + HRESULT (CALLBACK *GetAllCustData)( + ITypeInfo2* This, + CUSTDATA* pCustData); + + HRESULT (CALLBACK *GetAllFuncCustData)( + ITypeInfo2* This, + UINT index, + CUSTDATA* pCustData); + + HRESULT (CALLBACK *GetAllParamCustData)( + ITypeInfo2* This, + UINT indexFunc, + UINT indexParam, + CUSTDATA* pCustData); + + HRESULT (CALLBACK *GetAllVarCustData)( + ITypeInfo2* This, + UINT index, + CUSTDATA* pCustData); + + HRESULT (CALLBACK *GetAllImplTypeCustData)( + ITypeInfo2* This, + UINT index, + CUSTDATA* pCustData); + +}; + +#define ITypeInfo2_IMETHODS \ + ITypeInfo_IMETHODS \ + ICOM_METHOD1 (HRESULT,GetTypeKind,TYPEKIND*,pTypeKind) \ + ICOM_METHOD1 (HRESULT,GetTypeFlags,ULONG*,pTypeFlags) \ + ICOM_METHOD3 (HRESULT,GetFuncIndexOfMemId,MEMBERID,memid,INVOKEKIND,invKind,UINT*,pFuncIndex) \ + ICOM_METHOD2 (HRESULT,GetVarIndexOfMemId,MEMBERID,memid,UINT*,pVarIndex) \ + ICOM_METHOD2 (HRESULT,GetCustData,REFGUID,guid,VARIANT*,pVarVal) \ + ICOM_METHOD3 (HRESULT,GetFuncCustData,UINT,index,REFGUID,guid,VARIANT*,pVarVal) \ + ICOM_METHOD4 (HRESULT,GetParamCustData,UINT,indexFunc,UINT,indexParam,REFGUID,guid,VARIANT*,pVarVal) \ + ICOM_METHOD3 (HRESULT,GetVarCustData,UINT,index,REFGUID,guid,VARIANT*,pVarVal) \ + ICOM_METHOD3 (HRESULT,GetImplTypeCustData,UINT,index,REFGUID,guid,VARIANT*,pVarVal) \ + ICOM_METHOD5 (HRESULT,GetDocumentation2,MEMBERID,memid,LCID,lcid,BSTR*,pbstrHelpString,DWORD*,pdwHelpStringContext,BSTR*,pbstrHelpStringDll) \ + ICOM_METHOD1 (HRESULT,GetAllCustData,CUSTDATA*,pCustData) \ + ICOM_METHOD2 (HRESULT,GetAllFuncCustData,UINT,index,CUSTDATA*,pCustData) \ + ICOM_METHOD3 (HRESULT,GetAllParamCustData,UINT,indexFunc,UINT,indexParam,CUSTDATA*,pCustData) \ + ICOM_METHOD2 (HRESULT,GetAllVarCustData,UINT,index,CUSTDATA*,pCustData) \ + ICOM_METHOD2 (HRESULT,GetAllImplTypeCustData,UINT,index,CUSTDATA*,pCustData) + +/*** IUnknown methods ***/ +#define ITypeInfo2_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define ITypeInfo2_AddRef(p) (p)->lpVtbl->AddRef(p) +#define ITypeInfo2_Release(p) (p)->lpVtbl->Release(p) +/*** ITypeInfo methods ***/ +#define ITypeInfo2_GetTypeAttr(p,a) (p)->lpVtbl->GetTypeAttr(p,a) +#define ITypeInfo2_GetTypeComp(p,a) (p)->lpVtbl->GetTypeComp(p,a) +#define ITypeInfo2_GetFuncDesc(p,a,b) (p)->lpVtbl->GetFuncDesc(p,a,b) +#define ITypeInfo2_GetVarDesc(p,a,b) (p)->lpVtbl->GetVarDesc(p,a,b) +#define ITypeInfo2_GetNames(p,a,b,c,d) (p)->lpVtbl->GetNames(p,a,b,c,d) +#define ITypeInfo2_GetRefTypeOfImplType(p,a,b) (p)->lpVtbl->GetRefTypeOfImplType(p,a,b) +#define ITypeInfo2_GetImplTypeFlags(p,a,b) (p)->lpVtbl->GetImplTypeFlags(p,a,b) +#define ITypeInfo2_GetIDsOfNames(p,a,b,c) (p)->lpVtbl->GetIDsOfNames(p,a,b,c) +#define ITypeInfo2_Invoke(p,a,b,c,d,e,f,g) (p)->lpVtbl->Invoke(p,a,b,c,d,e,f,g) +#define ITypeInfo2_GetDocumentation(p,a,b,c,d,e) (p)->lpVtbl->GetDocumentation(p,a,b,c,d,e) +#define ITypeInfo2_GetDllEntry(p,a,b,c,d,e) (p)->lpVtbl->GetDllEntry(p,a,b,c,d,e) +#define ITypeInfo2_GetRefTypeInfo(p,a,b) (p)->lpVtbl->GetRefTypeInfo(p,a,b) +#define ITypeInfo2_AddressOfMember(p,a,b,c) (p)->lpVtbl->AddressOfMember(p,a,b,c) +#define ITypeInfo2_CreateInstance(p,a,b,c) (p)->lpVtbl->CreateInstance(p,a,b,c) +#define ITypeInfo2_GetMops(p,a,b) (p)->lpVtbl->GetMops(p,a,b) +#define ITypeInfo2_GetContainingTypeLib(p,a,b) (p)->lpVtbl->GetContainingTypeLib(p,a,b) +#define ITypeInfo2_ReleaseTypeAttr(p,a) (p)->lpVtbl->ReleaseTypeAttr(p,a) +#define ITypeInfo2_ReleaseFuncDesc(p,a) (p)->lpVtbl->ReleaseFuncDesc(p,a) +#define ITypeInfo2_ReleaseVarDesc(p,a) (p)->lpVtbl->ReleaseVarDesc(p,a) +/*** ITypeInfo2 methods ***/ +#define ITypeInfo2_GetTypeKind(p,a) (p)->lpVtbl->GetTypeKind(p,a) +#define ITypeInfo2_GetTypeFlags(p,a) (p)->lpVtbl->GetTypeFlags(p,a) +#define ITypeInfo2_GetFuncIndexOfMemId(p,a,b,c) (p)->lpVtbl->GetFuncIndexOfMemId(p,a,b,c) +#define ITypeInfo2_GetVarIndexOfMemId(p,a,b) (p)->lpVtbl->GetVarIndexOfMemId(p,a,b) +#define ITypeInfo2_GetCustData(p,a,b) (p)->lpVtbl->GetCustData(p,a,b) +#define ITypeInfo2_GetFuncCustData(p,a,b,c) (p)->lpVtbl->GetFuncCustData(p,a,b,c) +#define ITypeInfo2_GetParamCustData(p,a,b,c,d) (p)->lpVtbl->GetParamCustData(p,a,b,c,d) +#define ITypeInfo2_GetVarCustData(p,a,b,c) (p)->lpVtbl->GetVarCustData(p,a,b,c) +#define ITypeInfo2_GetImplTypeCustData(p,a,b,c) (p)->lpVtbl->GetImplTypeCustData(p,a,b,c) +#define ITypeInfo2_GetDocumentation2(p,a,b,c,d,e) (p)->lpVtbl->GetDocumentation2(p,a,b,c,d,e) +#define ITypeInfo2_GetAllCustData(p,a) (p)->lpVtbl->GetAllCustData(p,a) +#define ITypeInfo2_GetAllFuncCustData(p,a,b) (p)->lpVtbl->GetAllFuncCustData(p,a,b) +#define ITypeInfo2_GetAllParamCustData(p,a,b,c) (p)->lpVtbl->GetAllParamCustData(p,a,b,c) +#define ITypeInfo2_GetAllVarCustData(p,a,b) (p)->lpVtbl->GetAllVarCustData(p,a,b) +#define ITypeInfo2_GetAllImplTypeCustData(p,a,b) (p)->lpVtbl->GetAllImplTypeCustData(p,a,b) + +#endif + +HRESULT CALLBACK ITypeInfo2_GetTypeKind_Proxy( + ITypeInfo2* This, + TYPEKIND* pTypeKind); +void __RPC_STUB ITypeInfo2_GetTypeKind_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ITypeInfo2_GetTypeFlags_Proxy( + ITypeInfo2* This, + ULONG* pTypeFlags); +void __RPC_STUB ITypeInfo2_GetTypeFlags_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ITypeInfo2_GetFuncIndexOfMemId_Proxy( + ITypeInfo2* This, + MEMBERID memid, + INVOKEKIND invKind, + UINT* pFuncIndex); +void __RPC_STUB ITypeInfo2_GetFuncIndexOfMemId_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ITypeInfo2_GetVarIndexOfMemId_Proxy( + ITypeInfo2* This, + MEMBERID memid, + UINT* pVarIndex); +void __RPC_STUB ITypeInfo2_GetVarIndexOfMemId_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ITypeInfo2_GetCustData_Proxy( + ITypeInfo2* This, + REFGUID guid, + VARIANT* pVarVal); +void __RPC_STUB ITypeInfo2_GetCustData_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ITypeInfo2_GetFuncCustData_Proxy( + ITypeInfo2* This, + UINT index, + REFGUID guid, + VARIANT* pVarVal); +void __RPC_STUB ITypeInfo2_GetFuncCustData_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ITypeInfo2_GetParamCustData_Proxy( + ITypeInfo2* This, + UINT indexFunc, + UINT indexParam, + REFGUID guid, + VARIANT* pVarVal); +void __RPC_STUB ITypeInfo2_GetParamCustData_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ITypeInfo2_GetVarCustData_Proxy( + ITypeInfo2* This, + UINT index, + REFGUID guid, + VARIANT* pVarVal); +void __RPC_STUB ITypeInfo2_GetVarCustData_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ITypeInfo2_GetImplTypeCustData_Proxy( + ITypeInfo2* This, + UINT index, + REFGUID guid, + VARIANT* pVarVal); +void __RPC_STUB ITypeInfo2_GetImplTypeCustData_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ITypeInfo2_RemoteGetDocumentation2_Proxy( + ITypeInfo2* This, + MEMBERID memid, + LCID lcid, + DWORD refPtrFlags, + BSTR* pbstrHelpString, + DWORD* pdwHelpStringContext, + BSTR* pbstrHelpStringDll); +void __RPC_STUB ITypeInfo2_RemoteGetDocumentation2_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ITypeInfo2_GetDocumentation2_Proxy( + ITypeInfo2* This, + MEMBERID memid, + LCID lcid, + BSTR* pbstrHelpString, + DWORD* pdwHelpStringContext, + BSTR* pbstrHelpStringDll); +HRESULT __RPC_STUB ITypeInfo2_GetDocumentation2_Stub( + ITypeInfo2* This, + MEMBERID memid, + LCID lcid, + DWORD refPtrFlags, + BSTR* pbstrHelpString, + DWORD* pdwHelpStringContext, + BSTR* pbstrHelpStringDll); +HRESULT CALLBACK ITypeInfo2_GetAllCustData_Proxy( + ITypeInfo2* This, + CUSTDATA* pCustData); +void __RPC_STUB ITypeInfo2_GetAllCustData_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ITypeInfo2_GetAllFuncCustData_Proxy( + ITypeInfo2* This, + UINT index, + CUSTDATA* pCustData); +void __RPC_STUB ITypeInfo2_GetAllFuncCustData_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ITypeInfo2_GetAllParamCustData_Proxy( + ITypeInfo2* This, + UINT indexFunc, + UINT indexParam, + CUSTDATA* pCustData); +void __RPC_STUB ITypeInfo2_GetAllParamCustData_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ITypeInfo2_GetAllVarCustData_Proxy( + ITypeInfo2* This, + UINT index, + CUSTDATA* pCustData); +void __RPC_STUB ITypeInfo2_GetAllVarCustData_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ITypeInfo2_GetAllImplTypeCustData_Proxy( + ITypeInfo2* This, + UINT index, + CUSTDATA* pCustData); +void __RPC_STUB ITypeInfo2_GetAllImplTypeCustData_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +typedef ITypeLib *LPTYPELIB; + +typedef enum tagSYSKIND { + SYS_WIN16 = 0, + SYS_WIN32, + SYS_MAC +} SYSKIND; + +typedef enum tagLIBFLAGS { + LIBFLAG_FRESTRICTED = 0x1, + LIBFLAG_FCONTROL = 0x2, + LIBFLAG_FHIDDEN = 0x4, + LIBFLAG_FHASDISKIMAGE = 0x8 +} LIBFLAGS; + +typedef struct tagTLIBATTR { + GUID guid; + LCID lcid; + SYSKIND syskind; + WORD wMajorVerNum; + WORD wMinorVerNum; + WORD wLibFlags; +} TLIBATTR, *LPTLIBATTR; + +/***************************************************************************** + * ITypeLib interface + */ +DEFINE_GUID(IID_ITypeLib, 0x00020402, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct ITypeLib: IUnknown { + + virtual UINT CALLBACK GetTypeInfoCount( + ) = 0; + + virtual HRESULT CALLBACK GetTypeInfo( + UINT index, + ITypeInfo** ppTInfo) = 0; + + virtual HRESULT CALLBACK GetTypeInfoType( + UINT index, + TYPEKIND* pTKind) = 0; + + virtual HRESULT CALLBACK GetTypeInfoOfGuid( + REFGUID guid, + ITypeInfo** ppTinfo) = 0; + + virtual HRESULT CALLBACK GetLibAttr( + TLIBATTR** ppTLibAttr) = 0; + + virtual HRESULT CALLBACK GetTypeComp( + ITypeComp** ppTComp) = 0; + + virtual HRESULT CALLBACK GetDocumentation( + INT index, + BSTR* pBstrName, + BSTR* pBstrDocString, + DWORD* pdwHelpContext, + BSTR* pBstrHelpFile) = 0; + + virtual HRESULT CALLBACK IsName( + LPOLESTR szNameBuf, + ULONG lHashVal, + BOOL* pfName) = 0; + + virtual HRESULT CALLBACK FindName( + LPOLESTR szNameBuf, + ULONG lHashVal, + ITypeInfo** ppTInfo, + MEMBERID* rgMemId, + USHORT* pcFound) = 0; + + virtual void CALLBACK ReleaseTLibAttr( + TLIBATTR* pTLibAttr) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct ITypeLibVtbl ITypeLibVtbl; +struct ITypeLib { + const ITypeLibVtbl* lpVtbl; +}; +struct ITypeLibVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + ITypeLib* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + ITypeLib* This); + + ULONG (CALLBACK *Release)( + ITypeLib* This); + + /*** ITypeLib methods ***/ + UINT (CALLBACK *GetTypeInfoCount)( + ITypeLib* This); + + HRESULT (CALLBACK *GetTypeInfo)( + ITypeLib* This, + UINT index, + ITypeInfo** ppTInfo); + + HRESULT (CALLBACK *GetTypeInfoType)( + ITypeLib* This, + UINT index, + TYPEKIND* pTKind); + + HRESULT (CALLBACK *GetTypeInfoOfGuid)( + ITypeLib* This, + REFGUID guid, + ITypeInfo** ppTinfo); + + HRESULT (CALLBACK *GetLibAttr)( + ITypeLib* This, + TLIBATTR** ppTLibAttr); + + HRESULT (CALLBACK *GetTypeComp)( + ITypeLib* This, + ITypeComp** ppTComp); + + HRESULT (CALLBACK *GetDocumentation)( + ITypeLib* This, + INT index, + BSTR* pBstrName, + BSTR* pBstrDocString, + DWORD* pdwHelpContext, + BSTR* pBstrHelpFile); + + HRESULT (CALLBACK *IsName)( + ITypeLib* This, + LPOLESTR szNameBuf, + ULONG lHashVal, + BOOL* pfName); + + HRESULT (CALLBACK *FindName)( + ITypeLib* This, + LPOLESTR szNameBuf, + ULONG lHashVal, + ITypeInfo** ppTInfo, + MEMBERID* rgMemId, + USHORT* pcFound); + + void (CALLBACK *ReleaseTLibAttr)( + ITypeLib* This, + TLIBATTR* pTLibAttr); + +}; + +#define ITypeLib_IMETHODS \ + IUnknown_IMETHODS \ + ICOM_METHOD (UINT,GetTypeInfoCount) \ + ICOM_METHOD2 (HRESULT,GetTypeInfo,UINT,index,ITypeInfo**,ppTInfo) \ + ICOM_METHOD2 (HRESULT,GetTypeInfoType,UINT,index,TYPEKIND*,pTKind) \ + ICOM_METHOD2 (HRESULT,GetTypeInfoOfGuid,REFGUID,guid,ITypeInfo**,ppTinfo) \ + ICOM_METHOD1 (HRESULT,GetLibAttr,TLIBATTR**,ppTLibAttr) \ + ICOM_METHOD1 (HRESULT,GetTypeComp,ITypeComp**,ppTComp) \ + ICOM_METHOD5 (HRESULT,GetDocumentation,INT,index,BSTR*,pBstrName,BSTR*,pBstrDocString,DWORD*,pdwHelpContext,BSTR*,pBstrHelpFile) \ + ICOM_METHOD3 (HRESULT,IsName,LPOLESTR,szNameBuf,ULONG,lHashVal,BOOL*,pfName) \ + ICOM_METHOD5 (HRESULT,FindName,LPOLESTR,szNameBuf,ULONG,lHashVal,ITypeInfo**,ppTInfo,MEMBERID*,rgMemId,USHORT*,pcFound) \ + ICOM_VMETHOD1(ReleaseTLibAttr,TLIBATTR*,pTLibAttr) + +/*** IUnknown methods ***/ +#define ITypeLib_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define ITypeLib_AddRef(p) (p)->lpVtbl->AddRef(p) +#define ITypeLib_Release(p) (p)->lpVtbl->Release(p) +/*** ITypeLib methods ***/ +#define ITypeLib_GetTypeInfoCount(p) (p)->lpVtbl->GetTypeInfoCount(p) +#define ITypeLib_GetTypeInfo(p,a,b) (p)->lpVtbl->GetTypeInfo(p,a,b) +#define ITypeLib_GetTypeInfoType(p,a,b) (p)->lpVtbl->GetTypeInfoType(p,a,b) +#define ITypeLib_GetTypeInfoOfGuid(p,a,b) (p)->lpVtbl->GetTypeInfoOfGuid(p,a,b) +#define ITypeLib_GetLibAttr(p,a) (p)->lpVtbl->GetLibAttr(p,a) +#define ITypeLib_GetTypeComp(p,a) (p)->lpVtbl->GetTypeComp(p,a) +#define ITypeLib_GetDocumentation(p,a,b,c,d,e) (p)->lpVtbl->GetDocumentation(p,a,b,c,d,e) +#define ITypeLib_IsName(p,a,b,c) (p)->lpVtbl->IsName(p,a,b,c) +#define ITypeLib_FindName(p,a,b,c,d,e) (p)->lpVtbl->FindName(p,a,b,c,d,e) +#define ITypeLib_ReleaseTLibAttr(p,a) (p)->lpVtbl->ReleaseTLibAttr(p,a) + +#endif + +HRESULT CALLBACK ITypeLib_RemoteGetTypeInfoCount_Proxy( + ITypeLib* This, + UINT* pcTInfo); +void __RPC_STUB ITypeLib_RemoteGetTypeInfoCount_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +UINT CALLBACK ITypeLib_GetTypeInfoCount_Proxy( + ITypeLib* This); +HRESULT __RPC_STUB ITypeLib_GetTypeInfoCount_Stub( + ITypeLib* This, + UINT* pcTInfo); +HRESULT CALLBACK ITypeLib_GetTypeInfo_Proxy( + ITypeLib* This, + UINT index, + ITypeInfo** ppTInfo); +void __RPC_STUB ITypeLib_GetTypeInfo_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ITypeLib_GetTypeInfoType_Proxy( + ITypeLib* This, + UINT index, + TYPEKIND* pTKind); +void __RPC_STUB ITypeLib_GetTypeInfoType_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ITypeLib_GetTypeInfoOfGuid_Proxy( + ITypeLib* This, + REFGUID guid, + ITypeInfo** ppTinfo); +void __RPC_STUB ITypeLib_GetTypeInfoOfGuid_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ITypeLib_RemoteGetLibAttr_Proxy( + ITypeLib* This, + LPTLIBATTR* ppTLibAttr, + CLEANLOCALSTORAGE* pDummy); +void __RPC_STUB ITypeLib_RemoteGetLibAttr_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ITypeLib_GetLibAttr_Proxy( + ITypeLib* This, + TLIBATTR** ppTLibAttr); +HRESULT __RPC_STUB ITypeLib_GetLibAttr_Stub( + ITypeLib* This, + LPTLIBATTR* ppTLibAttr, + CLEANLOCALSTORAGE* pDummy); +HRESULT CALLBACK ITypeLib_GetTypeComp_Proxy( + ITypeLib* This, + ITypeComp** ppTComp); +void __RPC_STUB ITypeLib_GetTypeComp_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ITypeLib_RemoteGetDocumentation_Proxy( + ITypeLib* This, + INT index, + DWORD refPtrFlags, + BSTR* pBstrName, + BSTR* pBstrDocString, + DWORD* pdwHelpContext, + BSTR* pBstrHelpFile); +void __RPC_STUB ITypeLib_RemoteGetDocumentation_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ITypeLib_GetDocumentation_Proxy( + ITypeLib* This, + INT index, + BSTR* pBstrName, + BSTR* pBstrDocString, + DWORD* pdwHelpContext, + BSTR* pBstrHelpFile); +HRESULT __RPC_STUB ITypeLib_GetDocumentation_Stub( + ITypeLib* This, + INT index, + DWORD refPtrFlags, + BSTR* pBstrName, + BSTR* pBstrDocString, + DWORD* pdwHelpContext, + BSTR* pBstrHelpFile); +HRESULT CALLBACK ITypeLib_RemoteIsName_Proxy( + ITypeLib* This, + LPOLESTR szNameBuf, + ULONG lHashVal, + BOOL* pfName, + BSTR* pBstrLibName); +void __RPC_STUB ITypeLib_RemoteIsName_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ITypeLib_IsName_Proxy( + ITypeLib* This, + LPOLESTR szNameBuf, + ULONG lHashVal, + BOOL* pfName); +HRESULT __RPC_STUB ITypeLib_IsName_Stub( + ITypeLib* This, + LPOLESTR szNameBuf, + ULONG lHashVal, + BOOL* pfName, + BSTR* pBstrLibName); +HRESULT CALLBACK ITypeLib_RemoteFindName_Proxy( + ITypeLib* This, + LPOLESTR szNameBuf, + ULONG lHashVal, + ITypeInfo** ppTInfo, + MEMBERID* rgMemId, + USHORT* pcFound, + BSTR* pBstrLibName); +void __RPC_STUB ITypeLib_RemoteFindName_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ITypeLib_FindName_Proxy( + ITypeLib* This, + LPOLESTR szNameBuf, + ULONG lHashVal, + ITypeInfo** ppTInfo, + MEMBERID* rgMemId, + USHORT* pcFound); +HRESULT __RPC_STUB ITypeLib_FindName_Stub( + ITypeLib* This, + LPOLESTR szNameBuf, + ULONG lHashVal, + ITypeInfo** ppTInfo, + MEMBERID* rgMemId, + USHORT* pcFound, + BSTR* pBstrLibName); +HRESULT CALLBACK ITypeLib_LocalReleaseTLibAttr_Proxy( + ITypeLib* This); +void __RPC_STUB ITypeLib_LocalReleaseTLibAttr_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +void CALLBACK ITypeLib_ReleaseTLibAttr_Proxy( + ITypeLib* This, + TLIBATTR* pTLibAttr); +HRESULT __RPC_STUB ITypeLib_ReleaseTLibAttr_Stub( + ITypeLib* This); + +typedef struct ITypeLib2 ITypeLib2; +typedef ITypeLib2 *LPTYPELIB2; + +/***************************************************************************** + * ITypeLib2 interface + */ +DEFINE_GUID(IID_ITypeLib2, 0x00020411, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct ITypeLib2: ITypeLib { + + virtual HRESULT CALLBACK GetCustData( + REFGUID guid, + VARIANT* pVarVal) = 0; + + virtual HRESULT CALLBACK GetLibStatistics( + ULONG* pcUniqueNames, + ULONG* pcchUniqueNames) = 0; + + virtual HRESULT CALLBACK GetDocumentation2( + INT index, + LCID lcid, + BSTR* pbstrHelpString, + DWORD* pdwHelpStringContext, + BSTR* pbstrHelpStringDll) = 0; + + virtual HRESULT CALLBACK GetAllCustData( + CUSTDATA* pCustData) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct ITypeLib2Vtbl ITypeLib2Vtbl; +struct ITypeLib2 { + const ITypeLib2Vtbl* lpVtbl; +}; +struct ITypeLib2Vtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + ITypeLib2* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + ITypeLib2* This); + + ULONG (CALLBACK *Release)( + ITypeLib2* This); + + /*** ITypeLib methods ***/ + UINT (CALLBACK *GetTypeInfoCount)( + ITypeLib2* This); + + HRESULT (CALLBACK *GetTypeInfo)( + ITypeLib2* This, + UINT index, + ITypeInfo** ppTInfo); + + HRESULT (CALLBACK *GetTypeInfoType)( + ITypeLib2* This, + UINT index, + TYPEKIND* pTKind); + + HRESULT (CALLBACK *GetTypeInfoOfGuid)( + ITypeLib2* This, + REFGUID guid, + ITypeInfo** ppTinfo); + + HRESULT (CALLBACK *GetLibAttr)( + ITypeLib2* This, + TLIBATTR** ppTLibAttr); + + HRESULT (CALLBACK *GetTypeComp)( + ITypeLib2* This, + ITypeComp** ppTComp); + + HRESULT (CALLBACK *GetDocumentation)( + ITypeLib2* This, + INT index, + BSTR* pBstrName, + BSTR* pBstrDocString, + DWORD* pdwHelpContext, + BSTR* pBstrHelpFile); + + HRESULT (CALLBACK *IsName)( + ITypeLib2* This, + LPOLESTR szNameBuf, + ULONG lHashVal, + BOOL* pfName); + + HRESULT (CALLBACK *FindName)( + ITypeLib2* This, + LPOLESTR szNameBuf, + ULONG lHashVal, + ITypeInfo** ppTInfo, + MEMBERID* rgMemId, + USHORT* pcFound); + + void (CALLBACK *ReleaseTLibAttr)( + ITypeLib2* This, + TLIBATTR* pTLibAttr); + + /*** ITypeLib2 methods ***/ + HRESULT (CALLBACK *GetCustData)( + ITypeLib2* This, + REFGUID guid, + VARIANT* pVarVal); + + HRESULT (CALLBACK *GetLibStatistics)( + ITypeLib2* This, + ULONG* pcUniqueNames, + ULONG* pcchUniqueNames); + + HRESULT (CALLBACK *GetDocumentation2)( + ITypeLib2* This, + INT index, + LCID lcid, + BSTR* pbstrHelpString, + DWORD* pdwHelpStringContext, + BSTR* pbstrHelpStringDll); + + HRESULT (CALLBACK *GetAllCustData)( + ITypeLib2* This, + CUSTDATA* pCustData); + +}; + +#define ITypeLib2_IMETHODS \ + ITypeLib_IMETHODS \ + ICOM_METHOD2 (HRESULT,GetCustData,REFGUID,guid,VARIANT*,pVarVal) \ + ICOM_METHOD2 (HRESULT,GetLibStatistics,ULONG*,pcUniqueNames,ULONG*,pcchUniqueNames) \ + ICOM_METHOD5 (HRESULT,GetDocumentation2,INT,index,LCID,lcid,BSTR*,pbstrHelpString,DWORD*,pdwHelpStringContext,BSTR*,pbstrHelpStringDll) \ + ICOM_METHOD1 (HRESULT,GetAllCustData,CUSTDATA*,pCustData) + +/*** IUnknown methods ***/ +#define ITypeLib2_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define ITypeLib2_AddRef(p) (p)->lpVtbl->AddRef(p) +#define ITypeLib2_Release(p) (p)->lpVtbl->Release(p) +/*** ITypeLib methods ***/ +#define ITypeLib2_GetTypeInfoCount(p) (p)->lpVtbl->GetTypeInfoCount(p) +#define ITypeLib2_GetTypeInfo(p,a,b) (p)->lpVtbl->GetTypeInfo(p,a,b) +#define ITypeLib2_GetTypeInfoType(p,a,b) (p)->lpVtbl->GetTypeInfoType(p,a,b) +#define ITypeLib2_GetTypeInfoOfGuid(p,a,b) (p)->lpVtbl->GetTypeInfoOfGuid(p,a,b) +#define ITypeLib2_GetLibAttr(p,a) (p)->lpVtbl->GetLibAttr(p,a) +#define ITypeLib2_GetTypeComp(p,a) (p)->lpVtbl->GetTypeComp(p,a) +#define ITypeLib2_GetDocumentation(p,a,b,c,d,e) (p)->lpVtbl->GetDocumentation(p,a,b,c,d,e) +#define ITypeLib2_IsName(p,a,b,c) (p)->lpVtbl->IsName(p,a,b,c) +#define ITypeLib2_FindName(p,a,b,c,d,e) (p)->lpVtbl->FindName(p,a,b,c,d,e) +#define ITypeLib2_ReleaseTLibAttr(p,a) (p)->lpVtbl->ReleaseTLibAttr(p,a) +/*** ITypeLib2 methods ***/ +#define ITypeLib2_GetCustData(p,a,b) (p)->lpVtbl->GetCustData(p,a,b) +#define ITypeLib2_GetLibStatistics(p,a,b) (p)->lpVtbl->GetLibStatistics(p,a,b) +#define ITypeLib2_GetDocumentation2(p,a,b,c,d,e) (p)->lpVtbl->GetDocumentation2(p,a,b,c,d,e) +#define ITypeLib2_GetAllCustData(p,a) (p)->lpVtbl->GetAllCustData(p,a) + +#endif + +HRESULT CALLBACK ITypeLib2_GetCustData_Proxy( + ITypeLib2* This, + REFGUID guid, + VARIANT* pVarVal); +void __RPC_STUB ITypeLib2_GetCustData_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ITypeLib2_RemoteGetLibStatistics_Proxy( + ITypeLib2* This, + ULONG* pcUniqueNames, + ULONG* pcchUniqueNames); +void __RPC_STUB ITypeLib2_RemoteGetLibStatistics_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ITypeLib2_GetLibStatistics_Proxy( + ITypeLib2* This, + ULONG* pcUniqueNames, + ULONG* pcchUniqueNames); +HRESULT __RPC_STUB ITypeLib2_GetLibStatistics_Stub( + ITypeLib2* This, + ULONG* pcUniqueNames, + ULONG* pcchUniqueNames); +HRESULT CALLBACK ITypeLib2_RemoteGetDocumentation2_Proxy( + ITypeLib2* This, + INT index, + LCID lcid, + DWORD refPtrFlags, + BSTR* pbstrHelpString, + DWORD* pdwHelpStringContext, + BSTR* pbstrHelpStringDll); +void __RPC_STUB ITypeLib2_RemoteGetDocumentation2_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ITypeLib2_GetDocumentation2_Proxy( + ITypeLib2* This, + INT index, + LCID lcid, + BSTR* pbstrHelpString, + DWORD* pdwHelpStringContext, + BSTR* pbstrHelpStringDll); +HRESULT __RPC_STUB ITypeLib2_GetDocumentation2_Stub( + ITypeLib2* This, + INT index, + LCID lcid, + DWORD refPtrFlags, + BSTR* pbstrHelpString, + DWORD* pdwHelpStringContext, + BSTR* pbstrHelpStringDll); +HRESULT CALLBACK ITypeLib2_GetAllCustData_Proxy( + ITypeLib2* This, + CUSTDATA* pCustData); +void __RPC_STUB ITypeLib2_GetAllCustData_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +typedef struct ITypeChangeEvents ITypeChangeEvents; +typedef ITypeChangeEvents *LPTYPECHANGEEVENTS; + +typedef enum tagCHANGEKIND { + CHANGEKIND_ADDMEMBER, + CHANGEKIND_DELETEMEMBER, + CHANGEKIND_SETNAMES, + CHANGEKIND_SETDOCUMENTATION, + CHANGEKIND_GENERAL, + CHANGEKIND_INVALIDATE, + CHANGEKIND_CHANGEFAILED, + CHANGEKIND_MAX +} CHANGEKIND; + +/***************************************************************************** + * ITypeChangeEvents interface + */ +DEFINE_GUID(IID_ITypeChangeEvents, 0x00020410, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct ITypeChangeEvents: IUnknown { + + virtual HRESULT CALLBACK RequestTypeChange( + CHANGEKIND changeKind, + ITypeInfo* pTInfoBefore, + LPOLESTR pStrName, + INT* pfCancel) = 0; + + virtual HRESULT CALLBACK AfterTypeChange( + CHANGEKIND changeKind, + ITypeInfo* pTInfoAfter, + LPOLESTR pStrName) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct ITypeChangeEventsVtbl ITypeChangeEventsVtbl; +struct ITypeChangeEvents { + const ITypeChangeEventsVtbl* lpVtbl; +}; +struct ITypeChangeEventsVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + ITypeChangeEvents* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + ITypeChangeEvents* This); + + ULONG (CALLBACK *Release)( + ITypeChangeEvents* This); + + /*** ITypeChangeEvents methods ***/ + HRESULT (CALLBACK *RequestTypeChange)( + ITypeChangeEvents* This, + CHANGEKIND changeKind, + ITypeInfo* pTInfoBefore, + LPOLESTR pStrName, + INT* pfCancel); + + HRESULT (CALLBACK *AfterTypeChange)( + ITypeChangeEvents* This, + CHANGEKIND changeKind, + ITypeInfo* pTInfoAfter, + LPOLESTR pStrName); + +}; + +#define ITypeChangeEvents_IMETHODS \ + IUnknown_IMETHODS \ + ICOM_METHOD4 (HRESULT,RequestTypeChange,CHANGEKIND,changeKind,ITypeInfo*,pTInfoBefore,LPOLESTR,pStrName,INT*,pfCancel) \ + ICOM_METHOD3 (HRESULT,AfterTypeChange,CHANGEKIND,changeKind,ITypeInfo*,pTInfoAfter,LPOLESTR,pStrName) + +/*** IUnknown methods ***/ +#define ITypeChangeEvents_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define ITypeChangeEvents_AddRef(p) (p)->lpVtbl->AddRef(p) +#define ITypeChangeEvents_Release(p) (p)->lpVtbl->Release(p) +/*** ITypeChangeEvents methods ***/ +#define ITypeChangeEvents_RequestTypeChange(p,a,b,c,d) (p)->lpVtbl->RequestTypeChange(p,a,b,c,d) +#define ITypeChangeEvents_AfterTypeChange(p,a,b,c) (p)->lpVtbl->AfterTypeChange(p,a,b,c) + +#endif + +HRESULT CALLBACK ITypeChangeEvents_RequestTypeChange_Proxy( + ITypeChangeEvents* This, + CHANGEKIND changeKind, + ITypeInfo* pTInfoBefore, + LPOLESTR pStrName, + INT* pfCancel); +void __RPC_STUB ITypeChangeEvents_RequestTypeChange_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ITypeChangeEvents_AfterTypeChange_Proxy( + ITypeChangeEvents* This, + CHANGEKIND changeKind, + ITypeInfo* pTInfoAfter, + LPOLESTR pStrName); +void __RPC_STUB ITypeChangeEvents_AfterTypeChange_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +typedef struct IErrorInfo IErrorInfo; +typedef IErrorInfo *LPERRORINFO; + +/***************************************************************************** + * IErrorInfo interface + */ +DEFINE_GUID(IID_IErrorInfo, 0x1cf2b120, 0x547d, 0x101b, 0x8e,0x65, 0x08,0x00,0x2b,0x2b,0xd1,0x19); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IErrorInfo: IUnknown { + + virtual HRESULT CALLBACK GetGUID( + GUID* pGUID) = 0; + + virtual HRESULT CALLBACK GetSource( + BSTR* pBstrSource) = 0; + + virtual HRESULT CALLBACK GetDescription( + BSTR* pBstrDescription) = 0; + + virtual HRESULT CALLBACK GetHelpFile( + BSTR* pBstrHelpFile) = 0; + + virtual HRESULT CALLBACK GetHelpContext( + DWORD* pdwHelpContext) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct IErrorInfoVtbl IErrorInfoVtbl; +struct IErrorInfo { + const IErrorInfoVtbl* lpVtbl; +}; +struct IErrorInfoVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + IErrorInfo* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + IErrorInfo* This); + + ULONG (CALLBACK *Release)( + IErrorInfo* This); + + /*** IErrorInfo methods ***/ + HRESULT (CALLBACK *GetGUID)( + IErrorInfo* This, + GUID* pGUID); + + HRESULT (CALLBACK *GetSource)( + IErrorInfo* This, + BSTR* pBstrSource); + + HRESULT (CALLBACK *GetDescription)( + IErrorInfo* This, + BSTR* pBstrDescription); + + HRESULT (CALLBACK *GetHelpFile)( + IErrorInfo* This, + BSTR* pBstrHelpFile); + + HRESULT (CALLBACK *GetHelpContext)( + IErrorInfo* This, + DWORD* pdwHelpContext); + +}; + +#define IErrorInfo_IMETHODS \ + IUnknown_IMETHODS \ + ICOM_METHOD1 (HRESULT,GetGUID,GUID*,pGUID) \ + ICOM_METHOD1 (HRESULT,GetSource,BSTR*,pBstrSource) \ + ICOM_METHOD1 (HRESULT,GetDescription,BSTR*,pBstrDescription) \ + ICOM_METHOD1 (HRESULT,GetHelpFile,BSTR*,pBstrHelpFile) \ + ICOM_METHOD1 (HRESULT,GetHelpContext,DWORD*,pdwHelpContext) + +/*** IUnknown methods ***/ +#define IErrorInfo_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IErrorInfo_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IErrorInfo_Release(p) (p)->lpVtbl->Release(p) +/*** IErrorInfo methods ***/ +#define IErrorInfo_GetGUID(p,a) (p)->lpVtbl->GetGUID(p,a) +#define IErrorInfo_GetSource(p,a) (p)->lpVtbl->GetSource(p,a) +#define IErrorInfo_GetDescription(p,a) (p)->lpVtbl->GetDescription(p,a) +#define IErrorInfo_GetHelpFile(p,a) (p)->lpVtbl->GetHelpFile(p,a) +#define IErrorInfo_GetHelpContext(p,a) (p)->lpVtbl->GetHelpContext(p,a) + +#endif + +HRESULT CALLBACK IErrorInfo_GetGUID_Proxy( + IErrorInfo* This, + GUID* pGUID); +void __RPC_STUB IErrorInfo_GetGUID_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IErrorInfo_GetSource_Proxy( + IErrorInfo* This, + BSTR* pBstrSource); +void __RPC_STUB IErrorInfo_GetSource_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IErrorInfo_GetDescription_Proxy( + IErrorInfo* This, + BSTR* pBstrDescription); +void __RPC_STUB IErrorInfo_GetDescription_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IErrorInfo_GetHelpFile_Proxy( + IErrorInfo* This, + BSTR* pBstrHelpFile); +void __RPC_STUB IErrorInfo_GetHelpFile_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IErrorInfo_GetHelpContext_Proxy( + IErrorInfo* This, + DWORD* pdwHelpContext); +void __RPC_STUB IErrorInfo_GetHelpContext_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +typedef struct ICreateErrorInfo ICreateErrorInfo; +typedef ICreateErrorInfo *LPCREATEERRORINFO; + +/***************************************************************************** + * ICreateErrorInfo interface + */ +DEFINE_GUID(IID_ICreateErrorInfo, 0x22f03340, 0x547d, 0x101b, 0x8e,0x65, 0x08,0x00,0x2b,0x2b,0xd1,0x19); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct ICreateErrorInfo: IUnknown { + + virtual HRESULT CALLBACK SetGUID( + REFGUID rguid) = 0; + + virtual HRESULT CALLBACK SetSource( + LPOLESTR szSource) = 0; + + virtual HRESULT CALLBACK SetDescription( + LPOLESTR szDescription) = 0; + + virtual HRESULT CALLBACK SetHelpFile( + LPOLESTR szHelpFile) = 0; + + virtual HRESULT CALLBACK SetHelpContext( + DWORD dwHelpContext) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct ICreateErrorInfoVtbl ICreateErrorInfoVtbl; +struct ICreateErrorInfo { + const ICreateErrorInfoVtbl* lpVtbl; +}; +struct ICreateErrorInfoVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + ICreateErrorInfo* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + ICreateErrorInfo* This); + + ULONG (CALLBACK *Release)( + ICreateErrorInfo* This); + + /*** ICreateErrorInfo methods ***/ + HRESULT (CALLBACK *SetGUID)( + ICreateErrorInfo* This, + REFGUID rguid); + + HRESULT (CALLBACK *SetSource)( + ICreateErrorInfo* This, + LPOLESTR szSource); + + HRESULT (CALLBACK *SetDescription)( + ICreateErrorInfo* This, + LPOLESTR szDescription); + + HRESULT (CALLBACK *SetHelpFile)( + ICreateErrorInfo* This, + LPOLESTR szHelpFile); + + HRESULT (CALLBACK *SetHelpContext)( + ICreateErrorInfo* This, + DWORD dwHelpContext); + +}; + +#define ICreateErrorInfo_IMETHODS \ + IUnknown_IMETHODS \ + ICOM_METHOD1 (HRESULT,SetGUID,REFGUID,rguid) \ + ICOM_METHOD1 (HRESULT,SetSource,LPOLESTR,szSource) \ + ICOM_METHOD1 (HRESULT,SetDescription,LPOLESTR,szDescription) \ + ICOM_METHOD1 (HRESULT,SetHelpFile,LPOLESTR,szHelpFile) \ + ICOM_METHOD1 (HRESULT,SetHelpContext,DWORD,dwHelpContext) + +/*** IUnknown methods ***/ +#define ICreateErrorInfo_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define ICreateErrorInfo_AddRef(p) (p)->lpVtbl->AddRef(p) +#define ICreateErrorInfo_Release(p) (p)->lpVtbl->Release(p) +/*** ICreateErrorInfo methods ***/ +#define ICreateErrorInfo_SetGUID(p,a) (p)->lpVtbl->SetGUID(p,a) +#define ICreateErrorInfo_SetSource(p,a) (p)->lpVtbl->SetSource(p,a) +#define ICreateErrorInfo_SetDescription(p,a) (p)->lpVtbl->SetDescription(p,a) +#define ICreateErrorInfo_SetHelpFile(p,a) (p)->lpVtbl->SetHelpFile(p,a) +#define ICreateErrorInfo_SetHelpContext(p,a) (p)->lpVtbl->SetHelpContext(p,a) + +#endif + +HRESULT CALLBACK ICreateErrorInfo_SetGUID_Proxy( + ICreateErrorInfo* This, + REFGUID rguid); +void __RPC_STUB ICreateErrorInfo_SetGUID_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ICreateErrorInfo_SetSource_Proxy( + ICreateErrorInfo* This, + LPOLESTR szSource); +void __RPC_STUB ICreateErrorInfo_SetSource_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ICreateErrorInfo_SetDescription_Proxy( + ICreateErrorInfo* This, + LPOLESTR szDescription); +void __RPC_STUB ICreateErrorInfo_SetDescription_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ICreateErrorInfo_SetHelpFile_Proxy( + ICreateErrorInfo* This, + LPOLESTR szHelpFile); +void __RPC_STUB ICreateErrorInfo_SetHelpFile_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ICreateErrorInfo_SetHelpContext_Proxy( + ICreateErrorInfo* This, + DWORD dwHelpContext); +void __RPC_STUB ICreateErrorInfo_SetHelpContext_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +typedef struct ISupportErrorInfo ISupportErrorInfo; +typedef ISupportErrorInfo *LPSUPPORTERRORINFO; + +/***************************************************************************** + * ISupportErrorInfo interface + */ +DEFINE_GUID(IID_ISupportErrorInfo, 0xdf0b3d60, 0x548f, 0x101b, 0x8e,0x65, 0x08,0x00,0x2b,0x2b,0xd1,0x19); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct ISupportErrorInfo: IUnknown { + + virtual HRESULT CALLBACK InterfaceSupportsErrorInfo( + REFIID riid) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct ISupportErrorInfoVtbl ISupportErrorInfoVtbl; +struct ISupportErrorInfo { + const ISupportErrorInfoVtbl* lpVtbl; +}; +struct ISupportErrorInfoVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + ISupportErrorInfo* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + ISupportErrorInfo* This); + + ULONG (CALLBACK *Release)( + ISupportErrorInfo* This); + + /*** ISupportErrorInfo methods ***/ + HRESULT (CALLBACK *InterfaceSupportsErrorInfo)( + ISupportErrorInfo* This, + REFIID riid); + +}; + +#define ISupportErrorInfo_IMETHODS \ + IUnknown_IMETHODS \ + ICOM_METHOD1 (HRESULT,InterfaceSupportsErrorInfo,REFIID,riid) + +/*** IUnknown methods ***/ +#define ISupportErrorInfo_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define ISupportErrorInfo_AddRef(p) (p)->lpVtbl->AddRef(p) +#define ISupportErrorInfo_Release(p) (p)->lpVtbl->Release(p) +/*** ISupportErrorInfo methods ***/ +#define ISupportErrorInfo_InterfaceSupportsErrorInfo(p,a) (p)->lpVtbl->InterfaceSupportsErrorInfo(p,a) + +#endif + +HRESULT CALLBACK ISupportErrorInfo_InterfaceSupportsErrorInfo_Proxy( + ISupportErrorInfo* This, + REFIID riid); +void __RPC_STUB ISupportErrorInfo_InterfaceSupportsErrorInfo_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +typedef struct ITypeFactory ITypeFactory; +/***************************************************************************** + * ITypeFactory interface + */ +DEFINE_GUID(IID_ITypeFactory, 0x0000002e, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct ITypeFactory: IUnknown { + + virtual HRESULT CALLBACK CreateFromTypeInfo( + ITypeInfo* pTypeInfo, + REFIID riid, + IUnknown** ppv) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct ITypeFactoryVtbl ITypeFactoryVtbl; +struct ITypeFactory { + const ITypeFactoryVtbl* lpVtbl; +}; +struct ITypeFactoryVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + ITypeFactory* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + ITypeFactory* This); + + ULONG (CALLBACK *Release)( + ITypeFactory* This); + + /*** ITypeFactory methods ***/ + HRESULT (CALLBACK *CreateFromTypeInfo)( + ITypeFactory* This, + ITypeInfo* pTypeInfo, + REFIID riid, + IUnknown** ppv); + +}; + +#define ITypeFactory_IMETHODS \ + IUnknown_IMETHODS \ + ICOM_METHOD3 (HRESULT,CreateFromTypeInfo,ITypeInfo*,pTypeInfo,REFIID,riid,IUnknown**,ppv) + +/*** IUnknown methods ***/ +#define ITypeFactory_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define ITypeFactory_AddRef(p) (p)->lpVtbl->AddRef(p) +#define ITypeFactory_Release(p) (p)->lpVtbl->Release(p) +/*** ITypeFactory methods ***/ +#define ITypeFactory_CreateFromTypeInfo(p,a,b,c) (p)->lpVtbl->CreateFromTypeInfo(p,a,b,c) + +#endif + +HRESULT CALLBACK ITypeFactory_CreateFromTypeInfo_Proxy( + ITypeFactory* This, + ITypeInfo* pTypeInfo, + REFIID riid, + IUnknown** ppv); +void __RPC_STUB ITypeFactory_CreateFromTypeInfo_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +typedef struct ITypeMarshal ITypeMarshal; +/***************************************************************************** + * ITypeMarshal interface + */ +DEFINE_GUID(IID_ITypeMarshal, 0x0000002d, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct ITypeMarshal: IUnknown { + + virtual HRESULT CALLBACK Size( + PVOID pvType, + DWORD dwDestContext, + PVOID pvDestContext, + ULONG* pSize) = 0; + + virtual HRESULT CALLBACK Marshal( + PVOID pvType, + DWORD dwDestContext, + PVOID pvDestContext, + ULONG cbBufferLength, + BYTE* pBuffer, + ULONG* pcbWritten) = 0; + + virtual HRESULT CALLBACK Unmarshal( + PVOID pvType, + DWORD dwFlags, + ULONG cbBufferLength, + BYTE* pBuffer, + ULONG* pcbRead) = 0; + + virtual HRESULT CALLBACK Free( + PVOID pvType) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct ITypeMarshalVtbl ITypeMarshalVtbl; +struct ITypeMarshal { + const ITypeMarshalVtbl* lpVtbl; +}; +struct ITypeMarshalVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + ITypeMarshal* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + ITypeMarshal* This); + + ULONG (CALLBACK *Release)( + ITypeMarshal* This); + + /*** ITypeMarshal methods ***/ + HRESULT (CALLBACK *Size)( + ITypeMarshal* This, + PVOID pvType, + DWORD dwDestContext, + PVOID pvDestContext, + ULONG* pSize); + + HRESULT (CALLBACK *Marshal)( + ITypeMarshal* This, + PVOID pvType, + DWORD dwDestContext, + PVOID pvDestContext, + ULONG cbBufferLength, + BYTE* pBuffer, + ULONG* pcbWritten); + + HRESULT (CALLBACK *Unmarshal)( + ITypeMarshal* This, + PVOID pvType, + DWORD dwFlags, + ULONG cbBufferLength, + BYTE* pBuffer, + ULONG* pcbRead); + + HRESULT (CALLBACK *Free)( + ITypeMarshal* This, + PVOID pvType); + +}; + +#define ITypeMarshal_IMETHODS \ + IUnknown_IMETHODS \ + ICOM_METHOD4 (HRESULT,Size,PVOID,pvType,DWORD,dwDestContext,PVOID,pvDestContext,ULONG*,pSize) \ + ICOM_METHOD6 (HRESULT,Marshal,PVOID,pvType,DWORD,dwDestContext,PVOID,pvDestContext,ULONG,cbBufferLength,BYTE*,pBuffer,ULONG*,pcbWritten) \ + ICOM_METHOD5 (HRESULT,Unmarshal,PVOID,pvType,DWORD,dwFlags,ULONG,cbBufferLength,BYTE*,pBuffer,ULONG*,pcbRead) \ + ICOM_METHOD1 (HRESULT,Free,PVOID,pvType) + +/*** IUnknown methods ***/ +#define ITypeMarshal_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define ITypeMarshal_AddRef(p) (p)->lpVtbl->AddRef(p) +#define ITypeMarshal_Release(p) (p)->lpVtbl->Release(p) +/*** ITypeMarshal methods ***/ +#define ITypeMarshal_Size(p,a,b,c,d) (p)->lpVtbl->Size(p,a,b,c,d) +#define ITypeMarshal_Marshal(p,a,b,c,d,e,f) (p)->lpVtbl->Marshal(p,a,b,c,d,e,f) +#define ITypeMarshal_Unmarshal(p,a,b,c,d,e) (p)->lpVtbl->Unmarshal(p,a,b,c,d,e) +#define ITypeMarshal_Free(p,a) (p)->lpVtbl->Free(p,a) + +#endif + +HRESULT CALLBACK ITypeMarshal_Size_Proxy( + ITypeMarshal* This, + PVOID pvType, + DWORD dwDestContext, + PVOID pvDestContext, + ULONG* pSize); +void __RPC_STUB ITypeMarshal_Size_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ITypeMarshal_Marshal_Proxy( + ITypeMarshal* This, + PVOID pvType, + DWORD dwDestContext, + PVOID pvDestContext, + ULONG cbBufferLength, + BYTE* pBuffer, + ULONG* pcbWritten); +void __RPC_STUB ITypeMarshal_Marshal_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ITypeMarshal_Unmarshal_Proxy( + ITypeMarshal* This, + PVOID pvType, + DWORD dwFlags, + ULONG cbBufferLength, + BYTE* pBuffer, + ULONG* pcbRead); +void __RPC_STUB ITypeMarshal_Unmarshal_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ITypeMarshal_Free_Proxy( + ITypeMarshal* This, + PVOID pvType); +void __RPC_STUB ITypeMarshal_Free_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +typedef IRecordInfo *LPRECORDINFO; + +/***************************************************************************** + * IRecordInfo interface + */ +DEFINE_GUID(IID_IRecordInfo, 0x0000002f, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IRecordInfo: IUnknown { + + virtual HRESULT CALLBACK RecordInit( + PVOID pvNew) = 0; + + virtual HRESULT CALLBACK RecordClear( + PVOID pvExisting) = 0; + + virtual HRESULT CALLBACK RecordCopy( + PVOID pvExisting, + PVOID pvNew) = 0; + + virtual HRESULT CALLBACK GetGuid( + GUID* pguid) = 0; + + virtual HRESULT CALLBACK GetName( + BSTR* pbstrName) = 0; + + virtual HRESULT CALLBACK GetSize( + ULONG* pcbSize) = 0; + + virtual HRESULT CALLBACK GetTypeInfo( + ITypeInfo** ppTypeInfo) = 0; + + virtual HRESULT CALLBACK GetField( + PVOID pvData, + LPCOLESTR szFieldName, + VARIANT* pvarField) = 0; + + virtual HRESULT CALLBACK GetFieldNoCopy( + PVOID pvData, + LPCOLESTR szFieldName, + VARIANT* pvarField, + PVOID* ppvDataCArray) = 0; + + virtual HRESULT CALLBACK PutField( + ULONG wFlags, + PVOID pvData, + LPCOLESTR szFieldName, + VARIANT* pvarField) = 0; + + virtual HRESULT CALLBACK PutFieldNoCopy( + ULONG wFlags, + PVOID pvData, + LPCOLESTR szFieldName, + VARIANT* pvarField) = 0; + + virtual HRESULT CALLBACK GetFieldNames( + ULONG* pcNames, + BSTR* rgBstrNames) = 0; + + virtual BOOL CALLBACK IsMatchingType( + IRecordInfo* pRecordInfo) = 0; + + virtual PVOID CALLBACK RecordCreate( + ) = 0; + + virtual HRESULT CALLBACK RecordCreateCopy( + PVOID pvSource, + PVOID* ppvDest) = 0; + + virtual HRESULT CALLBACK RecordDestroy( + PVOID pvRecord) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct IRecordInfoVtbl IRecordInfoVtbl; +struct IRecordInfo { + const IRecordInfoVtbl* lpVtbl; +}; +struct IRecordInfoVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + IRecordInfo* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + IRecordInfo* This); + + ULONG (CALLBACK *Release)( + IRecordInfo* This); + + /*** IRecordInfo methods ***/ + HRESULT (CALLBACK *RecordInit)( + IRecordInfo* This, + PVOID pvNew); + + HRESULT (CALLBACK *RecordClear)( + IRecordInfo* This, + PVOID pvExisting); + + HRESULT (CALLBACK *RecordCopy)( + IRecordInfo* This, + PVOID pvExisting, + PVOID pvNew); + + HRESULT (CALLBACK *GetGuid)( + IRecordInfo* This, + GUID* pguid); + + HRESULT (CALLBACK *GetName)( + IRecordInfo* This, + BSTR* pbstrName); + + HRESULT (CALLBACK *GetSize)( + IRecordInfo* This, + ULONG* pcbSize); + + HRESULT (CALLBACK *GetTypeInfo)( + IRecordInfo* This, + ITypeInfo** ppTypeInfo); + + HRESULT (CALLBACK *GetField)( + IRecordInfo* This, + PVOID pvData, + LPCOLESTR szFieldName, + VARIANT* pvarField); + + HRESULT (CALLBACK *GetFieldNoCopy)( + IRecordInfo* This, + PVOID pvData, + LPCOLESTR szFieldName, + VARIANT* pvarField, + PVOID* ppvDataCArray); + + HRESULT (CALLBACK *PutField)( + IRecordInfo* This, + ULONG wFlags, + PVOID pvData, + LPCOLESTR szFieldName, + VARIANT* pvarField); + + HRESULT (CALLBACK *PutFieldNoCopy)( + IRecordInfo* This, + ULONG wFlags, + PVOID pvData, + LPCOLESTR szFieldName, + VARIANT* pvarField); + + HRESULT (CALLBACK *GetFieldNames)( + IRecordInfo* This, + ULONG* pcNames, + BSTR* rgBstrNames); + + BOOL (CALLBACK *IsMatchingType)( + IRecordInfo* This, + IRecordInfo* pRecordInfo); + + PVOID (CALLBACK *RecordCreate)( + IRecordInfo* This); + + HRESULT (CALLBACK *RecordCreateCopy)( + IRecordInfo* This, + PVOID pvSource, + PVOID* ppvDest); + + HRESULT (CALLBACK *RecordDestroy)( + IRecordInfo* This, + PVOID pvRecord); + +}; + +#define IRecordInfo_IMETHODS \ + IUnknown_IMETHODS \ + ICOM_METHOD1 (HRESULT,RecordInit,PVOID,pvNew) \ + ICOM_METHOD1 (HRESULT,RecordClear,PVOID,pvExisting) \ + ICOM_METHOD2 (HRESULT,RecordCopy,PVOID,pvExisting,PVOID,pvNew) \ + ICOM_METHOD1 (HRESULT,GetGuid,GUID*,pguid) \ + ICOM_METHOD1 (HRESULT,GetName,BSTR*,pbstrName) \ + ICOM_METHOD1 (HRESULT,GetSize,ULONG*,pcbSize) \ + ICOM_METHOD1 (HRESULT,GetTypeInfo,ITypeInfo**,ppTypeInfo) \ + ICOM_METHOD3 (HRESULT,GetField,PVOID,pvData,LPCOLESTR,szFieldName,VARIANT*,pvarField) \ + ICOM_METHOD4 (HRESULT,GetFieldNoCopy,PVOID,pvData,LPCOLESTR,szFieldName,VARIANT*,pvarField,PVOID*,ppvDataCArray) \ + ICOM_METHOD4 (HRESULT,PutField,ULONG,wFlags,PVOID,pvData,LPCOLESTR,szFieldName,VARIANT*,pvarField) \ + ICOM_METHOD4 (HRESULT,PutFieldNoCopy,ULONG,wFlags,PVOID,pvData,LPCOLESTR,szFieldName,VARIANT*,pvarField) \ + ICOM_METHOD2 (HRESULT,GetFieldNames,ULONG*,pcNames,BSTR*,rgBstrNames) \ + ICOM_METHOD1 (BOOL,IsMatchingType,IRecordInfo*,pRecordInfo) \ + ICOM_METHOD (PVOID,RecordCreate) \ + ICOM_METHOD2 (HRESULT,RecordCreateCopy,PVOID,pvSource,PVOID*,ppvDest) \ + ICOM_METHOD1 (HRESULT,RecordDestroy,PVOID,pvRecord) + +/*** IUnknown methods ***/ +#define IRecordInfo_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IRecordInfo_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IRecordInfo_Release(p) (p)->lpVtbl->Release(p) +/*** IRecordInfo methods ***/ +#define IRecordInfo_RecordInit(p,a) (p)->lpVtbl->RecordInit(p,a) +#define IRecordInfo_RecordClear(p,a) (p)->lpVtbl->RecordClear(p,a) +#define IRecordInfo_RecordCopy(p,a,b) (p)->lpVtbl->RecordCopy(p,a,b) +#define IRecordInfo_GetGuid(p,a) (p)->lpVtbl->GetGuid(p,a) +#define IRecordInfo_GetName(p,a) (p)->lpVtbl->GetName(p,a) +#define IRecordInfo_GetSize(p,a) (p)->lpVtbl->GetSize(p,a) +#define IRecordInfo_GetTypeInfo(p,a) (p)->lpVtbl->GetTypeInfo(p,a) +#define IRecordInfo_GetField(p,a,b,c) (p)->lpVtbl->GetField(p,a,b,c) +#define IRecordInfo_GetFieldNoCopy(p,a,b,c,d) (p)->lpVtbl->GetFieldNoCopy(p,a,b,c,d) +#define IRecordInfo_PutField(p,a,b,c,d) (p)->lpVtbl->PutField(p,a,b,c,d) +#define IRecordInfo_PutFieldNoCopy(p,a,b,c,d) (p)->lpVtbl->PutFieldNoCopy(p,a,b,c,d) +#define IRecordInfo_GetFieldNames(p,a,b) (p)->lpVtbl->GetFieldNames(p,a,b) +#define IRecordInfo_IsMatchingType(p,a) (p)->lpVtbl->IsMatchingType(p,a) +#define IRecordInfo_RecordCreate(p) (p)->lpVtbl->RecordCreate(p) +#define IRecordInfo_RecordCreateCopy(p,a,b) (p)->lpVtbl->RecordCreateCopy(p,a,b) +#define IRecordInfo_RecordDestroy(p,a) (p)->lpVtbl->RecordDestroy(p,a) + +#endif + +HRESULT CALLBACK IRecordInfo_RecordInit_Proxy( + IRecordInfo* This, + PVOID pvNew); +void __RPC_STUB IRecordInfo_RecordInit_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IRecordInfo_RecordClear_Proxy( + IRecordInfo* This, + PVOID pvExisting); +void __RPC_STUB IRecordInfo_RecordClear_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IRecordInfo_RecordCopy_Proxy( + IRecordInfo* This, + PVOID pvExisting, + PVOID pvNew); +void __RPC_STUB IRecordInfo_RecordCopy_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IRecordInfo_GetGuid_Proxy( + IRecordInfo* This, + GUID* pguid); +void __RPC_STUB IRecordInfo_GetGuid_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IRecordInfo_GetName_Proxy( + IRecordInfo* This, + BSTR* pbstrName); +void __RPC_STUB IRecordInfo_GetName_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IRecordInfo_GetSize_Proxy( + IRecordInfo* This, + ULONG* pcbSize); +void __RPC_STUB IRecordInfo_GetSize_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IRecordInfo_GetTypeInfo_Proxy( + IRecordInfo* This, + ITypeInfo** ppTypeInfo); +void __RPC_STUB IRecordInfo_GetTypeInfo_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IRecordInfo_GetField_Proxy( + IRecordInfo* This, + PVOID pvData, + LPCOLESTR szFieldName, + VARIANT* pvarField); +void __RPC_STUB IRecordInfo_GetField_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IRecordInfo_GetFieldNoCopy_Proxy( + IRecordInfo* This, + PVOID pvData, + LPCOLESTR szFieldName, + VARIANT* pvarField, + PVOID* ppvDataCArray); +void __RPC_STUB IRecordInfo_GetFieldNoCopy_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IRecordInfo_PutField_Proxy( + IRecordInfo* This, + ULONG wFlags, + PVOID pvData, + LPCOLESTR szFieldName, + VARIANT* pvarField); +void __RPC_STUB IRecordInfo_PutField_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IRecordInfo_PutFieldNoCopy_Proxy( + IRecordInfo* This, + ULONG wFlags, + PVOID pvData, + LPCOLESTR szFieldName, + VARIANT* pvarField); +void __RPC_STUB IRecordInfo_PutFieldNoCopy_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IRecordInfo_GetFieldNames_Proxy( + IRecordInfo* This, + ULONG* pcNames, + BSTR* rgBstrNames); +void __RPC_STUB IRecordInfo_GetFieldNames_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +BOOL CALLBACK IRecordInfo_IsMatchingType_Proxy( + IRecordInfo* This, + IRecordInfo* pRecordInfo); +void __RPC_STUB IRecordInfo_IsMatchingType_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +PVOID CALLBACK IRecordInfo_RecordCreate_Proxy( + IRecordInfo* This); +void __RPC_STUB IRecordInfo_RecordCreate_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IRecordInfo_RecordCreateCopy_Proxy( + IRecordInfo* This, + PVOID pvSource, + PVOID* ppvDest); +void __RPC_STUB IRecordInfo_RecordCreateCopy_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IRecordInfo_RecordDestroy_Proxy( + IRecordInfo* This, + PVOID pvRecord); +void __RPC_STUB IRecordInfo_RecordDestroy_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +typedef struct ICreateTypeInfo ICreateTypeInfo; +typedef ICreateTypeInfo *LPCREATETYPEINFO; + +/***************************************************************************** + * ICreateTypeInfo interface + */ +DEFINE_GUID(IID_ICreateTypeInfo, 0x00020405, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct ICreateTypeInfo: IUnknown { + + virtual HRESULT CALLBACK SetGuid( + REFGUID guid) = 0; + + virtual HRESULT CALLBACK SetTypeFlags( + UINT uTypeFlags) = 0; + + virtual HRESULT CALLBACK SetDocString( + LPOLESTR pStrDoc) = 0; + + virtual HRESULT CALLBACK SetHelpContext( + DWORD dwHelpContext) = 0; + + virtual HRESULT CALLBACK SetVersion( + WORD wMajorVerNum, + WORD wMinorVerNum) = 0; + + virtual HRESULT CALLBACK AddRefTypeInfo( + ITypeInfo* pTInfo, + HREFTYPE* phRefType) = 0; + + virtual HRESULT CALLBACK AddFuncDesc( + UINT index, + FUNCDESC* pFuncDesc) = 0; + + virtual HRESULT CALLBACK AddImplType( + UINT index, + HREFTYPE hRefType) = 0; + + virtual HRESULT CALLBACK SetImplTypeFlags( + UINT index, + INT implTypeFlags) = 0; + + virtual HRESULT CALLBACK SetAlignment( + WORD cbAlignment) = 0; + + virtual HRESULT CALLBACK SetSchema( + LPOLESTR pStrSchema) = 0; + + virtual HRESULT CALLBACK AddVarDesc( + UINT index, + VARDESC* pVarDesc) = 0; + + virtual HRESULT CALLBACK SetFuncAndParamNames( + UINT index, + LPOLESTR* rgszNames, + UINT cNames) = 0; + + virtual HRESULT CALLBACK SetVarName( + UINT index, + LPOLESTR szName) = 0; + + virtual HRESULT CALLBACK SetTypeDescAlias( + TYPEDESC* pTDescAlias) = 0; + + virtual HRESULT CALLBACK DefineFuncAsDllEntry( + UINT index, + LPOLESTR szDllName, + LPOLESTR szProcName) = 0; + + virtual HRESULT CALLBACK SetFuncDocString( + UINT index, + LPOLESTR szDocString) = 0; + + virtual HRESULT CALLBACK SetVarDocString( + UINT index, + LPOLESTR szDocString) = 0; + + virtual HRESULT CALLBACK SetFuncHelpContext( + UINT index, + DWORD dwHelpContext) = 0; + + virtual HRESULT CALLBACK SetVarHelpContext( + UINT index, + DWORD dwHelpContext) = 0; + + virtual HRESULT CALLBACK SetMops( + UINT index, + BSTR bstrMops) = 0; + + virtual HRESULT CALLBACK SetTypeIdldesc( + IDLDESC* pIdlDesc) = 0; + + virtual HRESULT CALLBACK LayOut( + ) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct ICreateTypeInfoVtbl ICreateTypeInfoVtbl; +struct ICreateTypeInfo { + const ICreateTypeInfoVtbl* lpVtbl; +}; +struct ICreateTypeInfoVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + ICreateTypeInfo* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + ICreateTypeInfo* This); + + ULONG (CALLBACK *Release)( + ICreateTypeInfo* This); + + /*** ICreateTypeInfo methods ***/ + HRESULT (CALLBACK *SetGuid)( + ICreateTypeInfo* This, + REFGUID guid); + + HRESULT (CALLBACK *SetTypeFlags)( + ICreateTypeInfo* This, + UINT uTypeFlags); + + HRESULT (CALLBACK *SetDocString)( + ICreateTypeInfo* This, + LPOLESTR pStrDoc); + + HRESULT (CALLBACK *SetHelpContext)( + ICreateTypeInfo* This, + DWORD dwHelpContext); + + HRESULT (CALLBACK *SetVersion)( + ICreateTypeInfo* This, + WORD wMajorVerNum, + WORD wMinorVerNum); + + HRESULT (CALLBACK *AddRefTypeInfo)( + ICreateTypeInfo* This, + ITypeInfo* pTInfo, + HREFTYPE* phRefType); + + HRESULT (CALLBACK *AddFuncDesc)( + ICreateTypeInfo* This, + UINT index, + FUNCDESC* pFuncDesc); + + HRESULT (CALLBACK *AddImplType)( + ICreateTypeInfo* This, + UINT index, + HREFTYPE hRefType); + + HRESULT (CALLBACK *SetImplTypeFlags)( + ICreateTypeInfo* This, + UINT index, + INT implTypeFlags); + + HRESULT (CALLBACK *SetAlignment)( + ICreateTypeInfo* This, + WORD cbAlignment); + + HRESULT (CALLBACK *SetSchema)( + ICreateTypeInfo* This, + LPOLESTR pStrSchema); + + HRESULT (CALLBACK *AddVarDesc)( + ICreateTypeInfo* This, + UINT index, + VARDESC* pVarDesc); + + HRESULT (CALLBACK *SetFuncAndParamNames)( + ICreateTypeInfo* This, + UINT index, + LPOLESTR* rgszNames, + UINT cNames); + + HRESULT (CALLBACK *SetVarName)( + ICreateTypeInfo* This, + UINT index, + LPOLESTR szName); + + HRESULT (CALLBACK *SetTypeDescAlias)( + ICreateTypeInfo* This, + TYPEDESC* pTDescAlias); + + HRESULT (CALLBACK *DefineFuncAsDllEntry)( + ICreateTypeInfo* This, + UINT index, + LPOLESTR szDllName, + LPOLESTR szProcName); + + HRESULT (CALLBACK *SetFuncDocString)( + ICreateTypeInfo* This, + UINT index, + LPOLESTR szDocString); + + HRESULT (CALLBACK *SetVarDocString)( + ICreateTypeInfo* This, + UINT index, + LPOLESTR szDocString); + + HRESULT (CALLBACK *SetFuncHelpContext)( + ICreateTypeInfo* This, + UINT index, + DWORD dwHelpContext); + + HRESULT (CALLBACK *SetVarHelpContext)( + ICreateTypeInfo* This, + UINT index, + DWORD dwHelpContext); + + HRESULT (CALLBACK *SetMops)( + ICreateTypeInfo* This, + UINT index, + BSTR bstrMops); + + HRESULT (CALLBACK *SetTypeIdldesc)( + ICreateTypeInfo* This, + IDLDESC* pIdlDesc); + + HRESULT (CALLBACK *LayOut)( + ICreateTypeInfo* This); + +}; + +#define ICreateTypeInfo_IMETHODS \ + IUnknown_IMETHODS \ + ICOM_METHOD1 (HRESULT,SetGuid,REFGUID,guid) \ + ICOM_METHOD1 (HRESULT,SetTypeFlags,UINT,uTypeFlags) \ + ICOM_METHOD1 (HRESULT,SetDocString,LPOLESTR,pStrDoc) \ + ICOM_METHOD1 (HRESULT,SetHelpContext,DWORD,dwHelpContext) \ + ICOM_METHOD2 (HRESULT,SetVersion,WORD,wMajorVerNum,WORD,wMinorVerNum) \ + ICOM_METHOD2 (HRESULT,AddRefTypeInfo,ITypeInfo*,pTInfo,HREFTYPE*,phRefType) \ + ICOM_METHOD2 (HRESULT,AddFuncDesc,UINT,index,FUNCDESC*,pFuncDesc) \ + ICOM_METHOD2 (HRESULT,AddImplType,UINT,index,HREFTYPE,hRefType) \ + ICOM_METHOD2 (HRESULT,SetImplTypeFlags,UINT,index,INT,implTypeFlags) \ + ICOM_METHOD1 (HRESULT,SetAlignment,WORD,cbAlignment) \ + ICOM_METHOD1 (HRESULT,SetSchema,LPOLESTR,pStrSchema) \ + ICOM_METHOD2 (HRESULT,AddVarDesc,UINT,index,VARDESC*,pVarDesc) \ + ICOM_METHOD3 (HRESULT,SetFuncAndParamNames,UINT,index,LPOLESTR*,rgszNames,UINT,cNames) \ + ICOM_METHOD2 (HRESULT,SetVarName,UINT,index,LPOLESTR,szName) \ + ICOM_METHOD1 (HRESULT,SetTypeDescAlias,TYPEDESC*,pTDescAlias) \ + ICOM_METHOD3 (HRESULT,DefineFuncAsDllEntry,UINT,index,LPOLESTR,szDllName,LPOLESTR,szProcName) \ + ICOM_METHOD2 (HRESULT,SetFuncDocString,UINT,index,LPOLESTR,szDocString) \ + ICOM_METHOD2 (HRESULT,SetVarDocString,UINT,index,LPOLESTR,szDocString) \ + ICOM_METHOD2 (HRESULT,SetFuncHelpContext,UINT,index,DWORD,dwHelpContext) \ + ICOM_METHOD2 (HRESULT,SetVarHelpContext,UINT,index,DWORD,dwHelpContext) \ + ICOM_METHOD2 (HRESULT,SetMops,UINT,index,BSTR,bstrMops) \ + ICOM_METHOD1 (HRESULT,SetTypeIdldesc,IDLDESC*,pIdlDesc) \ + ICOM_METHOD (HRESULT,LayOut) + +/*** IUnknown methods ***/ +#define ICreateTypeInfo_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define ICreateTypeInfo_AddRef(p) (p)->lpVtbl->AddRef(p) +#define ICreateTypeInfo_Release(p) (p)->lpVtbl->Release(p) +/*** ICreateTypeInfo methods ***/ +#define ICreateTypeInfo_SetGuid(p,a) (p)->lpVtbl->SetGuid(p,a) +#define ICreateTypeInfo_SetTypeFlags(p,a) (p)->lpVtbl->SetTypeFlags(p,a) +#define ICreateTypeInfo_SetDocString(p,a) (p)->lpVtbl->SetDocString(p,a) +#define ICreateTypeInfo_SetHelpContext(p,a) (p)->lpVtbl->SetHelpContext(p,a) +#define ICreateTypeInfo_SetVersion(p,a,b) (p)->lpVtbl->SetVersion(p,a,b) +#define ICreateTypeInfo_AddRefTypeInfo(p,a,b) (p)->lpVtbl->AddRefTypeInfo(p,a,b) +#define ICreateTypeInfo_AddFuncDesc(p,a,b) (p)->lpVtbl->AddFuncDesc(p,a,b) +#define ICreateTypeInfo_AddImplType(p,a,b) (p)->lpVtbl->AddImplType(p,a,b) +#define ICreateTypeInfo_SetImplTypeFlags(p,a,b) (p)->lpVtbl->SetImplTypeFlags(p,a,b) +#define ICreateTypeInfo_SetAlignment(p,a) (p)->lpVtbl->SetAlignment(p,a) +#define ICreateTypeInfo_SetSchema(p,a) (p)->lpVtbl->SetSchema(p,a) +#define ICreateTypeInfo_AddVarDesc(p,a,b) (p)->lpVtbl->AddVarDesc(p,a,b) +#define ICreateTypeInfo_SetFuncAndParamNames(p,a,b,c) (p)->lpVtbl->SetFuncAndParamNames(p,a,b,c) +#define ICreateTypeInfo_SetVarName(p,a,b) (p)->lpVtbl->SetVarName(p,a,b) +#define ICreateTypeInfo_SetTypeDescAlias(p,a) (p)->lpVtbl->SetTypeDescAlias(p,a) +#define ICreateTypeInfo_DefineFuncAsDllEntry(p,a,b,c) (p)->lpVtbl->DefineFuncAsDllEntry(p,a,b,c) +#define ICreateTypeInfo_SetFuncDocString(p,a,b) (p)->lpVtbl->SetFuncDocString(p,a,b) +#define ICreateTypeInfo_SetVarDocString(p,a,b) (p)->lpVtbl->SetVarDocString(p,a,b) +#define ICreateTypeInfo_SetFuncHelpContext(p,a,b) (p)->lpVtbl->SetFuncHelpContext(p,a,b) +#define ICreateTypeInfo_SetVarHelpContext(p,a,b) (p)->lpVtbl->SetVarHelpContext(p,a,b) +#define ICreateTypeInfo_SetMops(p,a,b) (p)->lpVtbl->SetMops(p,a,b) +#define ICreateTypeInfo_SetTypeIdldesc(p,a) (p)->lpVtbl->SetTypeIdldesc(p,a) +#define ICreateTypeInfo_LayOut(p) (p)->lpVtbl->LayOut(p) + +#endif + +HRESULT CALLBACK ICreateTypeInfo_SetGuid_Proxy( + ICreateTypeInfo* This, + REFGUID guid); +void __RPC_STUB ICreateTypeInfo_SetGuid_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ICreateTypeInfo_SetTypeFlags_Proxy( + ICreateTypeInfo* This, + UINT uTypeFlags); +void __RPC_STUB ICreateTypeInfo_SetTypeFlags_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ICreateTypeInfo_SetDocString_Proxy( + ICreateTypeInfo* This, + LPOLESTR pStrDoc); +void __RPC_STUB ICreateTypeInfo_SetDocString_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ICreateTypeInfo_SetHelpContext_Proxy( + ICreateTypeInfo* This, + DWORD dwHelpContext); +void __RPC_STUB ICreateTypeInfo_SetHelpContext_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ICreateTypeInfo_SetVersion_Proxy( + ICreateTypeInfo* This, + WORD wMajorVerNum, + WORD wMinorVerNum); +void __RPC_STUB ICreateTypeInfo_SetVersion_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ICreateTypeInfo_AddRefTypeInfo_Proxy( + ICreateTypeInfo* This, + ITypeInfo* pTInfo, + HREFTYPE* phRefType); +void __RPC_STUB ICreateTypeInfo_AddRefTypeInfo_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ICreateTypeInfo_AddFuncDesc_Proxy( + ICreateTypeInfo* This, + UINT index, + FUNCDESC* pFuncDesc); +void __RPC_STUB ICreateTypeInfo_AddFuncDesc_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ICreateTypeInfo_AddImplType_Proxy( + ICreateTypeInfo* This, + UINT index, + HREFTYPE hRefType); +void __RPC_STUB ICreateTypeInfo_AddImplType_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ICreateTypeInfo_SetImplTypeFlags_Proxy( + ICreateTypeInfo* This, + UINT index, + INT implTypeFlags); +void __RPC_STUB ICreateTypeInfo_SetImplTypeFlags_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ICreateTypeInfo_SetAlignment_Proxy( + ICreateTypeInfo* This, + WORD cbAlignment); +void __RPC_STUB ICreateTypeInfo_SetAlignment_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ICreateTypeInfo_SetSchema_Proxy( + ICreateTypeInfo* This, + LPOLESTR pStrSchema); +void __RPC_STUB ICreateTypeInfo_SetSchema_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ICreateTypeInfo_AddVarDesc_Proxy( + ICreateTypeInfo* This, + UINT index, + VARDESC* pVarDesc); +void __RPC_STUB ICreateTypeInfo_AddVarDesc_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ICreateTypeInfo_SetFuncAndParamNames_Proxy( + ICreateTypeInfo* This, + UINT index, + LPOLESTR* rgszNames, + UINT cNames); +void __RPC_STUB ICreateTypeInfo_SetFuncAndParamNames_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ICreateTypeInfo_SetVarName_Proxy( + ICreateTypeInfo* This, + UINT index, + LPOLESTR szName); +void __RPC_STUB ICreateTypeInfo_SetVarName_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ICreateTypeInfo_SetTypeDescAlias_Proxy( + ICreateTypeInfo* This, + TYPEDESC* pTDescAlias); +void __RPC_STUB ICreateTypeInfo_SetTypeDescAlias_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ICreateTypeInfo_DefineFuncAsDllEntry_Proxy( + ICreateTypeInfo* This, + UINT index, + LPOLESTR szDllName, + LPOLESTR szProcName); +void __RPC_STUB ICreateTypeInfo_DefineFuncAsDllEntry_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ICreateTypeInfo_SetFuncDocString_Proxy( + ICreateTypeInfo* This, + UINT index, + LPOLESTR szDocString); +void __RPC_STUB ICreateTypeInfo_SetFuncDocString_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ICreateTypeInfo_SetVarDocString_Proxy( + ICreateTypeInfo* This, + UINT index, + LPOLESTR szDocString); +void __RPC_STUB ICreateTypeInfo_SetVarDocString_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ICreateTypeInfo_SetFuncHelpContext_Proxy( + ICreateTypeInfo* This, + UINT index, + DWORD dwHelpContext); +void __RPC_STUB ICreateTypeInfo_SetFuncHelpContext_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ICreateTypeInfo_SetVarHelpContext_Proxy( + ICreateTypeInfo* This, + UINT index, + DWORD dwHelpContext); +void __RPC_STUB ICreateTypeInfo_SetVarHelpContext_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ICreateTypeInfo_SetMops_Proxy( + ICreateTypeInfo* This, + UINT index, + BSTR bstrMops); +void __RPC_STUB ICreateTypeInfo_SetMops_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ICreateTypeInfo_SetTypeIdldesc_Proxy( + ICreateTypeInfo* This, + IDLDESC* pIdlDesc); +void __RPC_STUB ICreateTypeInfo_SetTypeIdldesc_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ICreateTypeInfo_LayOut_Proxy( + ICreateTypeInfo* This); +void __RPC_STUB ICreateTypeInfo_LayOut_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +typedef struct ICreateTypeInfo2 ICreateTypeInfo2; +typedef ICreateTypeInfo2 *LPCREATETYPEINFO2; + +/***************************************************************************** + * ICreateTypeInfo2 interface + */ +DEFINE_GUID(IID_ICreateTypeInfo2, 0x0002040e, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct ICreateTypeInfo2: ICreateTypeInfo { + + virtual HRESULT CALLBACK DeleteFuncDesc( + UINT index) = 0; + + virtual HRESULT CALLBACK DeleteFuncDescByMemId( + MEMBERID memid, + INVOKEKIND invKind) = 0; + + virtual HRESULT CALLBACK DeleteVarDesc( + UINT index) = 0; + + virtual HRESULT CALLBACK DeleteVarDescByMemId( + MEMBERID memid) = 0; + + virtual HRESULT CALLBACK DeleteImplType( + UINT index) = 0; + + virtual HRESULT CALLBACK SetCustData( + REFGUID guid, + VARIANT* pVarVal) = 0; + + virtual HRESULT CALLBACK SetFuncCustData( + UINT index, + REFGUID guid, + VARIANT* pVarVal) = 0; + + virtual HRESULT CALLBACK SetParamCustData( + UINT indexFunc, + UINT indexParam, + REFGUID guid, + VARIANT* pVarVal) = 0; + + virtual HRESULT CALLBACK SetVarCustData( + UINT index, + REFGUID guid, + VARIANT* pVarVal) = 0; + + virtual HRESULT CALLBACK SetImplTypeCustData( + UINT index, + REFGUID guid, + VARIANT* pVarVal) = 0; + + virtual HRESULT CALLBACK SetHelpStringContext( + ULONG dwHelpStringContext) = 0; + + virtual HRESULT CALLBACK SetFuncHelpStringContext( + UINT index, + ULONG dwHelpStringContext) = 0; + + virtual HRESULT CALLBACK SetVarHelpStringContext( + UINT index, + ULONG dwHelpStringContext) = 0; + + virtual HRESULT CALLBACK Invalidate( + ) = 0; + + virtual HRESULT CALLBACK SetName( + LPOLESTR szName) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct ICreateTypeInfo2Vtbl ICreateTypeInfo2Vtbl; +struct ICreateTypeInfo2 { + const ICreateTypeInfo2Vtbl* lpVtbl; +}; +struct ICreateTypeInfo2Vtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + ICreateTypeInfo2* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + ICreateTypeInfo2* This); + + ULONG (CALLBACK *Release)( + ICreateTypeInfo2* This); + + /*** ICreateTypeInfo methods ***/ + HRESULT (CALLBACK *SetGuid)( + ICreateTypeInfo2* This, + REFGUID guid); + + HRESULT (CALLBACK *SetTypeFlags)( + ICreateTypeInfo2* This, + UINT uTypeFlags); + + HRESULT (CALLBACK *SetDocString)( + ICreateTypeInfo2* This, + LPOLESTR pStrDoc); + + HRESULT (CALLBACK *SetHelpContext)( + ICreateTypeInfo2* This, + DWORD dwHelpContext); + + HRESULT (CALLBACK *SetVersion)( + ICreateTypeInfo2* This, + WORD wMajorVerNum, + WORD wMinorVerNum); + + HRESULT (CALLBACK *AddRefTypeInfo)( + ICreateTypeInfo2* This, + ITypeInfo* pTInfo, + HREFTYPE* phRefType); + + HRESULT (CALLBACK *AddFuncDesc)( + ICreateTypeInfo2* This, + UINT index, + FUNCDESC* pFuncDesc); + + HRESULT (CALLBACK *AddImplType)( + ICreateTypeInfo2* This, + UINT index, + HREFTYPE hRefType); + + HRESULT (CALLBACK *SetImplTypeFlags)( + ICreateTypeInfo2* This, + UINT index, + INT implTypeFlags); + + HRESULT (CALLBACK *SetAlignment)( + ICreateTypeInfo2* This, + WORD cbAlignment); + + HRESULT (CALLBACK *SetSchema)( + ICreateTypeInfo2* This, + LPOLESTR pStrSchema); + + HRESULT (CALLBACK *AddVarDesc)( + ICreateTypeInfo2* This, + UINT index, + VARDESC* pVarDesc); + + HRESULT (CALLBACK *SetFuncAndParamNames)( + ICreateTypeInfo2* This, + UINT index, + LPOLESTR* rgszNames, + UINT cNames); + + HRESULT (CALLBACK *SetVarName)( + ICreateTypeInfo2* This, + UINT index, + LPOLESTR szName); + + HRESULT (CALLBACK *SetTypeDescAlias)( + ICreateTypeInfo2* This, + TYPEDESC* pTDescAlias); + + HRESULT (CALLBACK *DefineFuncAsDllEntry)( + ICreateTypeInfo2* This, + UINT index, + LPOLESTR szDllName, + LPOLESTR szProcName); + + HRESULT (CALLBACK *SetFuncDocString)( + ICreateTypeInfo2* This, + UINT index, + LPOLESTR szDocString); + + HRESULT (CALLBACK *SetVarDocString)( + ICreateTypeInfo2* This, + UINT index, + LPOLESTR szDocString); + + HRESULT (CALLBACK *SetFuncHelpContext)( + ICreateTypeInfo2* This, + UINT index, + DWORD dwHelpContext); + + HRESULT (CALLBACK *SetVarHelpContext)( + ICreateTypeInfo2* This, + UINT index, + DWORD dwHelpContext); + + HRESULT (CALLBACK *SetMops)( + ICreateTypeInfo2* This, + UINT index, + BSTR bstrMops); + + HRESULT (CALLBACK *SetTypeIdldesc)( + ICreateTypeInfo2* This, + IDLDESC* pIdlDesc); + + HRESULT (CALLBACK *LayOut)( + ICreateTypeInfo2* This); + + /*** ICreateTypeInfo2 methods ***/ + HRESULT (CALLBACK *DeleteFuncDesc)( + ICreateTypeInfo2* This, + UINT index); + + HRESULT (CALLBACK *DeleteFuncDescByMemId)( + ICreateTypeInfo2* This, + MEMBERID memid, + INVOKEKIND invKind); + + HRESULT (CALLBACK *DeleteVarDesc)( + ICreateTypeInfo2* This, + UINT index); + + HRESULT (CALLBACK *DeleteVarDescByMemId)( + ICreateTypeInfo2* This, + MEMBERID memid); + + HRESULT (CALLBACK *DeleteImplType)( + ICreateTypeInfo2* This, + UINT index); + + HRESULT (CALLBACK *SetCustData)( + ICreateTypeInfo2* This, + REFGUID guid, + VARIANT* pVarVal); + + HRESULT (CALLBACK *SetFuncCustData)( + ICreateTypeInfo2* This, + UINT index, + REFGUID guid, + VARIANT* pVarVal); + + HRESULT (CALLBACK *SetParamCustData)( + ICreateTypeInfo2* This, + UINT indexFunc, + UINT indexParam, + REFGUID guid, + VARIANT* pVarVal); + + HRESULT (CALLBACK *SetVarCustData)( + ICreateTypeInfo2* This, + UINT index, + REFGUID guid, + VARIANT* pVarVal); + + HRESULT (CALLBACK *SetImplTypeCustData)( + ICreateTypeInfo2* This, + UINT index, + REFGUID guid, + VARIANT* pVarVal); + + HRESULT (CALLBACK *SetHelpStringContext)( + ICreateTypeInfo2* This, + ULONG dwHelpStringContext); + + HRESULT (CALLBACK *SetFuncHelpStringContext)( + ICreateTypeInfo2* This, + UINT index, + ULONG dwHelpStringContext); + + HRESULT (CALLBACK *SetVarHelpStringContext)( + ICreateTypeInfo2* This, + UINT index, + ULONG dwHelpStringContext); + + HRESULT (CALLBACK *Invalidate)( + ICreateTypeInfo2* This); + + HRESULT (CALLBACK *SetName)( + ICreateTypeInfo2* This, + LPOLESTR szName); + +}; + +#define ICreateTypeInfo2_IMETHODS \ + ICreateTypeInfo_IMETHODS \ + ICOM_METHOD1 (HRESULT,DeleteFuncDesc,UINT,index) \ + ICOM_METHOD2 (HRESULT,DeleteFuncDescByMemId,MEMBERID,memid,INVOKEKIND,invKind) \ + ICOM_METHOD1 (HRESULT,DeleteVarDesc,UINT,index) \ + ICOM_METHOD1 (HRESULT,DeleteVarDescByMemId,MEMBERID,memid) \ + ICOM_METHOD1 (HRESULT,DeleteImplType,UINT,index) \ + ICOM_METHOD2 (HRESULT,SetCustData,REFGUID,guid,VARIANT*,pVarVal) \ + ICOM_METHOD3 (HRESULT,SetFuncCustData,UINT,index,REFGUID,guid,VARIANT*,pVarVal) \ + ICOM_METHOD4 (HRESULT,SetParamCustData,UINT,indexFunc,UINT,indexParam,REFGUID,guid,VARIANT*,pVarVal) \ + ICOM_METHOD3 (HRESULT,SetVarCustData,UINT,index,REFGUID,guid,VARIANT*,pVarVal) \ + ICOM_METHOD3 (HRESULT,SetImplTypeCustData,UINT,index,REFGUID,guid,VARIANT*,pVarVal) \ + ICOM_METHOD1 (HRESULT,SetHelpStringContext,ULONG,dwHelpStringContext) \ + ICOM_METHOD2 (HRESULT,SetFuncHelpStringContext,UINT,index,ULONG,dwHelpStringContext) \ + ICOM_METHOD2 (HRESULT,SetVarHelpStringContext,UINT,index,ULONG,dwHelpStringContext) \ + ICOM_METHOD (HRESULT,Invalidate) \ + ICOM_METHOD1 (HRESULT,SetName,LPOLESTR,szName) + +/*** IUnknown methods ***/ +#define ICreateTypeInfo2_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define ICreateTypeInfo2_AddRef(p) (p)->lpVtbl->AddRef(p) +#define ICreateTypeInfo2_Release(p) (p)->lpVtbl->Release(p) +/*** ICreateTypeInfo methods ***/ +#define ICreateTypeInfo2_SetGuid(p,a) (p)->lpVtbl->SetGuid(p,a) +#define ICreateTypeInfo2_SetTypeFlags(p,a) (p)->lpVtbl->SetTypeFlags(p,a) +#define ICreateTypeInfo2_SetDocString(p,a) (p)->lpVtbl->SetDocString(p,a) +#define ICreateTypeInfo2_SetHelpContext(p,a) (p)->lpVtbl->SetHelpContext(p,a) +#define ICreateTypeInfo2_SetVersion(p,a,b) (p)->lpVtbl->SetVersion(p,a,b) +#define ICreateTypeInfo2_AddRefTypeInfo(p,a,b) (p)->lpVtbl->AddRefTypeInfo(p,a,b) +#define ICreateTypeInfo2_AddFuncDesc(p,a,b) (p)->lpVtbl->AddFuncDesc(p,a,b) +#define ICreateTypeInfo2_AddImplType(p,a,b) (p)->lpVtbl->AddImplType(p,a,b) +#define ICreateTypeInfo2_SetImplTypeFlags(p,a,b) (p)->lpVtbl->SetImplTypeFlags(p,a,b) +#define ICreateTypeInfo2_SetAlignment(p,a) (p)->lpVtbl->SetAlignment(p,a) +#define ICreateTypeInfo2_SetSchema(p,a) (p)->lpVtbl->SetSchema(p,a) +#define ICreateTypeInfo2_AddVarDesc(p,a,b) (p)->lpVtbl->AddVarDesc(p,a,b) +#define ICreateTypeInfo2_SetFuncAndParamNames(p,a,b,c) (p)->lpVtbl->SetFuncAndParamNames(p,a,b,c) +#define ICreateTypeInfo2_SetVarName(p,a,b) (p)->lpVtbl->SetVarName(p,a,b) +#define ICreateTypeInfo2_SetTypeDescAlias(p,a) (p)->lpVtbl->SetTypeDescAlias(p,a) +#define ICreateTypeInfo2_DefineFuncAsDllEntry(p,a,b,c) (p)->lpVtbl->DefineFuncAsDllEntry(p,a,b,c) +#define ICreateTypeInfo2_SetFuncDocString(p,a,b) (p)->lpVtbl->SetFuncDocString(p,a,b) +#define ICreateTypeInfo2_SetVarDocString(p,a,b) (p)->lpVtbl->SetVarDocString(p,a,b) +#define ICreateTypeInfo2_SetFuncHelpContext(p,a,b) (p)->lpVtbl->SetFuncHelpContext(p,a,b) +#define ICreateTypeInfo2_SetVarHelpContext(p,a,b) (p)->lpVtbl->SetVarHelpContext(p,a,b) +#define ICreateTypeInfo2_SetMops(p,a,b) (p)->lpVtbl->SetMops(p,a,b) +#define ICreateTypeInfo2_SetTypeIdldesc(p,a) (p)->lpVtbl->SetTypeIdldesc(p,a) +#define ICreateTypeInfo2_LayOut(p) (p)->lpVtbl->LayOut(p) +/*** ICreateTypeInfo2 methods ***/ +#define ICreateTypeInfo2_DeleteFuncDesc(p,a) (p)->lpVtbl->DeleteFuncDesc(p,a) +#define ICreateTypeInfo2_DeleteFuncDescByMemId(p,a,b) (p)->lpVtbl->DeleteFuncDescByMemId(p,a,b) +#define ICreateTypeInfo2_DeleteVarDesc(p,a) (p)->lpVtbl->DeleteVarDesc(p,a) +#define ICreateTypeInfo2_DeleteVarDescByMemId(p,a) (p)->lpVtbl->DeleteVarDescByMemId(p,a) +#define ICreateTypeInfo2_DeleteImplType(p,a) (p)->lpVtbl->DeleteImplType(p,a) +#define ICreateTypeInfo2_SetCustData(p,a,b) (p)->lpVtbl->SetCustData(p,a,b) +#define ICreateTypeInfo2_SetFuncCustData(p,a,b,c) (p)->lpVtbl->SetFuncCustData(p,a,b,c) +#define ICreateTypeInfo2_SetParamCustData(p,a,b,c,d) (p)->lpVtbl->SetParamCustData(p,a,b,c,d) +#define ICreateTypeInfo2_SetVarCustData(p,a,b,c) (p)->lpVtbl->SetVarCustData(p,a,b,c) +#define ICreateTypeInfo2_SetImplTypeCustData(p,a,b,c) (p)->lpVtbl->SetImplTypeCustData(p,a,b,c) +#define ICreateTypeInfo2_SetHelpStringContext(p,a) (p)->lpVtbl->SetHelpStringContext(p,a) +#define ICreateTypeInfo2_SetFuncHelpStringContext(p,a,b) (p)->lpVtbl->SetFuncHelpStringContext(p,a,b) +#define ICreateTypeInfo2_SetVarHelpStringContext(p,a,b) (p)->lpVtbl->SetVarHelpStringContext(p,a,b) +#define ICreateTypeInfo2_Invalidate(p) (p)->lpVtbl->Invalidate(p) +#define ICreateTypeInfo2_SetName(p,a) (p)->lpVtbl->SetName(p,a) + +#endif + +HRESULT CALLBACK ICreateTypeInfo2_DeleteFuncDesc_Proxy( + ICreateTypeInfo2* This, + UINT index); +void __RPC_STUB ICreateTypeInfo2_DeleteFuncDesc_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ICreateTypeInfo2_DeleteFuncDescByMemId_Proxy( + ICreateTypeInfo2* This, + MEMBERID memid, + INVOKEKIND invKind); +void __RPC_STUB ICreateTypeInfo2_DeleteFuncDescByMemId_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ICreateTypeInfo2_DeleteVarDesc_Proxy( + ICreateTypeInfo2* This, + UINT index); +void __RPC_STUB ICreateTypeInfo2_DeleteVarDesc_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ICreateTypeInfo2_DeleteVarDescByMemId_Proxy( + ICreateTypeInfo2* This, + MEMBERID memid); +void __RPC_STUB ICreateTypeInfo2_DeleteVarDescByMemId_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ICreateTypeInfo2_DeleteImplType_Proxy( + ICreateTypeInfo2* This, + UINT index); +void __RPC_STUB ICreateTypeInfo2_DeleteImplType_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ICreateTypeInfo2_SetCustData_Proxy( + ICreateTypeInfo2* This, + REFGUID guid, + VARIANT* pVarVal); +void __RPC_STUB ICreateTypeInfo2_SetCustData_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ICreateTypeInfo2_SetFuncCustData_Proxy( + ICreateTypeInfo2* This, + UINT index, + REFGUID guid, + VARIANT* pVarVal); +void __RPC_STUB ICreateTypeInfo2_SetFuncCustData_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ICreateTypeInfo2_SetParamCustData_Proxy( + ICreateTypeInfo2* This, + UINT indexFunc, + UINT indexParam, + REFGUID guid, + VARIANT* pVarVal); +void __RPC_STUB ICreateTypeInfo2_SetParamCustData_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ICreateTypeInfo2_SetVarCustData_Proxy( + ICreateTypeInfo2* This, + UINT index, + REFGUID guid, + VARIANT* pVarVal); +void __RPC_STUB ICreateTypeInfo2_SetVarCustData_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ICreateTypeInfo2_SetImplTypeCustData_Proxy( + ICreateTypeInfo2* This, + UINT index, + REFGUID guid, + VARIANT* pVarVal); +void __RPC_STUB ICreateTypeInfo2_SetImplTypeCustData_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ICreateTypeInfo2_SetHelpStringContext_Proxy( + ICreateTypeInfo2* This, + ULONG dwHelpStringContext); +void __RPC_STUB ICreateTypeInfo2_SetHelpStringContext_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ICreateTypeInfo2_SetFuncHelpStringContext_Proxy( + ICreateTypeInfo2* This, + UINT index, + ULONG dwHelpStringContext); +void __RPC_STUB ICreateTypeInfo2_SetFuncHelpStringContext_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ICreateTypeInfo2_SetVarHelpStringContext_Proxy( + ICreateTypeInfo2* This, + UINT index, + ULONG dwHelpStringContext); +void __RPC_STUB ICreateTypeInfo2_SetVarHelpStringContext_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ICreateTypeInfo2_Invalidate_Proxy( + ICreateTypeInfo2* This); +void __RPC_STUB ICreateTypeInfo2_Invalidate_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ICreateTypeInfo2_SetName_Proxy( + ICreateTypeInfo2* This, + LPOLESTR szName); +void __RPC_STUB ICreateTypeInfo2_SetName_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +typedef struct ICreateTypeLib ICreateTypeLib; +typedef ICreateTypeLib *LPCREATETYPELIB; + +/***************************************************************************** + * ICreateTypeLib interface + */ +DEFINE_GUID(IID_ICreateTypeLib, 0x00020406, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct ICreateTypeLib: IUnknown { + + virtual HRESULT CALLBACK CreateTypeInfo( + LPOLESTR szName, + TYPEKIND tkind, + ICreateTypeInfo** ppCTInfo) = 0; + + virtual HRESULT CALLBACK SetName( + LPOLESTR szName) = 0; + + virtual HRESULT CALLBACK SetVersion( + WORD wMajorVerNum, + WORD wMinorVerNum) = 0; + + virtual HRESULT CALLBACK SetGuid( + REFGUID guid) = 0; + + virtual HRESULT CALLBACK SetDocString( + LPOLESTR szDoc) = 0; + + virtual HRESULT CALLBACK SetHelpFileName( + LPOLESTR szHelpFileName) = 0; + + virtual HRESULT CALLBACK SetHelpContext( + DWORD dwHelpContext) = 0; + + virtual HRESULT CALLBACK SetLcid( + LCID lcid) = 0; + + virtual HRESULT CALLBACK SetLibFlags( + UINT uLibFlags) = 0; + + virtual HRESULT CALLBACK SaveAllChanges( + ) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct ICreateTypeLibVtbl ICreateTypeLibVtbl; +struct ICreateTypeLib { + const ICreateTypeLibVtbl* lpVtbl; +}; +struct ICreateTypeLibVtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + ICreateTypeLib* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + ICreateTypeLib* This); + + ULONG (CALLBACK *Release)( + ICreateTypeLib* This); + + /*** ICreateTypeLib methods ***/ + HRESULT (CALLBACK *CreateTypeInfo)( + ICreateTypeLib* This, + LPOLESTR szName, + TYPEKIND tkind, + ICreateTypeInfo** ppCTInfo); + + HRESULT (CALLBACK *SetName)( + ICreateTypeLib* This, + LPOLESTR szName); + + HRESULT (CALLBACK *SetVersion)( + ICreateTypeLib* This, + WORD wMajorVerNum, + WORD wMinorVerNum); + + HRESULT (CALLBACK *SetGuid)( + ICreateTypeLib* This, + REFGUID guid); + + HRESULT (CALLBACK *SetDocString)( + ICreateTypeLib* This, + LPOLESTR szDoc); + + HRESULT (CALLBACK *SetHelpFileName)( + ICreateTypeLib* This, + LPOLESTR szHelpFileName); + + HRESULT (CALLBACK *SetHelpContext)( + ICreateTypeLib* This, + DWORD dwHelpContext); + + HRESULT (CALLBACK *SetLcid)( + ICreateTypeLib* This, + LCID lcid); + + HRESULT (CALLBACK *SetLibFlags)( + ICreateTypeLib* This, + UINT uLibFlags); + + HRESULT (CALLBACK *SaveAllChanges)( + ICreateTypeLib* This); + +}; + +#define ICreateTypeLib_IMETHODS \ + IUnknown_IMETHODS \ + ICOM_METHOD3 (HRESULT,CreateTypeInfo,LPOLESTR,szName,TYPEKIND,tkind,ICreateTypeInfo**,ppCTInfo) \ + ICOM_METHOD1 (HRESULT,SetName,LPOLESTR,szName) \ + ICOM_METHOD2 (HRESULT,SetVersion,WORD,wMajorVerNum,WORD,wMinorVerNum) \ + ICOM_METHOD1 (HRESULT,SetGuid,REFGUID,guid) \ + ICOM_METHOD1 (HRESULT,SetDocString,LPOLESTR,szDoc) \ + ICOM_METHOD1 (HRESULT,SetHelpFileName,LPOLESTR,szHelpFileName) \ + ICOM_METHOD1 (HRESULT,SetHelpContext,DWORD,dwHelpContext) \ + ICOM_METHOD1 (HRESULT,SetLcid,LCID,lcid) \ + ICOM_METHOD1 (HRESULT,SetLibFlags,UINT,uLibFlags) \ + ICOM_METHOD (HRESULT,SaveAllChanges) + +/*** IUnknown methods ***/ +#define ICreateTypeLib_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define ICreateTypeLib_AddRef(p) (p)->lpVtbl->AddRef(p) +#define ICreateTypeLib_Release(p) (p)->lpVtbl->Release(p) +/*** ICreateTypeLib methods ***/ +#define ICreateTypeLib_CreateTypeInfo(p,a,b,c) (p)->lpVtbl->CreateTypeInfo(p,a,b,c) +#define ICreateTypeLib_SetName(p,a) (p)->lpVtbl->SetName(p,a) +#define ICreateTypeLib_SetVersion(p,a,b) (p)->lpVtbl->SetVersion(p,a,b) +#define ICreateTypeLib_SetGuid(p,a) (p)->lpVtbl->SetGuid(p,a) +#define ICreateTypeLib_SetDocString(p,a) (p)->lpVtbl->SetDocString(p,a) +#define ICreateTypeLib_SetHelpFileName(p,a) (p)->lpVtbl->SetHelpFileName(p,a) +#define ICreateTypeLib_SetHelpContext(p,a) (p)->lpVtbl->SetHelpContext(p,a) +#define ICreateTypeLib_SetLcid(p,a) (p)->lpVtbl->SetLcid(p,a) +#define ICreateTypeLib_SetLibFlags(p,a) (p)->lpVtbl->SetLibFlags(p,a) +#define ICreateTypeLib_SaveAllChanges(p) (p)->lpVtbl->SaveAllChanges(p) + +#endif + +HRESULT CALLBACK ICreateTypeLib_CreateTypeInfo_Proxy( + ICreateTypeLib* This, + LPOLESTR szName, + TYPEKIND tkind, + ICreateTypeInfo** ppCTInfo); +void __RPC_STUB ICreateTypeLib_CreateTypeInfo_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ICreateTypeLib_SetName_Proxy( + ICreateTypeLib* This, + LPOLESTR szName); +void __RPC_STUB ICreateTypeLib_SetName_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ICreateTypeLib_SetVersion_Proxy( + ICreateTypeLib* This, + WORD wMajorVerNum, + WORD wMinorVerNum); +void __RPC_STUB ICreateTypeLib_SetVersion_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ICreateTypeLib_SetGuid_Proxy( + ICreateTypeLib* This, + REFGUID guid); +void __RPC_STUB ICreateTypeLib_SetGuid_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ICreateTypeLib_SetDocString_Proxy( + ICreateTypeLib* This, + LPOLESTR szDoc); +void __RPC_STUB ICreateTypeLib_SetDocString_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ICreateTypeLib_SetHelpFileName_Proxy( + ICreateTypeLib* This, + LPOLESTR szHelpFileName); +void __RPC_STUB ICreateTypeLib_SetHelpFileName_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ICreateTypeLib_SetHelpContext_Proxy( + ICreateTypeLib* This, + DWORD dwHelpContext); +void __RPC_STUB ICreateTypeLib_SetHelpContext_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ICreateTypeLib_SetLcid_Proxy( + ICreateTypeLib* This, + LCID lcid); +void __RPC_STUB ICreateTypeLib_SetLcid_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ICreateTypeLib_SetLibFlags_Proxy( + ICreateTypeLib* This, + UINT uLibFlags); +void __RPC_STUB ICreateTypeLib_SetLibFlags_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ICreateTypeLib_SaveAllChanges_Proxy( + ICreateTypeLib* This); +void __RPC_STUB ICreateTypeLib_SaveAllChanges_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +typedef struct ICreateTypeLib2 ICreateTypeLib2; +typedef ICreateTypeLib2 *LPCREATETYPELIB2; + +/***************************************************************************** + * ICreateTypeLib2 interface + */ +DEFINE_GUID(IID_ICreateTypeLib2, 0x0002040f, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct ICreateTypeLib2: ICreateTypeLib { + + virtual HRESULT CALLBACK DeleteTypeInfo( + LPOLESTR szName) = 0; + + virtual HRESULT CALLBACK SetCustData( + REFGUID guid, + VARIANT* pVarVal) = 0; + + virtual HRESULT CALLBACK SetHelpStringContext( + ULONG dwHelpStringContext) = 0; + + virtual HRESULT CALLBACK SetHelpStringDll( + LPOLESTR szFileName) = 0; + +} ICOM_COM_INTERFACE_ATTRIBUTE; +#else +typedef struct ICreateTypeLib2Vtbl ICreateTypeLib2Vtbl; +struct ICreateTypeLib2 { + const ICreateTypeLib2Vtbl* lpVtbl; +}; +struct ICreateTypeLib2Vtbl { + ICOM_MSVTABLE_COMPAT_FIELDS + + /*** IUnknown methods ***/ + HRESULT (CALLBACK *QueryInterface)( + ICreateTypeLib2* This, + REFIID riid, + void** ppvObject); + + ULONG (CALLBACK *AddRef)( + ICreateTypeLib2* This); + + ULONG (CALLBACK *Release)( + ICreateTypeLib2* This); + + /*** ICreateTypeLib methods ***/ + HRESULT (CALLBACK *CreateTypeInfo)( + ICreateTypeLib2* This, + LPOLESTR szName, + TYPEKIND tkind, + ICreateTypeInfo** ppCTInfo); + + HRESULT (CALLBACK *SetName)( + ICreateTypeLib2* This, + LPOLESTR szName); + + HRESULT (CALLBACK *SetVersion)( + ICreateTypeLib2* This, + WORD wMajorVerNum, + WORD wMinorVerNum); + + HRESULT (CALLBACK *SetGuid)( + ICreateTypeLib2* This, + REFGUID guid); + + HRESULT (CALLBACK *SetDocString)( + ICreateTypeLib2* This, + LPOLESTR szDoc); + + HRESULT (CALLBACK *SetHelpFileName)( + ICreateTypeLib2* This, + LPOLESTR szHelpFileName); + + HRESULT (CALLBACK *SetHelpContext)( + ICreateTypeLib2* This, + DWORD dwHelpContext); + + HRESULT (CALLBACK *SetLcid)( + ICreateTypeLib2* This, + LCID lcid); + + HRESULT (CALLBACK *SetLibFlags)( + ICreateTypeLib2* This, + UINT uLibFlags); + + HRESULT (CALLBACK *SaveAllChanges)( + ICreateTypeLib2* This); + + /*** ICreateTypeLib2 methods ***/ + HRESULT (CALLBACK *DeleteTypeInfo)( + ICreateTypeLib2* This, + LPOLESTR szName); + + HRESULT (CALLBACK *SetCustData)( + ICreateTypeLib2* This, + REFGUID guid, + VARIANT* pVarVal); + + HRESULT (CALLBACK *SetHelpStringContext)( + ICreateTypeLib2* This, + ULONG dwHelpStringContext); + + HRESULT (CALLBACK *SetHelpStringDll)( + ICreateTypeLib2* This, + LPOLESTR szFileName); + +}; + +#define ICreateTypeLib2_IMETHODS \ + ICreateTypeLib_IMETHODS \ + ICOM_METHOD1 (HRESULT,DeleteTypeInfo,LPOLESTR,szName) \ + ICOM_METHOD2 (HRESULT,SetCustData,REFGUID,guid,VARIANT*,pVarVal) \ + ICOM_METHOD1 (HRESULT,SetHelpStringContext,ULONG,dwHelpStringContext) \ + ICOM_METHOD1 (HRESULT,SetHelpStringDll,LPOLESTR,szFileName) + +/*** IUnknown methods ***/ +#define ICreateTypeLib2_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define ICreateTypeLib2_AddRef(p) (p)->lpVtbl->AddRef(p) +#define ICreateTypeLib2_Release(p) (p)->lpVtbl->Release(p) +/*** ICreateTypeLib methods ***/ +#define ICreateTypeLib2_CreateTypeInfo(p,a,b,c) (p)->lpVtbl->CreateTypeInfo(p,a,b,c) +#define ICreateTypeLib2_SetName(p,a) (p)->lpVtbl->SetName(p,a) +#define ICreateTypeLib2_SetVersion(p,a,b) (p)->lpVtbl->SetVersion(p,a,b) +#define ICreateTypeLib2_SetGuid(p,a) (p)->lpVtbl->SetGuid(p,a) +#define ICreateTypeLib2_SetDocString(p,a) (p)->lpVtbl->SetDocString(p,a) +#define ICreateTypeLib2_SetHelpFileName(p,a) (p)->lpVtbl->SetHelpFileName(p,a) +#define ICreateTypeLib2_SetHelpContext(p,a) (p)->lpVtbl->SetHelpContext(p,a) +#define ICreateTypeLib2_SetLcid(p,a) (p)->lpVtbl->SetLcid(p,a) +#define ICreateTypeLib2_SetLibFlags(p,a) (p)->lpVtbl->SetLibFlags(p,a) +#define ICreateTypeLib2_SaveAllChanges(p) (p)->lpVtbl->SaveAllChanges(p) +/*** ICreateTypeLib2 methods ***/ +#define ICreateTypeLib2_DeleteTypeInfo(p,a) (p)->lpVtbl->DeleteTypeInfo(p,a) +#define ICreateTypeLib2_SetCustData(p,a,b) (p)->lpVtbl->SetCustData(p,a,b) +#define ICreateTypeLib2_SetHelpStringContext(p,a) (p)->lpVtbl->SetHelpStringContext(p,a) +#define ICreateTypeLib2_SetHelpStringDll(p,a) (p)->lpVtbl->SetHelpStringDll(p,a) + +#endif + +HRESULT CALLBACK ICreateTypeLib2_DeleteTypeInfo_Proxy( + ICreateTypeLib2* This, + LPOLESTR szName); +void __RPC_STUB ICreateTypeLib2_DeleteTypeInfo_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ICreateTypeLib2_SetCustData_Proxy( + ICreateTypeLib2* This, + REFGUID guid, + VARIANT* pVarVal); +void __RPC_STUB ICreateTypeLib2_SetCustData_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ICreateTypeLib2_SetHelpStringContext_Proxy( + ICreateTypeLib2* This, + ULONG dwHelpStringContext); +void __RPC_STUB ICreateTypeLib2_SetHelpStringContext_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ICreateTypeLib2_SetHelpStringDll_Proxy( + ICreateTypeLib2* This, + LPOLESTR szFileName); +void __RPC_STUB ICreateTypeLib2_SetHelpStringDll_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#ifdef __cplusplus +} +#endif +#endif /* __WIDL_OAIDL_H */ diff --git a/include/oaidl.idl b/include/oaidl.idl new file mode 100644 index 00000000000..440e662ad3f --- /dev/null +++ b/include/oaidl.idl @@ -0,0 +1,1573 @@ +/* + * Copyright 2002 Ove Kaaven + * + * 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 + */ + +import "objidl.idl"; + +interface IDispatch; +interface ITypeInfo; +interface ITypeLib; +interface IRecordInfo; + +[ + version(1.0), + pointer_default(unique) +] +interface IOleAutomationTypes +{ + +typedef CY CURRENCY; + +/* Safe Array */ + +typedef struct tagSAFEARRAYBOUND { + ULONG cElements; + LONG lLbound; +} SAFEARRAYBOUND, *LPSAFEARRAYBOUND; + +typedef [unique] struct _wireVARIANT *wireVARIANT; +typedef [unique] struct _wireBRECORD *wireBRECORD; + +typedef struct _wireSAFEARR_BSTR { + ULONG Size; + [size_is(Size), ref] wireBSTR *aBstr; +} SAFEARR_BSTR; + +typedef struct _wireSAFEARR_UNKNOWN { + ULONG Size; + [size_is(Size), ref] IUnknown **apUnknown; +} SAFEARR_UNKNOWN; + +typedef struct _wireSAFEARR_DISPATCH { + ULONG Size; + [size_is(Size), ref] IDispatch **apDispatch; +} SAFEARR_DISPATCH; + +typedef struct _wireSAFEARR_VARIANT { + ULONG Size; + [size_is(Size), ref] wireVARIANT *aVariant; +} SAFEARR_VARIANT; + +typedef struct _wireSAFEARR_BRECORD { + ULONG Size; + [size_is(Size), ref] wireBRECORD *aRecord; +} SAFEARR_BRECORD; + +typedef struct _wireSAFEARR_HAVEIID { + ULONG Size; + [size_is(Size), ref] IUnknown **apUnknown; + IID iid; +} SAFEARR_HAVEIID; + +typedef [v1_enum] enum tagSF_TYPE { + SF_ERROR = VT_ERROR, + SF_I1 = VT_I1, + SF_I2 = VT_I2, + SF_I4 = VT_I4, + SF_I8 = VT_I8, + SF_BSTR = VT_BSTR, + SF_UNKNOWN = VT_UNKNOWN, + SF_DISPATCH = VT_DISPATCH, + SF_VARIANT = VT_VARIANT, + SF_RECORD = VT_RECORD, + SF_HAVEIID = VT_UNKNOWN|VT_RESERVED, +} SF_TYPE; + +typedef union _wireSAFEARRAY_UNION switch(ULONG sfType) u { + case SF_BSTR: SAFEARR_BSTR BstrStr; + case SF_UNKNOWN: SAFEARR_UNKNOWN UnknownStr; + case SF_DISPATCH: SAFEARR_DISPATCH DispatchStr; + case SF_VARIANT: SAFEARR_VARIANT VariantStr; + case SF_RECORD: SAFEARR_BRECORD RecordStr; + case SF_HAVEIID: SAFEARR_HAVEIID HaveIidStr; + case SF_I1: BYTE_SIZEDARR ByteStr; + case SF_I2: WORD_SIZEDARR WordStr; + case SF_I4: DWORD_SIZEDARR LongStr; + case SF_I8: HYPER_SIZEDARR HyperStr; +} SAFEARRAYUNION; + +typedef [unique] struct _wireSAFEARRAY { + USHORT cDims; + USHORT fFeatures; + ULONG cbElements; + ULONG cLocks; + SAFEARRAYUNION uArrayStructs; + [size_is(cDims)] SAFEARRAYBOUND rgsabound[]; +} *wireSAFEARRAY; + +typedef [unique] wireSAFEARRAY *wirePSAFEARRAY; + +typedef struct tagSAFEARRAY { + USHORT cDims; + USHORT fFeatures; + ULONG cbElements; + ULONG cLocks; + PVOID pvData; + SAFEARRAYBOUND rgsabound[]; +} SAFEARRAY; + +typedef [wire_marshal(wirePSAFEARRAY)] SAFEARRAY *LPSAFEARRAY; + +const USHORT FADF_AUTO = 0x0001; +const USHORT FADF_STATIC = 0x0002; +const USHORT FADF_EMBEDDED = 0x0004; +const USHORT FADF_FIXEDSIZE = 0x0010; +const USHORT FADF_RECORD = 0x0020; +const USHORT FADF_HAVEIID = 0x0040; +const USHORT FADF_HAVEVARTYPE = 0x0080; +const USHORT FADF_BSTR = 0x0100; +const USHORT FADF_UNKNOWN = 0x0200; +const USHORT FADF_DISPATCH = 0x0400; +const USHORT FADF_VARIANT = 0x0800; +const USHORT FADF_RESERVED = 0xF008; +/* Undocumented flags */ +const USHORT FADF_CREATEVECTOR = 0x2000; /* set when the safe array is created using SafeArrayCreateVector */ + +/* Variant */ + +cpp_quote("#if (__STDC__ && !defined(_FORCENAMELESSUNION)) || defined(NONAMELESSUNION)") +cpp_quote("#define __VARIANT_NAME_1 n1") +cpp_quote("#define __VARIANT_NAME_2 n2") +cpp_quote("#define __VARIANT_NAME_3 n3") +cpp_quote("#define __VARIANT_NAME_4 brecVal") +cpp_quote("#else") +cpp_quote("#define __tagVARIANT") +cpp_quote("#define __VARIANT_NAME_1") +cpp_quote("#define __VARIANT_NAME_2") +cpp_quote("#define __VARIANT_NAME_3") +cpp_quote("#define __tagBRECORD") +cpp_quote("#define __VARIANT_NAME_4") +cpp_quote("#endif") + +typedef [wire_marshal(wireVARIANT)] struct tagVARIANT VARIANT; + +struct tagVARIANT { + union { + struct __tagVARIANT { + VARTYPE vt; + WORD wReserved1; + WORD wReserved2; + WORD wReserved3; + union { + CHAR cVal; + USHORT uiVal; + ULONG ulVal; + INT intVal; + UINT uintVal; + BYTE bVal; + SHORT iVal; + LONG lVal; + FLOAT fltVal; + DOUBLE dblVal; + VARIANT_BOOL boolVal; +#if 0 /* illegal in C++ */ + _VARIANT_BOOL bool; +#endif + SCODE scode; + DATE date; + BSTR bstrVal; + CY cyVal; + IUnknown *punkVal; + IDispatch *pdispVal; + SAFEARRAY *parray; + CHAR *pcVal; + USHORT *puiVal; + ULONG *pulVal; + INT *pintVal; + UINT *puintVal; + BYTE *pbVal; + SHORT *piVal; + LONG *plVal; + FLOAT *pfltVal; + DOUBLE *pdblVal; + VARIANT_BOOL *pboolVal; +#if 0 + _VARIANT_BOOL *pbool; +#endif + SCODE *pscode; + DATE *pdate; + BSTR *pbstrVal; + VARIANT *pvarVal; + PVOID byref; + CY *pcyVal; + DECIMAL *pdecVal; + IUnknown **ppunkVal; + IDispatch **ppdispVal; + SAFEARRAY **pparray; + struct __tagBRECORD { + PVOID pvRecord; + IRecordInfo *pRecInfo; + } __VARIANT_NAME_4; + } __VARIANT_NAME_3; + } __VARIANT_NAME_2; + + DECIMAL decVal; + } __VARIANT_NAME_1; +}; + +typedef VARIANT *LPVARIANT; +typedef VARIANT VARIANTARG; +typedef VARIANTARG *LPVARIANTARG; + +struct _wireBRECORD { + ULONG fFlags; + ULONG clSize; + IRecordInfo *pRecInfo; + [size_is(clSize)] byte *pRecord; +}; + +struct _wireVARIANT { + DWORD clSize; + DWORD rpcReserved; + USHORT vt; + USHORT wReserved1; + USHORT wReserved2; + USHORT wReserved3; + [switch_is(vt)] union { + [case(VT_EMPTY, VT_NULL)] ; + [case(VT_I1)] CHAR cVal; + [case(VT_UI2)] USHORT uiVal; + [case(VT_UI4)] ULONG ulVal; + [case(VT_INT)] INT intVal; + [case(VT_UINT)] UINT uintVal; + [case(VT_UI1)] BYTE bVal; + [case(VT_I2)] SHORT iVal; + [case(VT_I4)] LONG lVal; + [case(VT_R4)] FLOAT fltVal; + [case(VT_R8)] DOUBLE dblVal; + [case(VT_BOOL)] VARIANT_BOOL boolVal; + [case(VT_ERROR)] SCODE scode; + [case(VT_DATE)] DATE date; + [case(VT_BSTR)] wireBSTR bstrVal; + [case(VT_CY)] CY cyVal; + [case(VT_DECIMAL)] DECIMAL decVal; + [case(VT_UNKNOWN)] IUnknown *punkVal; + [case(VT_DISPATCH)] IDispatch *pdispVal; + [case(VT_ARRAY)] wireSAFEARRAY parray; + [case(VT_I1|VT_BYREF)] CHAR *pcVal; + [case(VT_UI2|VT_BYREF)] USHORT *puiVal; + [case(VT_UI4|VT_BYREF)] ULONG *pulVal; + [case(VT_INT|VT_BYREF)] INT *pintVal; + [case(VT_UINT|VT_BYREF)] UINT *puintVal; + [case(VT_UI1|VT_BYREF)] BYTE *pbVal; + [case(VT_I2|VT_BYREF)] SHORT *piVal; + [case(VT_I4|VT_BYREF)] LONG *plVal; + [case(VT_R4|VT_BYREF)] FLOAT *pfltVal; + [case(VT_R8|VT_BYREF)] DOUBLE *pdblVal; + [case(VT_BOOL|VT_BYREF)] VARIANT_BOOL *pboolVal; + [case(VT_ERROR|VT_BYREF)] SCODE *pscode; + [case(VT_DATE|VT_BYREF)] DATE *pdate; + [case(VT_BSTR|VT_BYREF)] wireBSTR *pbstrVal; + [case(VT_VARIANT|VT_BYREF)] wireVARIANT *pvarVal; + [case(VT_CY|VT_BYREF)] CY *pcyVal; + [case(VT_DECIMAL|VT_BYREF)] DECIMAL *pdecVal; + [case(VT_UNKNOWN|VT_BYREF)] IUnknown **ppunkVal; + [case(VT_DISPATCH|VT_BYREF)] IDispatch **ppdispVal; + [case(VT_ARRAY|VT_BYREF)] wireSAFEARRAY *pparray; + [case(VT_RECORD, VT_RECORD|VT_BYREF)] wireBRECORD brecVal; + }; +}; + +/* Dispatch */ + +typedef LONG DISPID; +typedef DWORD HREFTYPE; +typedef DISPID MEMBERID; + +typedef [v1_enum] enum tagTYPEKIND { + TKIND_ENUM = 0, + TKIND_RECORD, + TKIND_MODULE, + TKIND_INTERFACE, + TKIND_DISPATCH, + TKIND_COCLASS, + TKIND_ALIAS, + TKIND_UNION, + TKIND_MAX +} TYPEKIND; + +typedef struct tagTYPEDESC { + [switch_is(vt)] union { + [case(VT_PTR, VT_SAFEARRAY)] struct tagTYPEDESC *lptdesc; + [case(VT_CARRAY)] struct tagARRAYDESC *lpadesc; + [case(VT_USERDEFINED)] HREFTYPE hreftype; + [default] ; + }; + VARTYPE vt; +} TYPEDESC; + +typedef struct tagARRAYDESC { + TYPEDESC tdescElem; + USHORT cDims; + [size_is(cDims)] SAFEARRAYBOUND rgbounds[]; +} ARRAYDESC; + +typedef struct tagPARAMDESCEX { + ULONG cBytes; + VARIANTARG varDefaultValue; +} PARAMDESCEX, *LPPARAMDESCEX; + +typedef struct tagPARAMDESC { + LPPARAMDESCEX pparamdescex; + USHORT wParamFlags; +} PARAMDESC, *LPPARAMDESC; + +const USHORT PARAMFLAG_NONE = 0x00; +const USHORT PARAMFLAG_FIN = 0x01; +const USHORT PARAMFLAG_FOUT = 0x02; +const USHORT PARAMFLAG_FLCID = 0x04; +const USHORT PARAMFLAG_FRETVAL = 0x08; +const USHORT PARAMFLAG_FOPT = 0x10; +const USHORT PARAMFLAG_FHASDEFAULT = 0x20; +const USHORT PARAMFLAG_FHASCUSTDATA = 0x40; + +typedef struct tagIDLDESC { + ULONG dwReserved; + USHORT wIDLFlags; +} IDLDESC, *LPIDLDESC; + +const USHORT IDLFLAG_NONE = PARAMFLAG_NONE; +const USHORT IDLFLAG_FIN = PARAMFLAG_FIN; +const USHORT IDLFLAG_FOUT = PARAMFLAG_FOUT; +const USHORT IDLFLAG_FLCID = PARAMFLAG_FLCID; +const USHORT IDLFLAG_FRETVAL = PARAMFLAG_FRETVAL; + +cpp_quote("#if 0") /* for IDL only */ +typedef struct tagELEMDESC { + TYPEDESC tdesc; + PARAMDESC paramdesc; +} ELEMDESC; +cpp_quote("#else") /* C/C++ defs */ +cpp_quote("typedef struct tagELEMDESC {") +cpp_quote(" TYPEDESC tdesc;") +cpp_quote(" union {") +cpp_quote(" IDLDESC idldesc;") +cpp_quote(" PARAMDESC paramdesc;") +cpp_quote(" } DUMMYUNIONNAME;") +cpp_quote("} ELEMDESC, *LPELEMDESC;") +cpp_quote("#endif") + +typedef struct tagTYPEATTR { + GUID guid; + LCID lcid; + DWORD dwReserved; + MEMBERID memidConstructor; + MEMBERID memidDestructor; + LPOLESTR lpstrSchema; + ULONG cbSizeInstance; + TYPEKIND typekind; + WORD cFuncs; + WORD cVars; + WORD cImplTypes; + WORD cbSizeVft; + WORD cbAlignment; + WORD wTypeFlags; + WORD wMajorVerNum; + WORD wMinorVerNum; + TYPEDESC tdescAlias; + IDLDESC idldescType; +} TYPEATTR, *LPTYPEATTR; + +typedef struct tagDISPPARAMS { + [size_is(cArgs)] VARIANTARG *rgvarg; + [size_is(cNamedArgs)] DISPID *rgdispidNamedArgs; + UINT cArgs; + UINT cNamedArgs; +} DISPPARAMS; + +cpp_quote("#if 0") /* for IDL only */ +typedef struct tagEXCEPINFO { + WORD wCode; + WORD wReserved; + BSTR bstrSource; + BSTR bstrDescription; + BSTR bstrHelpFile; + DWORD dwHelpContext; + ULONG pvReserved; + ULONG pfnDeferredFillIn; + SCODE scode; +} EXCEPINFO; +cpp_quote("#else") +cpp_quote("typedef struct tagEXCEPINFO {") +cpp_quote(" WORD wCode;") +cpp_quote(" WORD wReserved;") +cpp_quote(" BSTR bstrSource;") +cpp_quote(" BSTR bstrDescription;") +cpp_quote(" BSTR bstrHelpFile;") +cpp_quote(" DWORD dwHelpContext;") +cpp_quote(" PVOID pvReserved;") +cpp_quote(" HRESULT (__stdcall *pfnDeferredFillIn)(struct tagEXCEPINFO *);") +cpp_quote(" SCODE scode;") +cpp_quote("} EXCEPINFO, *LPEXCEPINFO;") +cpp_quote("#endif") + +typedef [v1_enum] enum tagCALLCONV { + CC_FASTCALL = 0, + CC_CDECL = 1, + CC_MSCPASCAL, + CC_PASCAL = CC_MSCPASCAL, + CC_MACPASCAL, + CC_STDCALL, + CC_FPFASTCALL, + CC_SYSCALL, + CC_MPWCDECL, + CC_MPWPASCAL, + CC_MAX +} CALLCONV; + +typedef [v1_enum] enum tagFUNCKIND { + FUNC_VIRTUAL, + FUNC_PUREVIRTUAL, + FUNC_NONVIRTUAL, + FUNC_STATIC, + FUNC_DISPATCH +} FUNCKIND; + +typedef [v1_enum] enum tagINVOKEKIND { + INVOKE_FUNC = 1, + INVOKE_PROPERTYGET = 2, + INVOKE_PROPERTYPUT = 4, + INVOKE_PROPERTYPUTREF = 8 +} INVOKEKIND; + +typedef struct tagFUNCDESC { + MEMBERID memid; + [size_is(cScodes)] SCODE *lprgscode; + [size_is(cParams)] ELEMDESC *lprgelemdescParam; + FUNCKIND funckind; + INVOKEKIND invkind; + CALLCONV callconv; + SHORT cParams; + SHORT cParamsOpt; + SHORT oVft; + SHORT cScodes; + ELEMDESC elemdescFunc; + WORD wFuncFlags; +} FUNCDESC, *LPFUNCDESC; + +typedef [v1_enum] enum tagVARKIND { + VAR_PERINSTANCE, + VAR_STATIC, + VAR_CONST, + VAR_DISPATCH +} VARKIND; + +const USHORT IMPLTYPEFLAG_FDEFAULT = 0x1; +const USHORT IMPLTYPEFLAG_FSOURCE = 0x2; +const USHORT IMPLTYPEFLAG_FRESTRICTED = 0x4; +const USHORT IMPLTYPEFLAG_FDEFAULTVTABLE = 0x8; + +typedef struct tagVARDESC { + MEMBERID memid; + LPOLESTR lpstrSchema; + [switch_is(varkind)] union { + [case(VAR_PERINSTANCE, VAR_DISPATCH, VAR_STATIC)] ULONG oInst; + [case(VAR_CONST)] VARIANT *lpvarValue; + }; + ELEMDESC elemdescVar; + WORD wVarFlags; + VARKIND varkind; +} VARDESC, *LPVARDESC; + +typedef enum tagTYPEFLAGS { + TYPEFLAG_FAPPOBJECT = 0x0001, + TYPEFLAG_FCANCREATE = 0x0002, + TYPEFLAG_FLICENSED = 0x0004, + TYPEFLAG_FPREDECLID = 0x0008, + TYPEFLAG_FHIDDEN = 0x0010, + TYPEFLAG_FCONTROL = 0x0020, + TYPEFLAG_FDUAL = 0x0040, + TYPEFLAG_FNONEXTENSIBLE = 0x0080, + TYPEFLAG_FOLEAUTOMATION = 0x0100, + TYPEFLAG_FRESTRICTED = 0x0200, + TYPEFLAG_FAGGREGATABLE = 0x0400, + TYPEFLAG_FREPLACEABLE = 0x0800, + TYPEFLAG_FDISPATCHABLE = 0x1000, + TYPEFLAG_FREVERSEBIND = 0x2000, + TYPEFLAG_FPROXY = 0x4000 +} TYPEFLAGS; + +typedef enum tagFUNCFLAGS { + FUNCFLAG_FRESTRICTED = 0x0001, + FUNCFLAG_FSOURCE = 0x0002, + FUNCFLAG_FBINDABLE = 0x0004, + FUNCFLAG_FREQUESTEDIT = 0x0008, + FUNCFLAG_FDISPLAYBIND = 0x0010, + FUNCFLAG_FDEFAULTBIND = 0x0020, + FUNCFLAG_FHIDDEN = 0x0040, + FUNCFLAG_FUSESGETLASTERROR = 0x0080, + FUNCFLAG_FDEFAULTCOLLELEM = 0x0100, + FUNCFLAG_FUIDEFAULT = 0x0200, + FUNCFLAG_FNONBROWSABLE = 0x0400, + FUNCFLAG_FREPLACEABLE = 0x0800, + FUNCFLAG_FIMMEDIATEBIND = 0x1000 +} FUNCFLAGS; + +typedef enum tagVARFLAGS { + VARFLAG_FREADONLY = 0x0001, + VARFLAG_FSOURCE = 0x0002, + VARFLAG_FBINDABLE = 0x0004, + VARFLAG_FREQUESTEDIT = 0x0008, + VARFLAG_FDISPLAYBIND = 0x0010, + VARFLAG_FDEFAULTBIND = 0x0020, + VARFLAG_FHIDDEN = 0x0040, + VARFLAG_FRESTRICTED = 0x0080, + VARFLAG_FDEFAULTCOLLELEM = 0x0100, + VARFLAG_FUIDEFAULT = 0x0200, + VARFLAG_FNONBROWSABLE = 0x0400, + VARFLAG_FREPLACEABLE = 0x0800, + VARFLAG_FIMMEDIATEBIND = 0x1000 +} VARFLAGS; + +typedef [wire_marshal(DWORD)] struct tagCLEANLOCALSTORAGE { + IUnknown *pInterface; + PVOID pStorage; + DWORD flags; +} CLEANLOCALSTORAGE; + +typedef struct tagCUSTDATAITEM { + GUID guid; + VARIANTARG varValue; +} CUSTDATAITEM, *LPCUSTDATAITEM; + +typedef struct tagCUSTDATA { + DWORD cCustData; + [size_is(cCustData)] LPCUSTDATAITEM prgCustData; +} CUSTDATA, *LPCUSTDATA; + +} /* interface IOleAutomationTypes */ + +/******************** INTERFACES ********************/ + +[ + object, + uuid(00020400-0000-0000-C000-000000000046), + pointer_default(unique) +] +interface IDispatch : IUnknown +{ + typedef [unique] IDispatch *LPDISPATCH; + + const DISPID DISPID_UNKNOWN = -1; + const DISPID DISPID_VALUE = 0; + const DISPID DISPID_PROPERTYPUT = -3; + const DISPID DISPID_NEWENUM = -4; + const DISPID DISPID_EVALUATE = -5; + const DISPID DISPID_CONSTRUCTOR = -6; + const DISPID DISPID_DESTRUCTOR = -7; + const DISPID DISPID_COLLECT = -8; + + HRESULT GetTypeInfoCount( + [out] UINT *pctinfo); + + HRESULT GetTypeInfo( + [in] UINT iTInfo, + [in] LCID lcid, + [out] ITypeInfo **ppTInfo); + + HRESULT GetIDsOfNames( + [in] REFIID riid, + [in, size_is(cNames)] LPOLESTR *rgszNames, + [in] UINT cNames, + [in] LCID lcid, + [out, size_is(cNames)] DISPID *rgDispId); + + [local] + HRESULT Invoke( + [in] DISPID dispIdMember, + [in] REFIID riid, + [in] LCID lcid, + [in] WORD wFlags, + [in, out] DISPPARAMS *pDispParams, + [out] VARIANT *pVarResult, + [out] EXCEPINFO *pExcepInfo, + [out] UINT *puArgErr); + + [call_as(Invoke)] + HRESULT RemoteInvoke( + [in] DISPID dispIdMember, + [in] REFIID riid, + [in] LCID lcid, + [in] DWORD dwFlags, + [in] DISPPARAMS *pDispParams, + [out] VARIANT *pVarResult, + [out] EXCEPINFO *pExcepInfo, + [out] UINT *pArgErr, + [in] UINT cVarRef, + [in, size_is(cVarRef)] UINT *rgVarRefIdx, + [in, out, size_is(cVarRef)] VARIANTARG *rgVarRef); +} + +[ + object, + uuid(00020404-0000-0000-C000-000000000046), + pointer_default(unique) +] +interface IEnumVARIANT : IUnknown +{ + typedef [unique] IEnumVARIANT *LPENUMVARIANT; + + [local] + HRESULT Next( + [in] ULONG celt, + [out] VARIANT *rgVar, + [out] ULONG *pCeltFetched); + + [call_as(Next)] + HRESULT RemoteNext( + [in] ULONG celt, + [out, size_is(celt), length_is(*pCeltFetched)] + VARIANT *rgVar, + [out] ULONG *pCeltFetched); + + HRESULT Skip( + [in] ULONG celt); + + HRESULT Reset(); + + HRESULT Clone( + [out] IEnumVARIANT **ppEnum); +} + +[ + object, + uuid(00020403-0000-0000-C000-000000000046), + pointer_default(unique) +] +interface ITypeComp : IUnknown +{ + typedef [unique] ITypeComp *LPTYPECOMP; + + typedef [v1_enum] enum tagDESCKIND { + DESCKIND_NONE = 0, + DESCKIND_FUNCDESC, + DESCKIND_VARDESC, + DESCKIND_TYPECOMP, + DESCKIND_IMPLICITAPPOBJ, + DESCKIND_MAX + } DESCKIND; + + typedef union tagBINDPTR { + FUNCDESC *lpfuncdesc; + VARDESC *lpvardesc; + ITypeComp *lptcomp; + } BINDPTR, *LPBINDPTR; + + [local] + HRESULT Bind( + [in] LPOLESTR szName, + [in] ULONG lHashVal, + [in] WORD wFlags, + [out] ITypeInfo **ppTInfo, + [out] DESCKIND *pDescKind, + [out] BINDPTR *pBindPtr); + + [call_as(Bind)] + HRESULT RemoteBind( + [in] LPOLESTR szName, + [in] ULONG lHashVal, + [in] WORD wFlags, + [out] ITypeInfo **ppTInfo, + [out] DESCKIND *pDescKind, + [out] LPFUNCDESC *ppFuncDesc, + [out] LPVARDESC *ppVarDesc, + [out] ITypeComp **ppTypeComp, + [out] CLEANLOCALSTORAGE *pDummy); + + [local] + HRESULT BindType( + [in] LPOLESTR szName, + [in] ULONG lHashVal, + [out] ITypeInfo **ppTInfo, + [out] ITypeComp **ppTComp); + + [call_as(BindType)] + HRESULT RemoteBindType( + [in] LPOLESTR szName, + [in] ULONG lHashVal, + [out] ITypeInfo **ppTInfo); +} + +[ + object, + uuid(00020401-0000-0000-C000-000000000046), + pointer_default(unique) +] +interface ITypeInfo : IUnknown +{ + typedef [unique] ITypeInfo *LPTYPEINFO; + + [local] + HRESULT GetTypeAttr( + [out] TYPEATTR **ppTypeAttr); + + [call_as(GetTypeAttr)] + HRESULT RemoteGetTypeAttr( + [out] LPTYPEATTR *ppTypeAttr, + [out] CLEANLOCALSTORAGE *pDummy); + + HRESULT GetTypeComp( + [out] ITypeComp **ppTComp); + + [local] + HRESULT GetFuncDesc( + [in] UINT index, + [out] FUNCDESC **ppFuncDesc); + + [call_as(GetFuncDesc)] + HRESULT RemoteGetFuncDesc( + [in] UINT index, + [out] LPFUNCDESC *ppFuncDesc, + [out] CLEANLOCALSTORAGE *pDummy); + + [local] + HRESULT GetVarDesc( + [in] UINT index, + [out] VARDESC **ppVarDesc); + + [call_as(GetVarDesc)] + HRESULT RemoteGetVarDesc( + [in] UINT index, + [out] LPVARDESC *ppVarDesc, + [out] CLEANLOCALSTORAGE *pDummy); + + [local] + HRESULT GetNames( + [in] MEMBERID memid, + [out, size_is(cMaxNames), length_is(*pcNames)] BSTR *rgBstrNames, + [in] UINT cMaxNames, + [out] UINT *pcNames); + + [call_as(GetNames)] + HRESULT RemoteGetNames( + [in] MEMBERID memid, + [out, size_is(cMaxNames), length_is(*pcNames)] BSTR *rgBstrNames, + [in] UINT cMaxNames, + [out] UINT *pcNames); + + HRESULT GetRefTypeOfImplType( + [in] UINT index, + [out] HREFTYPE *pRefType); + + HRESULT GetImplTypeFlags( + [in] UINT index, + [out] INT *pImplTypeFlags); + + [local] + HRESULT GetIDsOfNames( + [in, size_is(cNames)] LPOLESTR *rgszNames, + [in] UINT cNames, + [out, size_is(cNames)] MEMBERID *pMemId); + + [call_as(GetIDsOfNames)] + HRESULT LocalGetIDsOfNames(); + + [local] + HRESULT Invoke( + [in] PVOID pvInstance, + [in] MEMBERID memid, + [in] WORD wFlags, + [in, out] DISPPARAMS *pDispParams, + [out] VARIANT *pVarResult, + [out] EXCEPINFO *pExcepInfo, + [out] UINT *puArgErr); + + [call_as(Invoke)] + HRESULT LocalInvoke(); + + [local] + HRESULT GetDocumentation( + [in] MEMBERID memid, + [out] BSTR *pBstrName, + [out] BSTR *pBstrDocString, + [out] DWORD *pdwHelpContext, + [out] BSTR *pBstrHelpFile); + + [call_as(GetDocumentation)] + HRESULT RemoteGetDocumentation( + [in] MEMBERID memid, + [in] DWORD refPtrFlags, + [out] BSTR *pBstrName, + [out] BSTR *pBstrDocString, + [out] DWORD *pdwHelpContext, + [out] BSTR *pBstrHelpFile); + + [local] + HRESULT GetDllEntry( + [in] MEMBERID memid, + [in] INVOKEKIND invKind, + [out] BSTR *pBstrDllName, + [out] BSTR *pBstrName, + [out] WORD *pwOrdinal); + + [call_as(GetDllEntry)] + HRESULT RemoteGetDllEntry( + [in] MEMBERID memid, + [in] INVOKEKIND invKind, + [in] DWORD refPtrFlags, + [out] BSTR *pBstrDllName, + [out] BSTR *pBstrName, + [out] WORD *pwOrdinal); + + HRESULT GetRefTypeInfo( + [in] HREFTYPE hRefType, + [out] ITypeInfo **ppTInfo); + + [local] + HRESULT AddressOfMember( + [in] MEMBERID memid, + [in] INVOKEKIND invKind, + [out] PVOID *ppv); + + [call_as(AddressOfMember)] + HRESULT LocalAddressOfMember(); + + [local] + HRESULT CreateInstance( + [in] IUnknown *pUnkOuter, + [in] REFIID riid, + [out, iid_is(riid)] PVOID *ppvObj); + + [call_as(CreateInstance)] + HRESULT RemoteCreateInstance( + [in] REFIID riid, + [out, iid_is(riid)] IUnknown **ppvObj); + + HRESULT GetMops( + [in] MEMBERID memid, + [out] BSTR *pBstrMops); + + [local] + HRESULT GetContainingTypeLib( + [out] ITypeLib **ppTLib, + [out] UINT *pIndex); + + [call_as(GetContainingTypeLib)] + HRESULT RemoteGetContainingTypeLib( + [out] ITypeLib **ppTLib, + [out] UINT *pIndex); + + [local] + void ReleaseTypeAttr( + [in] TYPEATTR *pTypeAttr); + + [call_as(ReleaseTypeAttr)] + HRESULT LocalReleaseTypeAttr(); + + [local] + void ReleaseFuncDesc( + [in] FUNCDESC *pFuncDesc); + + [call_as(ReleaseFuncDesc)] + HRESULT LocalReleaseFuncDesc(); + + [local] + void ReleaseVarDesc( + [in] VARDESC *pVarDesc); + + [call_as(ReleaseVarDesc)] + HRESULT LocalReleaseVarDesc(); +} + +[ + object, + uuid(00020412-0000-0000-C000-000000000046), + pointer_default(unique) +] +interface ITypeInfo2 : ITypeInfo +{ + typedef [unique] ITypeInfo2 *LPTYPEINFO2; + + HRESULT GetTypeKind( + [out] TYPEKIND *pTypeKind); + + HRESULT GetTypeFlags( + [out] ULONG *pTypeFlags); + + HRESULT GetFuncIndexOfMemId( + [in] MEMBERID memid, + [in] INVOKEKIND invKind, + [out] UINT *pFuncIndex); + + HRESULT GetVarIndexOfMemId( + [in] MEMBERID memid, + [out] UINT *pVarIndex); + + HRESULT GetCustData( + [in] REFGUID guid, + [out] VARIANT *pVarVal); + + HRESULT GetFuncCustData( + [in] UINT index, + [in] REFGUID guid, + [out] VARIANT *pVarVal); + + HRESULT GetParamCustData( + [in] UINT indexFunc, + [in] UINT indexParam, + [in] REFGUID guid, + [out] VARIANT *pVarVal); + + HRESULT GetVarCustData( + [in] UINT index, + [in] REFGUID guid, + [out] VARIANT *pVarVal); + + HRESULT GetImplTypeCustData( + [in] UINT index, + [in] REFGUID guid, + [out] VARIANT *pVarVal); + + [local] + HRESULT GetDocumentation2( + [in] MEMBERID memid, + [in] LCID lcid, + [out] BSTR *pbstrHelpString, + [out] DWORD *pdwHelpStringContext, + [out] BSTR *pbstrHelpStringDll); + + [call_as(GetDocumentation2)] + HRESULT RemoteGetDocumentation2( + [in] MEMBERID memid, + [in] LCID lcid, + [in] DWORD refPtrFlags, + [out] BSTR *pbstrHelpString, + [out] DWORD *pdwHelpStringContext, + [out] BSTR *pbstrHelpStringDll); + + HRESULT GetAllCustData( + [out] CUSTDATA *pCustData); + + HRESULT GetAllFuncCustData( + [in] UINT index, + [out] CUSTDATA *pCustData); + + HRESULT GetAllParamCustData( + [in] UINT indexFunc, + [in] UINT indexParam, + [out] CUSTDATA *pCustData); + + HRESULT GetAllVarCustData( + [in] UINT index, + [out] CUSTDATA *pCustData); + + HRESULT GetAllImplTypeCustData( + [in] UINT index, + [out] CUSTDATA *pCustData); +} + +[ + object, + uuid(00020402-0000-0000-C000-000000000046), + pointer_default(unique) +] +interface ITypeLib : IUnknown +{ + typedef [unique] ITypeLib *LPTYPELIB; + + typedef [v1_enum] enum tagSYSKIND { + SYS_WIN16 = 0, + SYS_WIN32, + SYS_MAC + } SYSKIND; + + typedef [v1_enum] enum tagLIBFLAGS { + LIBFLAG_FRESTRICTED = 0x01, + LIBFLAG_FCONTROL = 0x02, + LIBFLAG_FHIDDEN = 0x04, + LIBFLAG_FHASDISKIMAGE = 0x08 + } LIBFLAGS; + + typedef struct tagTLIBATTR { + GUID guid; + LCID lcid; + SYSKIND syskind; + WORD wMajorVerNum; + WORD wMinorVerNum; + WORD wLibFlags; + } TLIBATTR, *LPTLIBATTR; + + [local] + UINT GetTypeInfoCount(); + + [call_as(GetTypeInfoCount)] + HRESULT RemoteGetTypeInfoCount( + [out] UINT *pcTInfo); + + HRESULT GetTypeInfo( + [in] UINT index, + [out] ITypeInfo **ppTInfo); + + HRESULT GetTypeInfoType( + [in] UINT index, + [out] TYPEKIND *pTKind); + + HRESULT GetTypeInfoOfGuid( + [in] REFGUID guid, + [out] ITypeInfo **ppTinfo); + + [local] + HRESULT GetLibAttr( + [out] TLIBATTR **ppTLibAttr); + + [call_as(GetLibAttr)] + HRESULT RemoteGetLibAttr( + [out] LPTLIBATTR *ppTLibAttr, + [out] CLEANLOCALSTORAGE *pDummy); + + HRESULT GetTypeComp( + [out] ITypeComp **ppTComp); + + [local] + HRESULT GetDocumentation( + [in] INT index, + [out] BSTR *pBstrName, + [out] BSTR *pBstrDocString, + [out] DWORD *pdwHelpContext, + [out] BSTR *pBstrHelpFile); + + [call_as(GetDocumentation)] + HRESULT RemoteGetDocumentation( + [in] INT index, + [in] DWORD refPtrFlags, + [out] BSTR *pBstrName, + [out] BSTR *pBstrDocString, + [out] DWORD *pdwHelpContext, + [out] BSTR *pBstrHelpFile); + + [local] + HRESULT IsName( + [in, out] LPOLESTR szNameBuf, + [in] ULONG lHashVal, + [out] BOOL *pfName); + + [call_as(IsName)] + HRESULT RemoteIsName( + [in] LPOLESTR szNameBuf, + [in] ULONG lHashVal, + [out] BOOL *pfName, + [out] BSTR *pBstrLibName); + + [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); + + [call_as(FindName)] + HRESULT RemoteFindName( + [in] 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, + [out] BSTR *pBstrLibName); + + [local] + void ReleaseTLibAttr( + [in] TLIBATTR *pTLibAttr); + + [call_as(ReleaseTLibAttr)] + HRESULT LocalReleaseTLibAttr(); +} + +[ + object, + uuid(00020411-0000-0000-C000-000000000046), + pointer_default(unique) +] +interface ITypeLib2 : ITypeLib +{ + typedef [unique] ITypeLib2 *LPTYPELIB2; + + HRESULT GetCustData( + [in] REFGUID guid, + [out] VARIANT *pVarVal); + + [local] + HRESULT GetLibStatistics( + [out] ULONG *pcUniqueNames, + [out] ULONG *pcchUniqueNames); + + [call_as(GetLibStatistics)] + HRESULT RemoteGetLibStatistics( + [out] ULONG *pcUniqueNames, + [out] ULONG *pcchUniqueNames); + + [local] + HRESULT GetDocumentation2( + [in] INT index, + [in] LCID lcid, + [out] BSTR *pbstrHelpString, + [out] DWORD *pdwHelpStringContext, + [out] BSTR *pbstrHelpStringDll); + + [call_as(GetDocumentation2)] + HRESULT RemoteGetDocumentation2( + [in] INT index, + [in] LCID lcid, + [in] DWORD refPtrFlags, + [out] BSTR *pbstrHelpString, + [out] DWORD *pdwHelpStringContext, + [out] BSTR *pbstrHelpStringDll); + + HRESULT GetAllCustData( + [out] CUSTDATA *pCustData); +} + +[ + local, + object, + uuid(00020410-0000-0000-C000-000000000046), + pointer_default(unique) +] +interface ITypeChangeEvents : IUnknown +{ + typedef [unique] ITypeChangeEvents *LPTYPECHANGEEVENTS; + + typedef enum tagCHANGEKIND { + CHANGEKIND_ADDMEMBER, + CHANGEKIND_DELETEMEMBER, + CHANGEKIND_SETNAMES, + CHANGEKIND_SETDOCUMENTATION, + CHANGEKIND_GENERAL, + CHANGEKIND_INVALIDATE, + CHANGEKIND_CHANGEFAILED, + CHANGEKIND_MAX + } CHANGEKIND; + + HRESULT RequestTypeChange( + [in] CHANGEKIND changeKind, + [in] ITypeInfo *pTInfoBefore, + [in] LPOLESTR pStrName, + [out] INT *pfCancel); + + HRESULT AfterTypeChange( + [in] CHANGEKIND changeKind, + [in] ITypeInfo *pTInfoAfter, + [in] LPOLESTR pStrName); +} + +[ + object, + uuid(1CF2B120-547D-101B-8E65-08002B2BD119), + pointer_default(unique) +] +interface IErrorInfo : IUnknown +{ + typedef [unique] IErrorInfo *LPERRORINFO; + + HRESULT GetGUID( + [out] GUID *pGUID); + + HRESULT GetSource( + [out] BSTR *pBstrSource); + + HRESULT GetDescription( + [out] BSTR *pBstrDescription); + + HRESULT GetHelpFile( + [out] BSTR *pBstrHelpFile); + + HRESULT GetHelpContext( + [out] DWORD *pdwHelpContext); +} + +[ + object, + uuid(22F03340-547D-101B-8E65-08002B2BD119), + pointer_default(unique) +] +interface ICreateErrorInfo : IUnknown +{ + typedef [unique] ICreateErrorInfo *LPCREATEERRORINFO; + + HRESULT SetGUID( + [in] REFGUID rguid); + + HRESULT SetSource( + [in] LPOLESTR szSource); + + HRESULT SetDescription( + [in] LPOLESTR szDescription); + + HRESULT SetHelpFile( + [in] LPOLESTR szHelpFile); + + HRESULT SetHelpContext( + [in] DWORD dwHelpContext); +} + +[ + object, + uuid(DF0B3D60-548F-101B-8E65-08002B2BD119), + pointer_default(unique) +] +interface ISupportErrorInfo : IUnknown +{ + typedef [unique] ISupportErrorInfo *LPSUPPORTERRORINFO; + + HRESULT InterfaceSupportsErrorInfo( + [in] REFIID riid); +} + +[ + object, + uuid(0000002E-0000-0000-C000-000000000046) +] +interface ITypeFactory : IUnknown +{ + HRESULT CreateFromTypeInfo( + [in] ITypeInfo *pTypeInfo, + [in] REFIID riid, + [out, iid_is(riid)] IUnknown **ppv); +} + +[ + local, + object, + uuid(0000002D-0000-0000-C000-000000000046) +] +interface ITypeMarshal : IUnknown +{ + HRESULT Size( + [in] PVOID pvType, + [in] DWORD dwDestContext, + [in] PVOID pvDestContext, + [out] ULONG *pSize); + + HRESULT Marshal( + [in] PVOID pvType, + [in] DWORD dwDestContext, + [in] PVOID pvDestContext, + [in] ULONG cbBufferLength, + [out] BYTE *pBuffer, + [out] ULONG *pcbWritten); + + HRESULT Unmarshal( + [out] PVOID pvType, + [in] DWORD dwFlags, + [in] ULONG cbBufferLength, + [in] BYTE *pBuffer, + [out] ULONG *pcbRead); + + HRESULT Free( + [in] PVOID pvType); +} + +[ + local, + object, + uuid(0000002F-0000-0000-C000-000000000046) +] +interface IRecordInfo : IUnknown +{ + typedef [unique] IRecordInfo *LPRECORDINFO; + + HRESULT RecordInit( + [out] PVOID pvNew); + + HRESULT RecordClear( + [in] PVOID pvExisting); + + HRESULT RecordCopy( + [in] PVOID pvExisting, + [out] PVOID pvNew); + + HRESULT GetGuid( + [out] GUID *pguid); + + HRESULT GetName( + [out] BSTR *pbstrName); + + HRESULT GetSize( + [out] ULONG *pcbSize); + + HRESULT GetTypeInfo( + [out] ITypeInfo **ppTypeInfo); + + HRESULT GetField( + [in] PVOID pvData, + [in] LPCOLESTR szFieldName, + [out] VARIANT *pvarField); + + HRESULT GetFieldNoCopy( + [in] PVOID pvData, + [in] LPCOLESTR szFieldName, + [out] VARIANT *pvarField, + [out] PVOID *ppvDataCArray); + + HRESULT PutField( + [in] ULONG wFlags, + [in, out] PVOID pvData, + [in] LPCOLESTR szFieldName, + [in] VARIANT *pvarField); + + HRESULT PutFieldNoCopy( + [in] ULONG wFlags, + [in, out] PVOID pvData, + [in] LPCOLESTR szFieldName, + [in] VARIANT *pvarField); + + HRESULT GetFieldNames( + [in, out] ULONG *pcNames, + [out, size_is(*pcNames), length_is(*pcNames)] BSTR *rgBstrNames); + + BOOL IsMatchingType( + [in] IRecordInfo *pRecordInfo); + + PVOID RecordCreate(); + + HRESULT RecordCreateCopy( + [in] PVOID pvSource, + [out] PVOID *ppvDest); + + HRESULT RecordDestroy( + [in] PVOID pvRecord); +} + +[ + local, + object, + uuid(00020405-0000-0000-C000-000000000046), + pointer_default(unique) +] +interface ICreateTypeInfo : IUnknown +{ + typedef [unique] ICreateTypeInfo *LPCREATETYPEINFO; + + HRESULT SetGuid( + [in] REFGUID guid); + + HRESULT SetTypeFlags( + [in] UINT uTypeFlags); + + HRESULT SetDocString( + [in] LPOLESTR pStrDoc); + + HRESULT SetHelpContext( + [in] DWORD dwHelpContext); + + HRESULT SetVersion( + [in] WORD wMajorVerNum, + [in] WORD wMinorVerNum); + + HRESULT AddRefTypeInfo( + [in] ITypeInfo *pTInfo, + [in] HREFTYPE *phRefType); + + HRESULT AddFuncDesc( + [in] UINT index, + [in] FUNCDESC *pFuncDesc); + + HRESULT AddImplType( + [in] UINT index, + [in] HREFTYPE hRefType); + + HRESULT SetImplTypeFlags( + [in] UINT index, + [in] INT implTypeFlags); + + HRESULT SetAlignment( + [in] WORD cbAlignment); + + HRESULT SetSchema( + [in] LPOLESTR pStrSchema); + + HRESULT AddVarDesc( + [in] UINT index, + [in] VARDESC *pVarDesc); + + HRESULT SetFuncAndParamNames( + [in] UINT index, + [in, size_is(cNames)] LPOLESTR *rgszNames, + [in] UINT cNames); + + HRESULT SetVarName( + [in] UINT index, + [in] LPOLESTR szName); + + HRESULT SetTypeDescAlias( + [in] TYPEDESC *pTDescAlias); + + HRESULT DefineFuncAsDllEntry( + [in] UINT index, + [in] LPOLESTR szDllName, + [in] LPOLESTR szProcName); + + HRESULT SetFuncDocString( + [in] UINT index, + [in] LPOLESTR szDocString); + + HRESULT SetVarDocString( + [in] UINT index, + [in] LPOLESTR szDocString); + + HRESULT SetFuncHelpContext( + [in] UINT index, + [in] DWORD dwHelpContext); + + HRESULT SetVarHelpContext( + [in] UINT index, + [in] DWORD dwHelpContext); + + HRESULT SetMops( + [in] UINT index, + [in] BSTR bstrMops); + + HRESULT SetTypeIdldesc( + [in] IDLDESC * pIdlDesc); + + HRESULT LayOut(); +} + +[ + local, + object, + uuid(0002040E-0000-0000-C000-000000000046), + pointer_default(unique) +] +interface ICreateTypeInfo2 : ICreateTypeInfo +{ + typedef [unique] ICreateTypeInfo2 *LPCREATETYPEINFO2; + + HRESULT DeleteFuncDesc( + [in] UINT index); + + HRESULT DeleteFuncDescByMemId( + [in] MEMBERID memid, + [in] INVOKEKIND invKind); + + HRESULT DeleteVarDesc( + [in] UINT index); + + HRESULT DeleteVarDescByMemId( + [in] MEMBERID memid); + + HRESULT DeleteImplType( + [in] UINT index); + + HRESULT SetCustData( + [in] REFGUID guid, + [in] VARIANT *pVarVal); + + HRESULT SetFuncCustData( + [in] UINT index, + [in] REFGUID guid, + [in] VARIANT *pVarVal); + + HRESULT SetParamCustData( + [in] UINT indexFunc, + [in] UINT indexParam, + [in] REFGUID guid, + [in] VARIANT *pVarVal); + + HRESULT SetVarCustData( + [in] UINT index, + [in] REFGUID guid, + [in] VARIANT *pVarVal); + + HRESULT SetImplTypeCustData( + [in] UINT index, + [in] REFGUID guid, + [in] VARIANT *pVarVal); + + HRESULT SetHelpStringContext( + [in] ULONG dwHelpStringContext); + + HRESULT SetFuncHelpStringContext( + [in] UINT index, + [in] ULONG dwHelpStringContext); + + HRESULT SetVarHelpStringContext( + [in] UINT index, + [in] ULONG dwHelpStringContext); + + HRESULT Invalidate(); + + HRESULT SetName( + [in] LPOLESTR szName); +} + +[ + local, + object, + uuid(00020406-0000-0000-C000-000000000046), + pointer_default(unique) +] +interface ICreateTypeLib : IUnknown +{ + typedef [unique] ICreateTypeLib *LPCREATETYPELIB; + + HRESULT CreateTypeInfo( + [in] LPOLESTR szName, + [in] TYPEKIND tkind, + [out] ICreateTypeInfo **ppCTInfo); + + HRESULT SetName( + [in] LPOLESTR szName); + + HRESULT SetVersion( + [in] WORD wMajorVerNum, + [in] WORD wMinorVerNum); + + HRESULT SetGuid( + [in] REFGUID guid); + + HRESULT SetDocString( + [in] LPOLESTR szDoc); + + HRESULT SetHelpFileName( + [in] LPOLESTR szHelpFileName); + + HRESULT SetHelpContext( + [in] DWORD dwHelpContext); + + HRESULT SetLcid( + [in] LCID lcid); + + HRESULT SetLibFlags( + [in] UINT uLibFlags); + + HRESULT SaveAllChanges(); +} + +[ + local, + object, + uuid(0002040F-0000-0000-C000-000000000046), + pointer_default(unique) +] +interface ICreateTypeLib2 : ICreateTypeLib +{ + typedef [unique] ICreateTypeLib2 *LPCREATETYPELIB2; + + HRESULT DeleteTypeInfo( + [in] LPOLESTR szName); + + HRESULT SetCustData( + [in] REFGUID guid, + [in] VARIANT *pVarVal); + + HRESULT SetHelpStringContext( + [in] ULONG dwHelpStringContext); + + HRESULT SetHelpStringDll( + [in] LPOLESTR szFileName); +} diff --git a/include/wine/obj_errorinfo.h b/include/wine/obj_errorinfo.h deleted file mode 100644 index efc37e94fca..00000000000 --- a/include/wine/obj_errorinfo.h +++ /dev/null @@ -1,110 +0,0 @@ -/* - * Defines the COM interfaces and APIs related to ErrorInfo - * - * Copyright (C) 2000 Juergen Schmied - * - * 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 - */ - -#ifndef __WINE_WINE_OBJ_ERRORINFO_H -#define __WINE_WINE_OBJ_ERRORINFO_H - -DEFINE_GUID(IID_IErrorInfo,0x1CF2B120,0x547D,0x101B,0x8E,0x65,0x08,0x00,0x2B,0x2B,0xD1,0x19); -typedef struct IErrorInfo IErrorInfo,*LPERRORINFO; - -DEFINE_GUID(IID_ICreateErrorInfo,0x22F03340,0x547D,0x101B,0x8E,0x65,0x08,0x00,0x2B,0x2B,0xD1,0x19); -typedef struct ICreateErrorInfo ICreateErrorInfo,*LPCREATEERRORINFO; - -DEFINE_GUID(IID_ISupportErrorInfo,0xDF0B3D60,0x547D,0x101B,0x8E,0x65,0x08,0x00,0x2B,0x2B,0xD1,0x19); -typedef struct ISupportErrorInfo ISupportErrorInfo,*LPSUPPORTERRORINFO; - -/***************************************************************************** - * IErrorInfo - */ -#define ICOM_INTERFACE IErrorInfo -#define IErrorInfo_METHODS \ - ICOM_METHOD1(HRESULT, GetGUID, GUID * , pGUID) \ - ICOM_METHOD1(HRESULT, GetSource, BSTR* ,pBstrSource) \ - ICOM_METHOD1(HRESULT, GetDescription, BSTR*, pBstrDescription) \ - ICOM_METHOD1(HRESULT, GetHelpFile, BSTR*, pBstrHelpFile) \ - ICOM_METHOD1(HRESULT, GetHelpContext, DWORD*, pdwHelpContext) - -#define IErrorInfo_IMETHODS \ - IUnknown_IMETHODS \ - IErrorInfo_METHODS -ICOM_DEFINE(IErrorInfo, IUnknown) -#undef ICOM_INTERFACE - -/*** IUnknown methods ***/ -#define IErrorInfo_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b) -#define IErrorInfo_AddRef(p) ICOM_CALL (AddRef,p) -#define IErrorInfo_Release(p) ICOM_CALL (Release,p) -/*** IErrorInfo methods ***/ -#define IErrorInfo_GetGUID(p,a) ICOM_CALL1 (GetGUID,p,a) -#define IErrorInfo_GetSource(p,a) ICOM_CALL1 (GetSource,p,a) -#define IErrorInfo_GetDescription(p,a) ICOM_CALL1 (GetDescription,p,a) -#define IErrorInfo_GetHelpFile(p,a) ICOM_CALL1 (GetHelpFile,p,a) -#define IErrorInfo_GetHelpContext(p,a) ICOM_CALL1 (GetHelpContext,p,a) - -/***************************************************************************** - * ICreateErrorInfo - */ -#define ICOM_INTERFACE ICreateErrorInfo -#define ICreateErrorInfo_METHODS \ - ICOM_METHOD1(HRESULT, SetGUID, REFGUID, rguid) \ - ICOM_METHOD1(HRESULT, SetSource, LPOLESTR, szSource) \ - ICOM_METHOD1(HRESULT, SetDescription, LPOLESTR, szDescription) \ - ICOM_METHOD1(HRESULT, SetHelpFile, LPOLESTR, szHelpFile) \ - ICOM_METHOD1(HRESULT, SetHelpContext, DWORD, dwHelpContext) - -#define ICreateErrorInfo_IMETHODS \ - IUnknown_IMETHODS \ - ICreateErrorInfo_METHODS -ICOM_DEFINE(ICreateErrorInfo, IUnknown) -#undef ICOM_INTERFACE - -/*** IUnknown methods ***/ -#define ICreateErrorInfo_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b) -#define ICreateErrorInfo_AddRef(p) ICOM_CALL (AddRef,p) -#define ICreateErrorInfo_Release(p) ICOM_CALL (Release,p) -/*** ICreateErrorInfo methods ***/ -#define ICreateErrorInfo_SetGUID(p,a) ICOM_CALL1 (SetGUID,p,a) -#define ICreateErrorInfo_SetSource(p,a) ICOM_CALL1 (SetSource,p,a) -#define ICreateErrorInfo_SetDescription(p,a) ICOM_CALL1 (SetDescription,p,a) -#define ICreateErrorInfo_SetHelpFile(p,a) ICOM_CALL1 (SetHelpFile,p,a) -#define ICreateErrorInfo_SetHelpContext(p,a) ICOM_CALL1 (SetHelpContext,p,a) - -/***************************************************************************** - * ISupportErrorInfo - */ -#define ICOM_INTERFACE ISupportErrorInfo -#define ISupportErrorInfo_METHODS \ - ICOM_METHOD1(HRESULT, InterfaceSupportsErrorInfo, REFIID, riid ) - -#define ISupportErrorInfo_IMETHODS \ - IUnknown_IMETHODS \ - ISupportErrorInfo_METHODS -ICOM_DEFINE(ISupportErrorInfo, IUnknown) -#undef ICOM_INTERFACE - -/*** IUnknown methods ***/ -#define ISupportErrorInfo_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b) -#define ISupportErrorInfo_AddRef(p) ICOM_CALL (AddRef,p) -#define ISupportErrorInfo_Release(p) ICOM_CALL (Release,p) -/*** ISupportErrorInfo methods ***/ -#define ISupportErrorInfo_InterfaceSupportsErrorInfo(p,a) ICOM_CALL1 (InterfaceSupportsErrorInfo,p,a) - - -#endif /* __WINE_WINE_OBJ_ERRORINFO_H */ diff --git a/include/wine/obj_oleaut.h b/include/wine/obj_oleaut.h deleted file mode 100644 index ff3a82728ae..00000000000 --- a/include/wine/obj_oleaut.h +++ /dev/null @@ -1,846 +0,0 @@ -/* - * Defines the COM interfaces and APIs related to OLE automation support. - * - * Copyright (C) the Wine project - * - * 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 - */ - -#ifndef __WINE_WINE_OBJ_OLEAUT_H -#define __WINE_WINE_OBJ_OLEAUT_H - -/***************************************************************************** - * Predeclare the interfaces - */ -DEFINE_OLEGUID(IID_IDispatch, 0x00020400,0,0); -typedef struct IDispatch IDispatch,*LPDISPATCH; - -DEFINE_OLEGUID(IID_ITypeInfo, 0x00020401,0,0); -typedef struct ITypeInfo ITypeInfo,*LPTYPEINFO; - -DEFINE_OLEGUID(IID_IRecordInfo, 0x0000002f,0,0); -typedef struct IRecordInfo IRecordInfo,*LPRECORDINFO; - -DEFINE_OLEGUID(IID_ITypeLib, 0x00020402,0,0); -typedef struct ITypeLib ITypeLib,*LPTYPELIB; - -DEFINE_OLEGUID(IID_ITypeComp, 0x00020403,0,0); -typedef struct ITypeComp ITypeComp,*LPTYPECOMP; - -DEFINE_OLEGUID(IID_IEnumVARIANT, 0x00020404,0,0); -typedef struct IEnumVARIANT IEnumVARIANT,*LPENUMVARIANT; - -DEFINE_OLEGUID(IID_ICreateTypeInfo, 0x00020405,0,0); -typedef struct ICreateTypeInfo ICreateTypeInfo,*LPCREATETYPEINFO; - -DEFINE_OLEGUID(IID_ICreateTypeLib, 0x00020406,0,0); -typedef struct ICreateTypeLib ICreateTypeLib,*LPCREATETYPELIB; - -DEFINE_OLEGUID(IID_ICreateTypeInfo2,0x0002040E,0,0); -typedef struct ICreateTypeInfo2 ICreateTypeInfo2,*LPCREATETYPEINFO2; - -DEFINE_OLEGUID(IID_ICreateTypeLib2, 0x0002040F,0,0); -typedef struct ICreateTypeLib2 ICreateTypeLib2,*LPCREATETYPELIB2; - -DEFINE_OLEGUID(IID_ITypeChangeEvents,0x00020410,0,0); -typedef struct ITypeChangeEvents ITypeChangeEvents,*LPTYPECHANGEEVENTS; - -DEFINE_OLEGUID(IID_ITypeLib2, 0x00020411,0,0); -typedef struct ITypeLib2 ITypeLib2,*LPTYPELIB2; - -DEFINE_OLEGUID(IID_ITypeInfo2, 0x00020412,0,0); -typedef struct ITypeInfo2 ITypeInfo2,*LPTYPEINFO2; - -/* The OLE Automation ProxyStub Interface Class (aka Typelib Marshaler) */ -DEFINE_OLEGUID(CLSID_PSOAInterface, 0x00020424,0,0); - -/***************************************************************************** - * Automation data types - */ - -/***************************************************************** - * SafeArray defines and structs - */ - -#define FADF_AUTO ( 0x1 ) -#define FADF_STATIC ( 0x2 ) -#define FADF_EMBEDDED ( 0x4 ) -#define FADF_FIXEDSIZE ( 0x10 ) -#define FADF_RECORD ( 0x20 ) -#define FADF_HAVEIID ( 0x40 ) -#define FADF_HAVEVARTYPE ( 0x80 ) -#define FADF_BSTR ( 0x100 ) -#define FADF_UNKNOWN ( 0x200 ) -#define FADF_DISPATCH ( 0x400 ) -#define FADF_VARIANT ( 0x800 ) -#define FADF_RESERVED ( 0xf008 ) - -/* Undocumented flags */ -#define FADF_CREATEVECTOR ( 0x2000 ) /* set when the safe array is created using SafeArrayCreateVector */ - - -typedef struct tagSAFEARRAYBOUND -{ - ULONG cElements; /* Number of elements in dimension */ - LONG lLbound; /* Lower bound of dimension */ -} SAFEARRAYBOUND; - -typedef struct tagSAFEARRAY -{ - USHORT cDims; /* Count of array dimension */ - USHORT fFeatures; /* Flags describing the array */ - ULONG cbElements; /* Size of each element */ - ULONG cLocks; /* Number of lock on array */ - PVOID pvData; /* Pointer to data valid when cLocks > 0 */ - SAFEARRAYBOUND rgsabound[ 1 ]; /* One bound for each dimension */ -} SAFEARRAY, *LPSAFEARRAY; - -typedef enum tagCALLCONV { - CC_CDECL = 1, - CC_MSCPASCAL = CC_CDECL + 1, - CC_PASCAL = CC_MSCPASCAL, - CC_MACPASCAL = CC_PASCAL + 1, - CC_STDCALL = CC_MACPASCAL + 1, - CC_RESERVED = CC_STDCALL + 1, - CC_SYSCALL = CC_RESERVED + 1, - CC_MPWCDECL = CC_SYSCALL + 1, - CC_MPWPASCAL = CC_MPWCDECL + 1, - CC_MAX = CC_MPWPASCAL + 1 -} CALLCONV; - -typedef CY CURRENCY; - -/* - * Declarations of the VARIANT structure and the VARIANT APIs. - */ -/* S_OK : Success. - * DISP_E_BADVARTYPE : The variant type vt in not a valid type of variant. - * DISP_E_OVERFLOW : The data pointed to by pvarSrc does not fit in the destination type. - * DISP_E_TYPEMISMATCH : The variant type vt is not a valid type of variant. - * E_INVALIDARG : One argument is invalid. - * * E_OUTOFMEMORY : Memory could not be allocated for the conversion. - * DISP_E_ARRAYISLOCKED : The variant contains an array that is locked. - */ -#if (__STDC__ && !defined(_FORCENAMELESSUNION)) || defined(NONAMELESSUNION) -#define __VARIANT_NAME_1 n1 -#define __VARIANT_NAME_2 n2 -#define __VARIANT_NAME_3 n3 -#else -#define __tagVARIANT -#define __VARIANT_NAME_1 -#define __VARIANT_NAME_2 -#define __VARIANT_NAME_3 -#endif - -typedef struct tagVARIANT VARIANT, *LPVARIANT; -typedef struct tagVARIANT VARIANTARG, *LPVARIANTARG; - -struct tagVARIANT -{ - union - { - struct __tagVARIANT - { - VARTYPE vt; - WORD wReserved1; - WORD wReserved2; - WORD wReserved3; - union /* DUMMYUNIONNAME */ - { - /* By value. */ - CHAR cVal; - USHORT uiVal; - ULONG ulVal; - INT intVal; - UINT uintVal; - BYTE bVal; - short iVal; - long lVal; - float fltVal; - double dblVal; - VARIANT_BOOL boolVal; - SCODE scode; - DATE date; - BSTR bstrVal; - CY cyVal; - IUnknown* punkVal; - IDispatch* pdispVal; - SAFEARRAY* parray; - - /* By reference */ - CHAR* pcVal; - USHORT* puiVal; - ULONG* pulVal; - INT* pintVal; - UINT* puintVal; - BYTE* pbVal; - short* piVal; - long* plVal; - float* pfltVal; - double* pdblVal; - VARIANT_BOOL* pboolVal; - SCODE* pscode; - DATE* pdate; - BSTR* pbstrVal; - VARIANT* pvarVal; - PVOID byref; - CY* pcyVal; - DECIMAL* pdecVal; - IUnknown** ppunkVal; - IDispatch** ppdispVal; - SAFEARRAY** pparray; - } __VARIANT_NAME_3; - } __VARIANT_NAME_2; - DECIMAL decVal; - } __VARIANT_NAME_1; -}; - - -typedef LONG DISPID; -typedef DWORD HREFTYPE; -typedef DISPID MEMBERID; - -#define DISPID_UNKNOWN ( -1 ) -#define DISPID_VALUE ( 0 ) -#define DISPID_PROPERTYPUT ( -3 ) -#define DISPID_NEWENUM ( -4 ) -#define DISPID_EVALUATE ( -5 ) -#define DISPID_CONSTRUCTOR ( -6 ) -#define DISPID_DESTRUCTOR ( -7 ) -#define DISPID_COLLECT ( -8 ) - -#define IMPLTYPEFLAG_FDEFAULT (0x1) -#define IMPLTYPEFLAG_FSOURCE (0x2) -#define IMPLTYPEFLAG_FRESTRICTED (0x4) -#define IMPLTYPEFLAG_FDEFAULTVTABLE (0x8) - -typedef struct tagDISPPARAMS -{ - VARIANTARG* rgvarg; - DISPID* rgdispidNamedArgs; - UINT cArgs; - UINT cNamedArgs; -} DISPPARAMS; - -typedef struct tagEXCEPINFO -{ - WORD wCode; - WORD wReserved; - BSTR bstrSource; - BSTR bstrDescription; - BSTR bstrHelpFile; - DWORD dwHelpContext; - PVOID pvReserved; - HRESULT (__stdcall *pfnDeferredFillIn)(struct tagEXCEPINFO *); - SCODE scode; -} EXCEPINFO, * LPEXCEPINFO; - -typedef struct tagIDLDESC -{ - ULONG dwReserved; - USHORT wIDLFlags; -} IDLDESC; - -typedef struct tagPARAMDESCEX -{ - ULONG cBytes; - VARIANTARG varDefaultValue; -} PARAMDESCEX, *LPPARAMDESCEX; - -typedef struct tagPARAMDESC -{ - LPPARAMDESCEX pparamdescex; - USHORT wParamFlags; -} PARAMDESC; - -#define PARAMFLAG_NONE (0x00) -#define PARAMFLAG_FIN (0x01) -#define PARAMFLAG_FOUT (0x02) -#define PARAMFLAG_FLCID (0x04) -#define PARAMFLAG_FRETVAL (0x08) -#define PARAMFLAG_FOPT (0x10) -#define PARAMFLAG_FHASDEFAULT (0x20) -#define PARAMFLAG_FHASCUSTDATA (0x40) - -typedef struct tagTYPEDESC -{ - union { - struct tagTYPEDESC *lptdesc; - struct tagARRAYDESC *lpadesc; - HREFTYPE hreftype; - } DUMMYUNIONNAME; - VARTYPE vt; -} TYPEDESC; - -typedef struct tagELEMDESC -{ - TYPEDESC tdesc; - union { - IDLDESC idldesc; - PARAMDESC paramdesc; - } DUMMYUNIONNAME; -} ELEMDESC, *LPELEMDESC; - -typedef enum tagTYPEKIND -{ - TKIND_ENUM = 0, - TKIND_RECORD = 1, - TKIND_MODULE = 2, - TKIND_INTERFACE = 3, - TKIND_DISPATCH = 4, - TKIND_COCLASS = 5, - TKIND_ALIAS = 6, - TKIND_UNION = 7, - TKIND_MAX = 8 -} TYPEKIND; - -typedef struct tagTYPEATTR -{ - GUID guid; - LCID lcid; - DWORD dwReserved; - MEMBERID memidConstructor; - MEMBERID memidDestructor; - LPOLESTR lpstrSchema; - ULONG cbSizeInstance; - TYPEKIND typekind; - WORD cFuncs; - WORD cVars; - WORD cImplTypes; - WORD cbSizeVft; - WORD cbAlignment; - WORD wTypeFlags; - WORD wMajorVerNum; - WORD wMinorVerNum; - TYPEDESC tdescAlias; - IDLDESC idldescType; -} TYPEATTR, *LPTYPEATTR; - -typedef enum tagTYPEFLAGS { - TYPEFLAG_FAPPOBJECT = 0x01, - TYPEFLAG_FCANCREATE = 0x02, - TYPEFLAG_FLICENSED = 0x04, - TYPEFLAG_FPREDECLID = 0x08, - TYPEFLAG_FHIDDEN = 0x10, - TYPEFLAG_FCONTROL = 0x20, - TYPEFLAG_FDUAL = 0x40, - TYPEFLAG_FNONEXTENSIBLE = 0x80, - TYPEFLAG_FOLEAUTOMATION = 0x100, - TYPEFLAG_FRESTRICTED = 0x200, - TYPEFLAG_FAGGREGATABLE = 0x400, - TYPEFLAG_FREPLACEABLE = 0x800, - TYPEFLAG_FDISPATCHABLE = 0x1000, - TYPEFLAG_FREVERSEBIND = 0x2000, - TYPEFLAG_FPROXY = 0x4000 -} TYPEFLAGS; - -typedef struct tagARRAYDESC -{ - TYPEDESC tdescElem; - USHORT cDims; - SAFEARRAYBOUND rgbounds[1]; -} ARRAYDESC; - -typedef enum tagFUNCKIND -{ - FUNC_VIRTUAL = 0, - FUNC_PUREVIRTUAL = 1, - FUNC_NONVIRTUAL = 2, - FUNC_STATIC = 3, - FUNC_DISPATCH = 4 -} FUNCKIND; - -typedef enum tagFUNCFLAGS -{ - FUNCFLAG_FRESTRICTED = 0x1, - FUNCFLAG_FSOURCE = 0x2, - FUNCFLAG_FBINDABLE = 0x4, - FUNCFLAG_FREQUESTEDIT = 0x8, - FUNCFLAG_FDISPLAYBIND = 0x10, - FUNCFLAG_FDEFAULTBIND = 0x20, - FUNCFLAG_FHIDDEN = 0x40, - FUNCFLAG_FUSESGETLASTERROR = 0x80, - FUNCFLAG_FDEFAULTCOLLELEM = 0x100, - FUNCFLAG_FUIDEFAULT = 0x200, - FUNCFLAG_FNONBROWSABLE = 0x400, - FUNCFLAG_FREPLACEABLE = 0x800, - FUNCFLAG_FIMMEDIATEBIND = 0x1000 -} FUNCFLAGS; - -typedef enum tagINVOKEKIND -{ - INVOKE_FUNC = 1, - INVOKE_PROPERTYGET = 2, - INVOKE_PROPERTYPUT = 4, - INVOKE_PROPERTYPUTREF = 8 -} INVOKEKIND; - -typedef struct tagFUNCDESC -{ - MEMBERID memid; - SCODE *lprgscode; - ELEMDESC *lprgelemdescParam; - FUNCKIND funckind; - INVOKEKIND invkind; - CALLCONV callconv; - SHORT cParams; - SHORT cParamsOpt; - SHORT oVft; - SHORT cScodes; - ELEMDESC elemdescFunc; - WORD wFuncFlags; -} FUNCDESC, *LPFUNCDESC; - -typedef enum tagVARKIND -{ - VAR_PERINSTANCE = 0, - VAR_STATIC = 1, - VAR_CONST = 2, - VAR_DISPATCH = 3 -} VARKIND; - -typedef struct tagVARDESC -{ - MEMBERID memid; - LPOLESTR lpstrSchema; - union { - ULONG oInst; - VARIANT *lpvarValue; - } DUMMYUNIONNAME; - ELEMDESC elemdescVar; - WORD wVarFlags; - VARKIND varkind; -} VARDESC, *LPVARDESC; - -typedef enum tagSYSKIND -{ - SYS_WIN16 = 0, - SYS_WIN32 = 1, - SYS_MAC = 2 -} SYSKIND; - -typedef enum tagLIBFLAGS -{ - LIBFLAG_FRESTRICTED = 0x1, - LIBFLAG_FCONTROL = 0x2, - LIBFLAG_FHIDDEN = 0x4, - LIBFLAG_FHASDISKIMAGE = 0x8 -} LIBFLAGS; - -typedef struct tagTLIBATTR -{ - GUID guid; - LCID lcid; - SYSKIND syskind; - WORD wMajorVerNum; - WORD wMinorVerNum; - WORD wLibFlags; -} TLIBATTR, *LPTLIBATTR; - -typedef enum tagDESCKIND -{ - DESCKIND_NONE = 0, - DESCKIND_FUNCDESC = 1, - DESCKIND_VARDESC = 2, - DESCKIND_TYPECOMP = 3, - DESCKIND_IMPLICITAPPOBJ = 4, - DESCKIND_MAX = 5 -} DESCKIND; - -typedef union tagBINDPTR -{ - FUNCDESC *lpfuncdesc; - VARDESC *lpvardesc; - ITypeComp *lptcomp; -} BINDPTR, *LPBINDPTR; - -typedef enum tagVARFLAGS -{ - VARFLAG_FREADONLY = 0x1, - VARFLAG_FSOURCE = 0x2, - VARFLAG_FBINDABLE = 0x4, - VARFLAG_FREQUESTEDIT = 0x8, - VARFLAG_FDISPLAYBIND = 0x10, - VARFLAG_FDEFAULTBIND = 0x20, - VARFLAG_FHIDDEN = 0x40, - VARFLAG_FRESTRICTED = 0x80, - VARFLAG_FDEFAULTCOLLELEM = 0x100, - VARFLAG_FUIDEFAULT = 0x200, - VARFLAG_FNONBROWSABLE = 0x400, - VARFLAG_FREPLACEABLE = 0x800, - VARFLAG_FIMMEDIATEBIND = 0x1000 -} VARFLAGS; - - -/* - * Declarations of the VARIANT structure and the VARIANT APIs. - */ - -/* S_OK : Success. - * DISP_E_BADVARTYPE : The variant type vt in not a valid type of variant. - * DISP_E_OVERFLOW : The data pointed to by pvarSrc does not fit in the destination type. - * DISP_E_TYPEMISMATCH : The variant type vt is not a valid type of variant. - * E_INVALIDARG : One argument is invalid. - * E_OUTOFMEMORY : Memory could not be allocated for the conversion. - * DISP_E_ARRAYISLOCKED : The variant contains an array that is locked. - */ - - -typedef struct tagCUSTDATAITEM { - GUID guid; - VARIANTARG varValue; -} CUSTDATAITEM, *LPCUSTDATAITEM; - -typedef struct tagCUSTDATA { - INT cCustData; - LPCUSTDATAITEM prgCustData; /* count cCustdata */ -} CUSTDATA, *LPCUSTDATA; - - - -/***************************************************************************** - * IDispatch interface - */ -#define ICOM_INTERFACE IDispatch -#define IDispatch_METHODS \ - ICOM_METHOD1(HRESULT, GetTypeInfoCount, UINT*, pctinfo) \ - ICOM_METHOD3(HRESULT, GetTypeInfo, UINT, iTInfo, LCID, lcid, ITypeInfo**, ppTInfo) \ - ICOM_METHOD5(HRESULT, GetIDsOfNames, REFIID, riid, LPOLESTR*, rgszNames, UINT, cNames, LCID, lcid, DISPID*, rgDispId) \ - ICOM_METHOD8(HRESULT, Invoke, DISPID, dispIdMember, REFIID, riid, LCID, lcid, WORD, wFlags, DISPPARAMS*, pDispParams, VARIANT*, pVarResult, EXCEPINFO*, pExepInfo, UINT*, puArgErr) -#define IDispatch_IMETHODS \ - IUnknown_IMETHODS \ - IDispatch_METHODS -ICOM_DEFINE(IDispatch,IUnknown) -#undef ICOM_INTERFACE - -/*** IUnknown methods ***/ -#define IDispatch_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b) -#define IDispatch_AddRef(p) ICOM_CALL (AddRef,p) -#define IDispatch_Release(p) ICOM_CALL (Release,p) -/*** IDispatch methods ***/ -#define IDispatch_GetTypeInfoCount(p,a) ICOM_CALL1 (GetTypeInfoCount,p,a) -#define IDispatch_GetTypeInfo(p,a,b,c) ICOM_CALL3 (GetTypeInfo,p,a,b,c) -#define IDispatch_GetIDsOfNames(p,a,b,c,d,e) ICOM_CALL5 (GetIDsOfNames,p,a,b,c,d,e) -#define IDispatch_Invoke(p,a,b,c,d,e,f,g,h) ICOM_CALL8 (Invoke,p,a,b,c,d,e,f,g,h) - - -/***************************************************************************** - * ITypeInfo interface - */ -#define ICOM_INTERFACE ITypeInfo -#define ITypeInfo_METHODS \ - ICOM_METHOD1(HRESULT,GetTypeAttr, TYPEATTR**,ppTypeAttr) \ - ICOM_METHOD1(HRESULT,GetTypeComp, ITypeComp**,ppTComp) \ - ICOM_METHOD2(HRESULT,GetFuncDesc, UINT,index, FUNCDESC**,ppFuncDesc) \ - ICOM_METHOD2(HRESULT,GetVarDesc, UINT,index, VARDESC**,ppVarDesc) \ - ICOM_METHOD4(HRESULT,GetNames, MEMBERID,memid, BSTR*,rgBstrNames, UINT,cMaxNames, UINT*,pcNames) \ - ICOM_METHOD2(HRESULT,GetRefTypeOfImplType, UINT,index, HREFTYPE*, pRefType) \ - ICOM_METHOD2(HRESULT,GetImplTypeFlags, UINT,index, INT*,pImplTypeFlags)\ - ICOM_METHOD3(HRESULT,GetIDsOfNames, LPOLESTR*,rgszNames, UINT,cNames, MEMBERID*,pMemId) \ - ICOM_METHOD7(HRESULT,Invoke, PVOID,pvInstance, MEMBERID,memid, WORD,wFlags, DISPPARAMS*,pDispParams, VARIANT*,pVarResult, EXCEPINFO*,pExcepInfo, UINT*,puArgErr) \ - ICOM_METHOD5(HRESULT,GetDocumentation, MEMBERID,memid, BSTR*,pBstrName, BSTR*,pBstrDocString, DWORD*,pdwHelpContext, BSTR*,pBstrHelpFile) \ - ICOM_METHOD5(HRESULT,GetDllEntry, MEMBERID,memid, INVOKEKIND,invKind, BSTR*,pBstrDllName, BSTR*,pBstrName, WORD*,pwOrdinal) \ - ICOM_METHOD2(HRESULT,GetRefTypeInfo, HREFTYPE,hRefType, ITypeInfo**,ppTInfo) \ - ICOM_METHOD3(HRESULT,AddressOfMember, MEMBERID,memid, INVOKEKIND,invKind, PVOID*,ppv) \ - ICOM_METHOD3(HRESULT,CreateInstance, IUnknown*,pUnkOuter, REFIID,riid, PVOID*,ppvObj) \ - ICOM_METHOD2(HRESULT,GetMops, MEMBERID,memid, BSTR*,pBstrMops) \ - ICOM_METHOD2(HRESULT,GetContainingTypeLib, ITypeLib**,ppTLib, UINT*,pIndex) \ - ICOM_METHOD1(HRESULT,ReleaseTypeAttr, TYPEATTR*,pTypeAttr) \ - ICOM_METHOD1(HRESULT,ReleaseFuncDesc, FUNCDESC*,pFuncDesc) \ - ICOM_METHOD1(HRESULT,ReleaseVarDesc, VARDESC*,pVarDesc) - -#define ITypeInfo_IMETHODS \ - IUnknown_IMETHODS \ - ITypeInfo_METHODS -ICOM_DEFINE(ITypeInfo,IUnknown) -#undef ICOM_INTERFACE - -/*** IUnknown methods ***/ -#define ITypeInfo_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b) -#define ITypeInfo_AddRef(p) ICOM_CALL (AddRef,p) -#define ITypeInfo_Release(p) ICOM_CALL (Release,p) -/*** ITypeInfo methods ***/ -#define ITypeInfo_GetTypeAttr(p,a) ICOM_CALL1(GetTypeAttr,p,a) -#define ITypeInfo_GetTypeComp(p,a) ICOM_CALL1(GetTypeComp,p,a) -#define ITypeInfo_GetFuncDesc(p,a,b) ICOM_CALL2(GetFuncDesc,p,a,b) -#define ITypeInfo_GetVarDesc(p,a,b) ICOM_CALL2(GetVarDesc,p,a,b) -#define ITypeInfo_GetNames(p,a,b,c,d) ICOM_CALL4(GetNames,p,a,b,c,d) -#define ITypeInfo_GetRefTypeOfImplType(p,a,b) ICOM_CALL2(GetRefTypeOfImplType,p,a,b) -#define ITypeInfo_GetImplTypeFlags(p,a,b) ICOM_CALL2(GetImplTypeFlags,p,a,b) -#define ITypeInfo_GetIDsOfNames(p,a,b,c) ICOM_CALL3(GetIDsOfNames,p,a,b,c) -#define ITypeInfo_Invoke(p,a,b,c,d,e,f,g) ICOM_CALL7(Invoke,p,a,b,c,d,e,f,g) -#define ITypeInfo_GetDocumentation(p,a,b,c,d,e) ICOM_CALL5(GetDocumentation,p,a,b,c,d,e) -#define ITypeInfo_GetDllEntry(p,a,b,c,d,e) ICOM_CALL5(GetDllEntry,p,a,b,c,d,e) -#define ITypeInfo_GetRefTypeInfo(p,a,b) ICOM_CALL2(GetRefTypeInfo,p,a,b) -#define ITypeInfo_AddressOfMember(p,a,b,c) ICOM_CALL3(AddressOfMember,p,a,b,c) -#define ITypeInfo_CreateInstance(p,a,b,c) ICOM_CALL3(CreateInstance,p,a,b,c) -#define ITypeInfo_GetMops(p,a,b) ICOM_CALL2(GetMops,p,a,b) -#define ITypeInfo_GetContainingTypeLib(p,a,b) ICOM_CALL2(GetContainingTypeLib,p,a,b) -#define ITypeInfo_ReleaseTypeAttr(p,a) ICOM_CALL1(ReleaseTypeAttr,p,a) -#define ITypeInfo_ReleaseFuncDesc(p,a) ICOM_CALL1(ReleaseFuncDesc,p,a) -#define ITypeInfo_ReleaseVarDesc(p,a) ICOM_CALL1(ReleaseVarDesc,p,a) - - -/***************************************************************************** - * ITypeInfo2 interface - */ -#define ICOM_INTERFACE ITypeInfo2 -#define ITypeInfo2_METHODS \ - ICOM_METHOD1(HRESULT, GetTypeKind, TYPEKIND*, pTypeKind) \ - ICOM_METHOD1(HRESULT, GetTypeFlags, UINT*, pTypeFlags) \ - ICOM_METHOD3(HRESULT, GetFuncIndexOfMemId, MEMBERID, memid, INVOKEKIND,\ - invKind, UINT*, pFuncIndex) \ - ICOM_METHOD2(HRESULT, GetVarIndexOfMemId, MEMBERID, memid, UINT*, \ - pVarIndex) \ - ICOM_METHOD2(HRESULT, GetCustData, REFGUID, guid, VARIANT*, pVarVal) \ - ICOM_METHOD3(HRESULT, GetFuncCustData, UINT, index, REFGUID, guid,\ - VARIANT*, pVarVal) \ - ICOM_METHOD4(HRESULT, GetParamCustData, UINT, indexFunc, UINT,\ - indexParam, REFGUID, guid, VARIANT*, pVarVal) \ - ICOM_METHOD3(HRESULT, GetVarCustData, UINT, index, REFGUID, guid,\ - VARIANT*, pVarVal) \ - ICOM_METHOD3(HRESULT, GetImplTypeCustData, UINT, index, REFGUID, guid,\ - VARIANT*, pVarVal) \ - ICOM_METHOD5(HRESULT, GetDocumentation2, MEMBERID, memid, LCID, lcid,\ - BSTR*, pbstrHelpString, DWORD*, pdwHelpStringContext,\ - BSTR*, pbstrHelpStringDll) \ - ICOM_METHOD1(HRESULT, GetAllCustData, CUSTDATA*, pCustData) \ - ICOM_METHOD2(HRESULT, GetAllFuncCustData, UINT, index, CUSTDATA*,\ - pCustData)\ - ICOM_METHOD3(HRESULT, GetAllParamCustData, UINT, indexFunc, UINT,\ - indexParam, CUSTDATA*, pCustData) \ - ICOM_METHOD2(HRESULT, GetAllVarCustData, UINT, index, CUSTDATA*,\ - pCustData) \ - ICOM_METHOD2(HRESULT, GetAllImplTypeCustData, UINT, index, CUSTDATA*,\ - pCustData) - -#define ITypeInfo2_IMETHODS \ - IUnknown_IMETHODS \ - ITypeInfo_METHODS \ - ITypeInfo2_METHODS -ICOM_DEFINE(ITypeInfo2,ITypeInfo) -#undef ICOM_INTERFACE - -/*** IUnknown methods ***/ -#define ITypeInfo2_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b) -#define ITypeInfo2_AddRef(p) ICOM_CALL (AddRef,p) -#define ITypeInfo2_Release(p) ICOM_CALL (Release,p) -/*** ITypeInfo methods ***/ -#define ITypeInfo2_GetTypeAttr(p,a) ICOM_CALL1(GetTypeAttr,p,a) -#define ITypeInfo2_GetTypeComp(p,a) ICOM_CALL1(GetTypeComp,p,a) -#define ITypeInfo2_GetFuncDesc(p,a,b) ICOM_CALL2(GetFuncDesc,p,a,b) -#define ITypeInfo2_GetVarDesc(p,a,b) ICOM_CALL2(GetVarDesc,p,a,b) -#define ITypeInfo2_GetNames(p,a,b,c,d) ICOM_CALL4(GetNames,p,a,b,c,d) -#define ITypeInfo2_GetRefTypeOfImplType(p,a,b) ICOM_CALL2(GetRefTypeOfImplType,p,a,b) -#define ITypeInfo2_GetImplTypeFlags(p,a,b) ICOM_CALL2(GetImplTypeFlags,p,a,b) -#define ITypeInfo2_GetIDsOfNames(p,a,b,c) ICOM_CALL3(GetIDsOfNames,p,a,b,c) -#define ITypeInfo2_Invoke(p,a,b,c,d,e,f,g) ICOM_CALL7(Invoke,p,a,b,c,d,e,f,g) -#define ITypeInfo2_GetDocumentation(p,a,b,c,d,e) ICOM_CALL5(GetDocumentation,p,a,b,c,d,e) -#define ITypeInfo2_GetDllEntry(p,a,b,c,d,e) ICOM_CALL5(GetDllEntry,p,a,b,c,d,e) -#define ITypeInfo2_GetRefTypeInfo(p,a,b) ICOM_CALL2(GetRefTypeInfo,p,a,b) -#define ITypeInfo2_AddressOfMember(p,a,b,c) ICOM_CALL3(AddressOfMember,p,a,b,c) -#define ITypeInfo2_CreateInstance(p,a,b,c) ICOM_CALL3(CreateInstance,p,a,b,c) -#define ITypeInfo2_GetMops(p,a,b) ICOM_CALL2(GetMops,p,a,b) -#define ITypeInfo2_GetContainingTypeLib(p,a,b) ICOM_CALL2(GetContainingTypeLib,p,a,b) -#define ITypeInfo2_ReleaseTypeAttr(p,a) ICOM_CALL1(ReleaseTypeAttr,p,a) -#define ITypeInfo2_ReleaseFuncDesc(p,a) ICOM_CALL1(ReleaseFuncDesc,p,a) -#define ITypeInfo2_ReleaseVarDesc(p,a) ICOM_CALL1(ReleaseVarDesc,p,a) -/*** ITypeInfo2 methods ***/ -#define ITypeInfo2_GetTypeKind(p,a) ICOM_CALL1(GetTypeKind,p,a) -#define ITypeInfo2_GetTypeFlags(p,a) ICOM_CALL1(GetTypeFlags,p,a) -#define ITypeInfo2_GetFuncIndexOfMemId(p,a,b,c) ICOM_CALL3(GetFuncIndexOfMemId,p,a,b,c) -#define ITypeInfo2_GetVarIndexOfMemId(p,a,b) ICOM_CALL2(GetVarIndexOfMemId,p,a,b) -#define ITypeInfo2_GetCustData(p,a,b) ICOM_CALL2(GetCustData,p,a,b) -#define ITypeInfo2_GetFuncCustData(p,a,b,c) ICOM_CALL3(GetFuncCustData,p,a,b,c) -#define ITypeInfo2_GetParamCustData(p,a,b,c,d) ICOM_CALL4(GetParamCustData,p,a,b,c,d) -#define ITypeInfo2_GetVarCustData(p,a,b,c) ICOM_CALL3(GetVarCustData,p,a,b,c) -#define ITypeInfo2_GetImplTypeCustData(p,a,b,c) ICOM_CALL3(GetImplTypeCustData,p,a,b,c) -#define ITypeInfo2_GetDocumentation2(p,a,b,c,d,e) ICOM_CALL5(GetDocumentation2,p,a,b,c,d,e) -#define ITypeInfo2_GetAllCustData(p,a) ICOM_CALL1(GetAllCustData,p,a) -#define ITypeInfo2_GetAllFuncCustData(p,a,b) ICOM_CALL2(GetAllFuncCustData,p,a,b) -#define ITypeInfo2_GetAllParamCustData(p,a,b,c) ICOM_CALL3(GetAllParamCustData,p,a,b,c) -#define ITypeInfo2_GetAllVarCustData(p,a,b) ICOM_CALL2(GetAllVarCustData,p,a,b) -#define ITypeInfo2_GetAllImplTypeCustData(p,a,b) ICOM_CALL2(GetAllImplTypeCustData,p,a,b) - -/***************************************************************************** - * ITypeLib interface - */ -#define ICOM_INTERFACE ITypeLib -#define ITypeLib_METHODS \ - ICOM_METHOD (UINT,GetTypeInfoCount) \ - ICOM_METHOD2(HRESULT,GetTypeInfo, UINT,index, ITypeInfo**,ppTInfo) \ - ICOM_METHOD2(HRESULT,GetTypeInfoType, UINT,index, TYPEKIND*,pTKind) \ - ICOM_METHOD2(HRESULT,GetTypeInfoOfGuid, REFGUID,guid, ITypeInfo**,ppTinfo) \ - ICOM_METHOD1(HRESULT,GetLibAttr, TLIBATTR**,ppTLibAttr) \ - ICOM_METHOD1(HRESULT,GetTypeComp, ITypeComp**,ppTComp) \ - ICOM_METHOD5(HRESULT,GetDocumentation, INT,index, BSTR*,pBstrName, BSTR*,pBstrDocString, DWORD*,pdwHelpContext, BSTR*,pBstrHelpFile) \ - ICOM_METHOD3(HRESULT,IsName, LPOLESTR,szNameBuf, ULONG,lHashVal, BOOL*,bfName) \ - ICOM_METHOD5(HRESULT,FindName, LPOLESTR,szNameBuf, ULONG,lHashVal, ITypeInfo**,ppTInfo, MEMBERID*,rgMemId, USHORT*,pcFound) \ - ICOM_METHOD1(VOID,ReleaseTLibAttr, TLIBATTR*,pTLibAttr) -#define ITypeLib_IMETHODS \ - IUnknown_IMETHODS \ - ITypeLib_METHODS -ICOM_DEFINE(ITypeLib,IUnknown) -#undef ICOM_INTERFACE - -/*** IUnknown methods ***/ -#define ITypeLib_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b) -#define ITypeLib_AddRef(p) ICOM_CALL (AddRef,p) -#define ITypeLib_Release(p) ICOM_CALL (Release,p) -/*** ITypeLib methods ***/ -#define ITypeLib_GetTypeInfoCount(p) ICOM_CALL (GetTypeInfoCount,p) -#define ITypeLib_GetTypeInfo(p,a,b) ICOM_CALL2(GetTypeInfo,p,a,b) -#define ITypeLib_GetTypeInfoType(p,a,b) ICOM_CALL2(GetTypeInfoType,p,a,b) -#define ITypeLib_GetTypeInfoOfGuid(p,a,b) ICOM_CALL2(GetTypeInfoOfGuid,p,a,b) -#define ITypeLib_GetLibAttr(p,a) ICOM_CALL1(GetLibAttr,p,a) -#define ITypeLib_GetTypeComp(p,a) ICOM_CALL1(GetTypeComp,p,a) -#define ITypeLib_GetDocumentation(p,a,b,c,d,e) ICOM_CALL5(GetDocumentation,p,a,b,c,d,e) -#define ITypeLib_IsName(p,a,b,c) ICOM_CALL3(IsName,p,a,b,c) -#define ITypeLib_FindName(p,a,b,c,d,e) ICOM_CALL5(FindName,p,a,b,c,d,e) -#define ITypeLib_ReleaseTLibAttr(p,a) ICOM_CALL1(ReleaseTLibAttr,p,a) - - -/***************************************************************************** - * ITypeLib2 interface - */ -#define ICOM_INTERFACE ITypeLib2 -#define ITypeLib2_METHODS \ - ICOM_METHOD2(HRESULT, GetCustData, REFGUID, guid, VARIANT*, pVarVal) \ - ICOM_METHOD2(HRESULT, GetLibStatistics, ULONG *, pcUniqueNames, ULONG*,pcchUniqueNames) \ - ICOM_METHOD5(HRESULT, GetDocumentation2, INT, index, LCID, lcid,BSTR*, pbstrHelpString, DWORD*, pdwHelpStringContext, BSTR*, strHelpStringDll) \ - ICOM_METHOD1(HRESULT, GetAllCustData, CUSTDATA *, pCustData) -#define ITypeLib2_IMETHODS \ - IUnknown_IMETHODS \ - ITypeLib_IMETHODS \ - ITypeLib2_METHODS -ICOM_DEFINE(ITypeLib2,ITypeLib) -#undef ICOM_INTERFACE - -/*** IUnknown methods ***/ -#define ITypeLib2_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b) -#define ITypeLib2_AddRef(p) ICOM_CALL (AddRef,p) -#define ITypeLib2_Release(p) ICOM_CALL (Release,p) -/*** ITypeLib methods ***/ -#define ITypeLib2_GetTypeInfoCount(p) ICOM_CALL (GetTypeInfoCount,p) -#define ITypeLib2_GetTypeInfo(p,a,b) ICOM_CALL2(GetTypeInfo,p,a,b) -#define ITypeLib2_GetTypeInfoType(p,a,b) ICOM_CALL2(GetTypeInfoType,p,a,b) -#define ITypeLib2_GetTypeInfoOfGuid(p,a,b) ICOM_CALL2(GetTypeInfoOfGuid,p,a,b) -#define ITypeLib2_GetLibAttr(p,a) ICOM_CALL1(GetLibAttr,p,a) -#define ITypeLib2_GetTypeComp(p,a) ICOM_CALL1(GetTypeComp,p,a) -#define ITypeLib2_GetDocumentation(p,a,b,c,d,e) ICOM_CALL5(GetDocumentation,p,a,b,c,d,e) -#define ITypeLib2_IsName(p,a,b,c) ICOM_CALL3(IsName,p,a,b,c) -#define ITypeLib2_FindName(p,a,b,c,d,e) ICOM_CALL5(FindName,p,a,b,c,d,e) -#define ITypeLib2_ReleaseTLibAttr(p,a) ICOM_CALL1(ReleaseTLibAttr,p,a) -/*** ITypeLib2 methods ***/ -#define ITypeLib2_GetCustData(p,a,b) ICOM_CALL2(GetCustData,p,a,b) -#define ITypeLib2_GetLibStatistics(p,a,b) ICOM_CALL2(GetLibStatistics,p,a,b) -#define ITypeLib2_GetDocumentation2(p,a,b,c,d,e,f) ICOM_CALL5(GetDocumentation2,p,a,b,c,d,e) -#define ITypeLib2_GetAllCustData(p,a) ICOM_CALL1(GetAllCustData,p,a) - -/***************************************************************************** - * ITypeComp interface - */ -#define ICOM_INTERFACE ITypeComp -#define ITypeComp_METHODS \ - ICOM_METHOD6(HRESULT,Bind, LPOLESTR,szName, ULONG,lHashVal, WORD,wFlags, ITypeInfo**,ppTInfo, DESCKIND*,pDescKind, BINDPTR*,pBindPtr) \ - ICOM_METHOD4(HRESULT,BindType, LPOLESTR,szName, ULONG,lHashVal, ITypeInfo**,ppTInfo, ITypeComp**,ppTComp) -#define ITypeComp_IMETHODS \ - IUnknown_IMETHODS \ - ITypeComp_METHODS -ICOM_DEFINE(ITypeComp,IUnknown) -#undef ICOM_INTERFACE - -/*** IUnknown methods ***/ -#define ITypeComp_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b) -#define ITypeComp_AddRef(p) ICOM_CALL (AddRef,p) -#define ITypeComp_Release(p) ICOM_CALL (Release,p) -/*** ITypeComp methods ***/ -#define ITypeComp_Bind(p,a,b,c,d,e,f) ICOM_CALL6(Bind,p,a,b,c,d,e,f) -#define ITypeComp_BindType(p,a,b,c,d) ICOM_CALL4(BindType,p,a,b,c,d) - -/***************************************************************************** - * IEnumVARIANT interface - */ -#define ICOM_INTERFACE IEnumVARIANT -#define IEnumVARIANT_METHODS \ - ICOM_METHOD3(HRESULT,Next, ULONG,celt, VARIANT*,rgVar, ULONG*,pCeltFetched) \ - ICOM_METHOD1(HRESULT,Skip, ULONG,celt) \ - ICOM_METHOD (HRESULT,Reset) \ - ICOM_METHOD1(HRESULT,Clone, IEnumVARIANT**,ppEnum) -#define IEnumVARIANT_IMETHODS \ - IUnknown_IMETHODS \ - IEnumVARIANT_METHODS -ICOM_DEFINE(IEnumVARIANT,IUnknown) -#undef ICOM_INTERFACE - -/*** IUnknown methods ***/ -#define IEnumVARIANT_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b) -#define IEnumVARIANT_AddRef(p) ICOM_CALL (AddRef,p) -#define IEnumVARIANT_Release(p) ICOM_CALL (Release,p) -/*** IEnumVARIANT methods ***/ -#define IEnumVARIANT_Next(p,a,b,c) ICOM_CALL3(Next,p,a,b,c) -#define IEnumVARIANT_Skip(p,a) ICOM_CALL1(Skip,p,a) -#define IEnumVARIANT_Reset(p) ICOM_CALL (Reset,p) -#define IEnumVARIANT_Clone(p,a) ICOM_CALL1(Clone,p,a) - -/***************************************************************************** - * IRecordInfo interface - */ -#define ICOM_INTERFACE IRecordInfo -#define IRecordInfo_METHODS \ - ICOM_METHOD1(HRESULT, RecordInit, PVOID, pvNew) \ - ICOM_METHOD1(HRESULT, RecordClear, PVOID, pvExisting) \ - ICOM_METHOD2(HRESULT, RecordCopy, PVOID, pvExisting, PVOID, pvNew) \ - ICOM_METHOD1(HRESULT, GetGUID, GUID*, pguid) \ - ICOM_METHOD1(HRESULT, GetName, BSTR*, pbstrName) \ - ICOM_METHOD1(HRESULT, GetSize, ULONG*, pcbSize) \ - ICOM_METHOD1(HRESULT, GetTypeInfo, ITypeInfo**, ppTypeInfo) \ - ICOM_METHOD3(HRESULT, GetField, PVOID, pvData, LPCOLESTR, szFieldName, VARIANT*, pvarField) \ - ICOM_METHOD4(HRESULT, GetFieldNoCopy, PVOID, pvData, LPCOLESTR, szFieldName, VARIANT*, pvarField, PVOID *,ppvDataCArray) \ - ICOM_METHOD4(HRESULT, PutField, ULONG, wFlags, PVOID, pvData, LPCOLESTR, szFieldName, VARIANT*, pvarField) \ - ICOM_METHOD4(HRESULT, PutFieldNoCopy, ULONG, wFlags, PVOID, pvData, LPCOLESTR, szFieldName, VARIANT*, pvarField) \ - ICOM_METHOD2(HRESULT, GetFieldNames, ULONG*, pcNames, BSTR*, rgBstrNames) \ - ICOM_METHOD1(BOOL, IsMatchingType, IRecordInfo*, pRecordInfo) \ - ICOM_METHOD (LPVOID, RecordCreate) \ - ICOM_METHOD2(HRESULT, RecordCreateCopy, PVOID, pvSource, PVOID*, ppvDest) \ - ICOM_METHOD1(HRESULT, RecordDestroy, PVOID, pvRecord) - -#define IRecordInfo_IMETHODS \ - IUnknown_IMETHODS \ - IRecordInfo_METHODS -ICOM_DEFINE(IRecordInfo,IUnknown) -#undef ICOM_INTERFACE - -/*** IUnknown methods ***/ -#define IRecordInfo_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b) -#define IRecordInfo_AddRef(p) ICOM_CALL (AddRef,p) -#define IRecordInfo_Release(p) ICOM_CALL (Release,p) -/*** IRecordInfo methods ***/ -#define IRecordInfo_RecordInit(p,a) ICOM_CALL1(RecordInit,p,a) -#define IRecordInfo_RecordClear(p,a) ICOM_CALL1(RecordClear,p,a) -#define IRecordInfo_RecordCopy(p,a,b) ICOM_CALL2(RecordCopy,p,a,b) -#define IRecordInfo_GetGUID(p,a) ICOM_CALL1(GetGUID,p,a) -#define IRecordInfo_GetName(p,a) ICOM_CALL1(GetName,p,a) -#define IRecordInfo_GetTypeInfo(p,a) ICOM_CALL1(GetTypeInfo,p,a) -#define IRecordInfo_GetField(p,a,b,c) ICOM_CALL3(GetField,p,a,b,c) -#define IRecordInfo_GetFieldNoCopy(p,a,b,c,d) ICOM_CALL4(GetFieldNoCopy,p,a,b,c,d) -#define IRecordInfo_PutField(p,a,b,c,d) ICOM_CALL4(PutField,p,a,b,c,d) -#define IRecordInfo_PutFieldNoCopy(p,a,b,c,d) ICOM_CALL4(PutField,p,a,b,c,d) -#define IRecordInfo_GetFieldNames(p,a,b) ICOM_CALL2(GetFieldNames,p,a,b) -#define IRecordInfo_RecordCreate(p) ICOM_CALL (RecordCreate,p) -#define IRecordInfo_RecordCreateCopy(p,a,b) ICOM_CALL2(RecordCreateCopy,p,a,b) -#define IRecordInfo_RecordDestroy(p,a) ICOM_CALL1(RecordDestroy,p,a) - -#endif /* __WINE_WINE_OBJ_OLEAUT_H */