Wrote a new oaidl.idl to replace include/wine/obj_oleaut.h and

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 \

include/oaidl.idl

+/*
+ * 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);
+}

include/wine/obj_errorinfo.h

-/*
- * 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 */

include/wine/obj_oleaut.h

-/*
- * 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 */