diff options
Diffstat (limited to 'src/VBox/Devices/Graphics/shaderlib/wine/include/oaidl.idl')
| -rw-r--r-- | src/VBox/Devices/Graphics/shaderlib/wine/include/oaidl.idl | 1651 |
1 files changed, 1651 insertions, 0 deletions
diff --git a/src/VBox/Devices/Graphics/shaderlib/wine/include/oaidl.idl b/src/VBox/Devices/Graphics/shaderlib/wine/include/oaidl.idl new file mode 100644 index 00000000..88c134c9 --- /dev/null +++ b/src/VBox/Devices/Graphics/shaderlib/wine/include/oaidl.idl @@ -0,0 +1,1651 @@ +/* + * 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +/* + * Oracle LGPL Disclaimer: For the avoidance of doubt, except that if any license choice + * other than GPL or LGPL is available it will apply instead, Oracle elects to use only + * the Lesser General Public License version 2.1 (LGPLv2) at this time for any software where + * a choice of LGPL license versions is made available with the language indicating + * that LGPLv2 or any later version may be used, or where a choice of which version + * of the LGPL is applied is otherwise unspecified. + */ + +#ifndef DO_NO_IMPORTS +import "objidl.idl"; +#endif + +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_DATADELETED = 0x1000; /* Data in a vector has been deleted */ +const USHORT FADF_CREATEVECTOR = 0x2000; /* This array is a vector */ + +/* 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 { + signed 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; + LONGLONG llVal; + ULONGLONG ullVal; + signed 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; + LONGLONG *pllVal; + ULONGLONG *pullVal; + 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; + +cpp_quote("#if 0") +typedef const VARIANT *REFVARIANT; +cpp_quote("#elif !defined(_REFVARIANT_DEFINED)") +cpp_quote("#define _REFVARIANT_DEFINED") +cpp_quote("#ifdef __cplusplus") +cpp_quote("#define REFVARIANT const VARIANT &") +cpp_quote("#else") +cpp_quote("#define REFVARIANT const VARIANT *__MIDL_CONST") +cpp_quote("#endif") +cpp_quote("#endif") + +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)] signed 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)] signed 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; + } DUMMYUNIONNAME; +}; + +/* 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] ; + } DUMMYUNIONNAME; + 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_PTR 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_PTR pvReserved; + ULONG_PTR 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; + } DUMMYUNIONNAME; + 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, + SYS_WIN64 + } 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); +} + + +/***************************************************************************** + * IErrorLog interface + */ +[ + object, + uuid(3127ca40-446e-11ce-8135-00aa004bb851), + pointer_default(unique) +] +interface IErrorLog : IUnknown +{ + typedef IErrorLog *LPERRORLOG; + + HRESULT AddError( + [in] LPCOLESTR pszPropName, + [in] EXCEPINFO *pExcepInfo); +} + + +/***************************************************************************** + * IPropertyBag interface + */ +[ + object, + uuid(55272a00-42cb-11ce-8135-00aa004bb851), + pointer_default(unique) +] +interface IPropertyBag : IUnknown +{ + typedef IPropertyBag *LPPROPERTYBAG; + + [local] + HRESULT Read( + [in] LPCOLESTR pszPropName, + [in, out] VARIANT *pVar, + [in] IErrorLog *pErrorLog); + + [call_as(Read)] + HRESULT RemoteRead( + [in] LPCOLESTR pszPropName, + [out] VARIANT *pVar, + [in] IErrorLog *pErrorLog, + [in] DWORD varType, + [in] IUnknown *pUnkObj); + + HRESULT Write( + [in] LPCOLESTR pszPropName, + [in] VARIANT *pVar); +} |