| // Licensed under the Apache License, Version 2.0 |
| // <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license |
| // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option. |
| // All files in the project carrying such notice may not be copied, modified, or distributed |
| // except according to those terms. |
| //! Mappings for the contents of OAIdl.h |
| use shared::basetsd::ULONG_PTR; |
| use shared::guiddef::{GUID, IID, REFGUID, REFIID}; |
| use shared::minwindef::{BOOL, BYTE, DWORD, FLOAT, INT, UINT, ULONG, USHORT, WORD}; |
| use shared::rpcndr::byte; |
| use shared::wtypes::{ |
| BSTR, CY, DATE, DECIMAL, VARIANT_BOOL, VARTYPE, VT_BSTR, VT_DISPATCH, VT_ERROR, |
| VT_I1, VT_I2, VT_I4, VT_I8, VT_RECORD, VT_RESERVED, VT_UNKNOWN, VT_VARIANT, |
| wireBSTR |
| }; |
| use shared::wtypesbase::{ |
| BYTE_SIZEDARR, DOUBLE, DWORD_SIZEDARR, HYPER_SIZEDARR, LPCOLESTR, LPOLESTR, SCODE, |
| WORD_SIZEDARR |
| }; |
| use um::unknwnbase::{IUnknown, IUnknownVtbl}; |
| use um::winnt::{CHAR, HRESULT, LCID, LONG, LONGLONG, PVOID, SHORT, ULONGLONG}; |
| pub type CURRENCY = CY; |
| STRUCT!{struct SAFEARRAYBOUND { |
| cElements: ULONG, |
| lLbound: LONG, |
| }} |
| pub type LPSAFEARRAYBOUND = *mut SAFEARRAYBOUND; |
| pub type wireBRECORD = *mut _wireBRECORD; |
| pub type wireVARIANT = *mut _wireVARIANT; |
| STRUCT!{struct SAFEARR_BSTR { |
| Size: ULONG, |
| aBstr: *mut wireBSTR, |
| }} |
| STRUCT!{struct SAFEARR_UNKNOWN { |
| Size: ULONG, |
| apUnknown: *mut *mut IUnknown, |
| }} |
| STRUCT!{struct SAFEARR_DISPATCH { |
| Size: ULONG, |
| apDispatch: *mut *mut IDispatch, |
| }} |
| STRUCT!{struct SAFEARR_VARIANT { |
| Size: ULONG, |
| aVariant: *mut wireVARIANT, |
| }} |
| STRUCT!{struct SAFEARR_BRECORD { |
| Size: ULONG, |
| aRecord: *mut wireBRECORD, |
| }} |
| STRUCT!{struct SAFEARR_HAVEIID { |
| Size: ULONG, |
| apUnknown: *mut *mut IUnknown, |
| iid: IID, |
| }} |
| ENUM!{enum SF_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, |
| }} |
| #[cfg(target_pointer_width = "32")] |
| UNION!{union __MIDL_IOleAutomationTypes_0001 { |
| [u32; 6], |
| BstrStr BstrStr_mut: SAFEARR_BSTR, |
| UnknownStr UnknownStr_mut: SAFEARR_UNKNOWN, |
| DispatchStr DispatchStr_mut: SAFEARR_DISPATCH, |
| VariantStr VariantStr_mut: SAFEARR_VARIANT, |
| RecordStr RecordStr_mut: SAFEARR_BRECORD, |
| HaveIidStr HaveIidStr_mut: SAFEARR_HAVEIID, |
| ByteStr ByteStr_mut: BYTE_SIZEDARR, |
| WordStr WordStr_mut: WORD_SIZEDARR, |
| LongStr LongStr_mut: DWORD_SIZEDARR, |
| HyperStr HyperStr_mut: HYPER_SIZEDARR, |
| }} |
| #[cfg(target_pointer_width = "64")] |
| UNION!{union __MIDL_IOleAutomationTypes_0001 { |
| [u64; 4], |
| BstrStr BstrStr_mut: SAFEARR_BSTR, |
| UnknownStr UnknownStr_mut: SAFEARR_UNKNOWN, |
| DispatchStr DispatchStr_mut: SAFEARR_DISPATCH, |
| VariantStr VariantStr_mut: SAFEARR_VARIANT, |
| RecordStr RecordStr_mut: SAFEARR_BRECORD, |
| HaveIidStr HaveIidStr_mut: SAFEARR_HAVEIID, |
| ByteStr ByteStr_mut: BYTE_SIZEDARR, |
| WordStr WordStr_mut: WORD_SIZEDARR, |
| LongStr LongStr_mut: DWORD_SIZEDARR, |
| HyperStr HyperStr_mut: HYPER_SIZEDARR, |
| }} |
| STRUCT!{struct SAFEARRAYUNION { |
| sfType: ULONG, |
| u: __MIDL_IOleAutomationTypes_0001, |
| }} |
| STRUCT!{struct _wireSAFEARRAY { |
| cDims: USHORT, |
| fFeatures: USHORT, |
| cbElements: ULONG, |
| cLocks: ULONG, |
| uArrayStructs: SAFEARRAYUNION, |
| rgsaBound: [SAFEARRAYBOUND; 1], |
| }} |
| pub type wireSAFEARRAY = *mut _wireSAFEARRAY; |
| pub type wirePSAFEARRAY = *mut wireSAFEARRAY; |
| STRUCT!{struct SAFEARRAY { |
| cDims: USHORT, |
| fFeatures: USHORT, |
| cbElements: ULONG, |
| cLocks: ULONG, |
| pvData: PVOID, |
| rgsabound: [SAFEARRAYBOUND; 1], |
| }} |
| pub type LPSAFEARRAY = *mut SAFEARRAY; |
| pub const FADF_AUTO: DWORD = 0x1; |
| pub const FADF_STATIC: DWORD = 0x2; |
| pub const FADF_EMBEDDED: DWORD = 0x4; |
| pub const FADF_FIXEDSIZE: DWORD = 0x10; |
| pub const FADF_RECORD: DWORD = 0x20; |
| pub const FADF_HAVEIID: DWORD = 0x40; |
| pub const FADF_HAVEVARTYPE: DWORD = 0x80; |
| pub const FADF_BSTR: DWORD = 0x100; |
| pub const FADF_UNKNOWN: DWORD = 0x200; |
| pub const FADF_DISPATCH: DWORD = 0x400; |
| pub const FADF_VARIANT: DWORD = 0x800; |
| pub const FADF_RESERVED: DWORD = 0xf008; |
| STRUCT!{struct __tagBRECORD { |
| pvRecord: PVOID, |
| pRecInfo: *mut IRecordInfo, |
| }} |
| UNION!{union VARIANT_n3 { |
| [u64; 1] [u64; 2], |
| llVal llVal_mut: LONGLONG, |
| lVal lVal_mut: LONG, |
| bVal bVal_mut: BYTE, |
| iVal iVal_mut: SHORT, |
| fltVal fltVal_mut: FLOAT, |
| dblVal dblVal_mut: DOUBLE, |
| boolVal boolVal_mut: VARIANT_BOOL, |
| scode scode_mut: SCODE, |
| cyVal cyVal_mut: CY, |
| date date_mut: DATE, |
| bstrVal bstrVal_mut: BSTR, |
| punkVal punkVal_mut: *mut IUnknown, |
| pdispVal pdispVal_mut: *mut IDispatch, |
| parray parray_mut: *mut SAFEARRAY, |
| pbVal pbVal_mut: *mut BYTE, |
| piVal piVal_mut: *mut SHORT, |
| plVal plVal_mut: *mut LONG, |
| pllVal pllVal_mut: *mut LONGLONG, |
| pfltVal pfltVal_mut: *mut FLOAT, |
| pdblVal pdblVal_mut: *mut DOUBLE, |
| pboolVal pboolVal_mut: *mut VARIANT_BOOL, |
| pscode pscode_mut: *mut SCODE, |
| pcyVal pcyVal_mut: *mut CY, |
| pdate pdate_mut: *mut DATE, |
| pbstrVal pbstrVal_mut: *mut BSTR, |
| ppunkVal ppunkVal_mut: *mut *mut IUnknown, |
| ppdispVal ppdispVal_mut: *mut *mut IDispatch, |
| pparray pparray_mut: *mut *mut SAFEARRAY, |
| pvarVal pvarVal_mut: *mut VARIANT, |
| byref byref_mut: PVOID, |
| cVal cVal_mut: CHAR, |
| uiVal uiVal_mut: USHORT, |
| ulVal ulVal_mut: ULONG, |
| ullVal ullVal_mut: ULONGLONG, |
| intVal intVal_mut: INT, |
| uintVal uintVal_mut: UINT, |
| pdecVal pdecVal_mut: *mut DECIMAL, |
| pcVal pcVal_mut: *mut CHAR, |
| puiVal puiVal_mut: *mut USHORT, |
| pulVal pulVal_mut: *mut ULONG, |
| pullVal pullVal_mut: *mut ULONGLONG, |
| pintVal pintVal_mut: *mut INT, |
| puintVal puintVal_mut: *mut UINT, |
| n4 n4_mut: __tagBRECORD, |
| }} |
| STRUCT!{struct __tagVARIANT { |
| vt: VARTYPE, |
| wReserved1: WORD, |
| wReserved2: WORD, |
| wReserved3: WORD, |
| n3: VARIANT_n3, |
| }} |
| UNION!{union VARIANT_n1 { |
| [u64; 2] [u64; 3], |
| n2 n2_mut: __tagVARIANT, |
| decVal decVal_mut: DECIMAL, |
| }} |
| STRUCT!{struct VARIANT { |
| n1: VARIANT_n1, |
| }} |
| pub type LPVARIANT = *mut VARIANT; |
| pub type VARIANTARG = VARIANT; |
| pub type LPVARIANTARG = *mut VARIANT; |
| pub type REFVARIANT = *const VARIANT; |
| STRUCT!{struct _wireBRECORD { |
| fFlags: ULONG, |
| clSize: ULONG, |
| pRecInfo: *mut IRecordInfo, |
| pRecord: *mut byte, |
| }} |
| UNION!{union _wireVARIANT_u { |
| [u64; 2], |
| llVal llVal_mut: LONGLONG, |
| lVal lVal_mut: LONG, |
| bVal bVal_mut: BYTE, |
| iVal iVal_mut: SHORT, |
| fltVal fltVal_mut: FLOAT, |
| dblVal dblVal_mut: DOUBLE, |
| boolVal boolVal_mut: VARIANT_BOOL, |
| scode scode_mut: SCODE, |
| cyVal cyVal_mut: CY, |
| date date_mut: DATE, |
| bstrVal bstrVal_mut: wireBSTR, |
| punkVal punkVal_mut: *mut IUnknown, |
| pdispVal pdispVal_mut: *mut IDispatch, |
| parray parray_mut: wirePSAFEARRAY, |
| brecVal brecVal_mut: wireBRECORD, |
| pbVal pbVal_mut: *mut BYTE, |
| piVal piVal_mut: *mut SHORT, |
| plVal plVal_mut: *mut LONG, |
| pllVal pllVal_mut: *mut LONGLONG, |
| pfltVal pfltVal_mut: *mut FLOAT, |
| pdblVal pdblVal_mut: *mut DOUBLE, |
| pboolVal pboolVal_mut: *mut VARIANT_BOOL, |
| pscode pscode_mut: *mut SCODE, |
| pcyVal pcyVal_mut: *mut CY, |
| pdate pdate_mut: *mut DATE, |
| pbstrVal pbstrVal_mut: *mut wireBSTR, |
| ppunkVal ppunkVal_mut: *mut *mut IUnknown, |
| ppdispVal ppdispVal_mut: *mut *mut IDispatch, |
| pparray pparray_mut: *mut wirePSAFEARRAY, |
| pvarVal pvarVal_mut: *mut wireVARIANT, |
| cVal cVal_mut: CHAR, |
| uiVal uiVal_mut: USHORT, |
| ulVal ulVal_mut: ULONG, |
| ullVal ullVal_mut: ULONGLONG, |
| intVal intVal_mut: INT, |
| uintVal uintVal_mut: UINT, |
| decVal decVal_mut: DECIMAL, |
| pdecVal pdecVal_mut: *mut DECIMAL, |
| pcVal pcVal_mut: *mut CHAR, |
| puiVal puiVal_mut: *mut USHORT, |
| pulVal pulVal_mut: *mut ULONG, |
| pullVal pullVal_mut: *mut ULONGLONG, |
| pintVal pintVal_mut: *mut INT, |
| puintVal puintVal_mut: *mut UINT, |
| }} |
| STRUCT!{struct _wireVARIANT { |
| clSize: DWORD, |
| rpcReserved: DWORD, |
| vt: USHORT, |
| wReserved1: USHORT, |
| wReserved2: USHORT, |
| wReserved3: USHORT, |
| u: _wireVARIANT_u, |
| }} |
| pub type DISPID = LONG; |
| pub type MEMBERID = DISPID; |
| pub type HREFTYPE = DWORD; |
| ENUM!{enum TYPEKIND { |
| TKIND_ENUM = 0, |
| TKIND_RECORD, |
| TKIND_MODULE, |
| TKIND_INTERFACE, |
| TKIND_DISPATCH, |
| TKIND_COCLASS, |
| TKIND_ALIAS, |
| TKIND_UNION, |
| TKIND_MAX, |
| }} |
| UNION!{union TYPEDESC_u { |
| [usize; 1], |
| lptdesc lptdesc_mut: *mut TYPEDESC, |
| lpadesc lpadesc_mut: *mut ARRAYDESC, |
| hreftype hreftype_mut: HREFTYPE, |
| }} |
| STRUCT!{struct TYPEDESC { |
| u: TYPEDESC_u, |
| vt: VARTYPE, |
| }} |
| STRUCT!{struct ARRAYDESC { |
| tdescElem: TYPEDESC, |
| cDims: USHORT, |
| rgbounds: [SAFEARRAYBOUND; 1], |
| }} |
| STRUCT!{struct PARAMDESCEX { |
| cBytes: ULONG, |
| varDefaultValue: VARIANTARG, |
| }} |
| pub type LPPARAMDESCEX = *mut PARAMDESCEX; |
| STRUCT!{struct PARAMDESC { |
| pparamdescex: LPPARAMDESCEX, |
| wParamFlags: USHORT, |
| }} |
| pub type LPPARAMDESC = *mut PARAMDESC; |
| pub const PARAMFLAG_NONE: DWORD = 0; |
| pub const PARAMFLAG_FIN: DWORD = 0x1; |
| pub const PARAMFLAG_FOUT: DWORD = 0x2; |
| pub const PARAMFLAG_FLCID: DWORD = 0x4; |
| pub const PARAMFLAG_FRETVAL: DWORD = 0x8; |
| pub const PARAMFLAG_FOPT: DWORD = 0x10; |
| pub const PARAMFLAG_FHASDEFAULT: DWORD = 0x20; |
| pub const PARAMFLAG_FHASCUSTDATA: DWORD = 0x40; |
| STRUCT!{struct IDLDESC { |
| dwReserved: ULONG_PTR, |
| wIDLFlags: USHORT, |
| }} |
| pub type LPIDLDESC = *mut IDLDESC; |
| pub const IDLFLAG_NONE: DWORD = PARAMFLAG_NONE; |
| pub const IDLFLAG_FIN: DWORD = PARAMFLAG_FIN; |
| pub const IDLFLAG_FOUT: DWORD = PARAMFLAG_FOUT; |
| pub const IDLFLAG_FLCID: DWORD = PARAMFLAG_FLCID; |
| pub const IDLFLAG_FRETVAL: DWORD = PARAMFLAG_FRETVAL; |
| UNION!{union ELEMDESC_u { |
| [usize; 2], |
| idldesc idldesc_mut: IDLDESC, |
| paramdesc paramdesc_mut: PARAMDESC, |
| }} |
| STRUCT!{struct ELEMDESC { |
| tdesc: TYPEDESC, |
| u: ELEMDESC_u, |
| }} |
| pub type LPELEMDESC = *mut ELEMDESC; |
| STRUCT!{struct TYPEATTR { |
| guid: GUID, |
| lcid: LCID, |
| dwReserved: DWORD, |
| memidConstructor: MEMBERID, |
| memidDestructor: MEMBERID, |
| lpstrSchema: LPOLESTR, |
| cbSizeInstance: ULONG, |
| typekind: TYPEKIND, |
| cFuncs: WORD, |
| cVars: WORD, |
| cImplTypes: WORD, |
| cbSizeVft: WORD, |
| cbAlignment: WORD, |
| wTypeFlags: WORD, |
| wMajorVerNum: WORD, |
| wMinorVerNum: WORD, |
| tdescAlias: TYPEDESC, |
| idldescType: IDLDESC, |
| }} |
| pub type LPTYPEATTR = *mut TYPEATTR; |
| STRUCT!{struct DISPPARAMS { |
| rgvarg: *mut VARIANTARG, |
| rgdispidNamedArgs: *mut DISPID, |
| cArgs: UINT, |
| cNamedArgs: UINT, |
| }} |
| STRUCT!{struct EXCEPINFO { |
| wCode: WORD, |
| wReserved: WORD, |
| bstrSource: BSTR, |
| bstrDescription: BSTR, |
| bstrHelpFile: BSTR, |
| dwHelpContext: DWORD, |
| pvReserved: PVOID, |
| pfnDeferredFillIn: Option<unsafe extern "system" fn( |
| einfo: *mut EXCEPINFO, |
| ) -> HRESULT>, |
| scode: SCODE, |
| }} |
| ENUM!{enum CALLCONV { |
| CC_FASTCALL = 0, |
| CC_CDECL = 1, |
| CC_MSCPASCAL, |
| CC_PASCAL, |
| CC_MACPASCAL, |
| CC_STDCALL, |
| CC_FPFASTCALL, |
| CC_SYSCALL, |
| CC_MPWCDECL, |
| CC_MPWPASCAL, |
| CC_MAX, |
| }} |
| ENUM!{enum FUNCKIND { |
| FUNC_VIRTUAL = 0, |
| FUNC_PUREVIRTUAL, |
| FUNC_NONVIRTUAL, |
| FUNC_STATIC, |
| FUNC_DISPATCH, |
| }} |
| ENUM!{enum INVOKEKIND { |
| INVOKE_FUNC = 1, |
| INVOKE_PROPERTYGET = 2, |
| INVOKE_PROPERTYPUT = 4, |
| INVOKE_PROPERTYPUTREF = 8, |
| }} |
| STRUCT!{struct FUNCDESC { |
| memid: MEMBERID, |
| lprgscode: *mut SCODE, |
| lprgelemdescParam: *mut ELEMDESC, |
| funckind: FUNCKIND, |
| invkind: INVOKEKIND, |
| callconv: CALLCONV, |
| cParams: SHORT, |
| cParamsOpt: SHORT, |
| oVft: SHORT, |
| cScodes: SHORT, |
| elemdescFunc: ELEMDESC, |
| wFuncFlags: WORD, |
| }} |
| pub type LPFUNCDESC = *mut FUNCDESC; |
| ENUM!{enum VARKIND { |
| VAR_PERINSTANCE = 0, |
| VAR_STATIC, |
| VAR_CONST, |
| VAR_DISPATCH, |
| }} |
| pub const IMPLTYPEFLAG_FDEFAULT: DWORD = 0x1; |
| pub const IMPLTYPEFLAG_FSOURCE: DWORD = 0x2; |
| pub const IMPLTYPEFLAG_FRESTRICTED: DWORD = 0x4; |
| pub const IMPLTYPEFLAG_FDEFAULTVTABLE: DWORD = 0x8; |
| UNION!{union VARDESC_u { |
| [usize; 1], |
| oInst oInst_mut: ULONG, |
| lpvarValue lpvarValue_mut: *mut VARIANT, |
| }} |
| STRUCT!{struct VARDESC { |
| memid: MEMBERID, |
| lpstrSchema: LPOLESTR, |
| u: VARDESC_u, |
| elemdescVar: ELEMDESC, |
| wVarFlags: WORD, |
| varkind: VARKIND, |
| }} |
| pub type LPVARDESC = *mut VARDESC; |
| ENUM!{enum TYPEFLAGS { |
| TYPEFLAG_FAPPOBJECT = 0x1, |
| TYPEFLAG_FCANCREATE = 0x2, |
| TYPEFLAG_FLICENSED = 0x4, |
| TYPEFLAG_FPREDECLID = 0x8, |
| TYPEFLAG_FHIDDEN = 0x10, |
| TYPEFLAG_FCONTROL = 0x20, |
| TYPEFLAG_FDUAL = 0x40, |
| TYPEFLAG_FNONEXTENSIBLE = 0x80, |
| TYPEFLAG_FOLEAUTOMATION = 0x100, |
| TYPEFLAG_FRESTRICTED = 0x200, |
| TYPEFLAG_FAGGREGATABLE = 0x400, |
| TYPEFLAG_FREPLACEABLE = 0x800, |
| TYPEFLAG_FDISPATCHABLE = 0x1000, |
| TYPEFLAG_FREVERSEBIND = 0x2000, |
| TYPEFLAG_FPROXY = 0x4000, |
| }} |
| ENUM!{enum FUNCFLAGS { |
| 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, |
| }} |
| ENUM!{enum VARFLAGS { |
| 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, |
| }} |
| STRUCT!{struct CLEANLOCALSTORAGE { |
| pInterface: *mut IUnknown, |
| pStorage: PVOID, |
| flags: DWORD, |
| }} |
| STRUCT!{struct CUSTDATAITEM { |
| guid: GUID, |
| varValue: VARIANTARG, |
| }} |
| pub type LPCUSTDATAITEM = *mut CUSTDATAITEM; |
| STRUCT!{struct CUSTDATA { |
| cCustData: DWORD, |
| prgCustData: LPCUSTDATAITEM, |
| }} |
| pub type LPCUSTDATA = *mut CUSTDATA; |
| pub type LPCREATETYPEINFO = *mut ICreateTypeInfo; |
| RIDL!{#[uuid(0x00020405, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)] |
| interface ICreateTypeInfo(ICreateTypeInfoVtbl): IUnknown(IUnknownVtbl) { |
| fn SetGuid( |
| guid: REFGUID, |
| ) -> HRESULT, |
| fn SetTypeFlags( |
| uTypeFlags: UINT, |
| ) -> HRESULT, |
| fn SetDocString( |
| pStrDoc: LPOLESTR, |
| ) -> HRESULT, |
| fn SetHelpContext( |
| dwHelpContext: DWORD, |
| ) -> HRESULT, |
| fn SetVersion( |
| wMajorVerNum: WORD, |
| wMinorVerNum: WORD, |
| ) -> HRESULT, |
| fn AddRefTypeInfo( |
| pTInfo: *mut ITypeInfo, |
| ) -> HRESULT, |
| fn AddFuncDesc( |
| index: UINT, |
| pFuncDesc: *mut FUNCDESC, |
| ) -> HRESULT, |
| fn SetImplTypeFlags( |
| index: UINT, |
| implTypeFlags: INT, |
| ) -> HRESULT, |
| fn SetAlignment( |
| cbAlignment: WORD, |
| ) -> HRESULT, |
| fn SetSchema( |
| pStrSchema: LPOLESTR, |
| ) -> HRESULT, |
| fn AddVarDesc( |
| index: UINT, |
| pVarDesc: *mut VARDESC, |
| ) -> HRESULT, |
| fn SetFuncAndParamNames( |
| index: UINT, |
| rgszNames: *mut LPOLESTR, |
| cNames: UINT, |
| ) -> HRESULT, |
| fn SetVarName( |
| index: UINT, |
| szName: LPOLESTR, |
| ) -> HRESULT, |
| fn SetTypeDescAlias( |
| pTDescAlias: *mut TYPEDESC, |
| ) -> HRESULT, |
| fn DefineFuncAsDllEntry( |
| index: UINT, |
| szDllName: LPOLESTR, |
| szProcName: LPOLESTR, |
| ) -> HRESULT, |
| fn SetFuncDocString( |
| index: UINT, |
| szDocString: LPOLESTR, |
| ) -> HRESULT, |
| fn SetVarDocString( |
| index: UINT, |
| szDocString: LPOLESTR, |
| ) -> HRESULT, |
| fn SetFuncHelpContext( |
| index: UINT, |
| dwHelpContext: DWORD, |
| ) -> HRESULT, |
| fn SetVarHelpContext( |
| index: UINT, |
| dwHelpContext: DWORD, |
| ) -> HRESULT, |
| fn SetMops( |
| index: UINT, |
| bstrMops: BSTR, |
| ) -> HRESULT, |
| fn SetTypeIdldesc( |
| pIdlDesc: *mut IDLDESC, |
| ) -> HRESULT, |
| fn LayOut() -> HRESULT, |
| }} |
| // LPCREATETYPEINFO2 |
| // ICreateTypeInfo2 |
| // LPCREATETYPELIB |
| // ICreateTypeLib |
| // LPCREATETYPELIB2 |
| // ICreateTypeLib2 |
| pub type LPDISPATCH = *mut IDispatch; |
| pub const DISPID_UNKNOWN: INT = -1; |
| pub const DISPID_VALUE: INT = 0; |
| pub const DISPID_PROPERTYPUT: INT = -3; |
| pub const DISPID_NEWENUM: INT = -4; |
| pub const DISPID_EVALUATE: INT = -5; |
| pub const DISPID_CONSTRUCTOR: INT = -6; |
| pub const DISPID_DESTRUCTOR: INT = -7; |
| pub const DISPID_COLLECT: INT = -8; |
| RIDL!{#[uuid(0x00020400, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)] |
| interface IDispatch(IDispatchVtbl): IUnknown(IUnknownVtbl) { |
| fn GetTypeInfoCount( |
| pctinfo: *mut UINT, |
| ) -> HRESULT, |
| fn GetTypeInfo( |
| iTInfo: UINT, |
| lcid: LCID, |
| ppTInfo: *mut *mut ITypeInfo, |
| ) -> HRESULT, |
| fn GetIDsOfNames( |
| riid: REFIID, |
| rgszNames: *mut LPOLESTR, |
| cNames: UINT, |
| lcid: LCID, |
| rgDispId: *mut DISPID, |
| ) -> HRESULT, |
| fn Invoke( |
| dispIdMember: DISPID, |
| riid: REFIID, |
| lcid: LCID, |
| wFlags: WORD, |
| pDispParams: *mut DISPPARAMS, |
| pVarResult: *mut VARIANT, |
| pExcepInfo: *mut EXCEPINFO, |
| puArgErr: *mut UINT, |
| ) -> HRESULT, |
| }} |
| // IDispatch_RemoteInvoke_Proxy |
| // IDispatch_RemoteInvoke_Stub |
| // LPENUMVARIANT |
| // IEnumVARIANT |
| // IEnumVARIANT_RemoteNext_Proxy |
| // IEnumVARIANT_RemoteNext_Stub |
| RIDL!{#[uuid(0x0000002F, 0x0000, 0x0000, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)] |
| interface IRecordInfo(IRecordInfoVtbl): IUnknown(IUnknownVtbl) { |
| fn RecordInit( |
| pvNew: PVOID, |
| ) -> HRESULT, |
| fn RecordClear( |
| pvExisting: PVOID, |
| ) -> HRESULT, |
| fn RecordCopy( |
| pvExisting: PVOID, |
| pvNew: PVOID, |
| ) -> HRESULT, |
| fn GetGuid( |
| pguid: *mut GUID, |
| ) -> HRESULT, |
| fn GetName( |
| pbstrName: *mut BSTR, |
| ) -> HRESULT, |
| fn GetSize( |
| pcbSize: *mut ULONG, |
| ) -> HRESULT, |
| fn GetTypeInfo( |
| ppTypeInfo: *mut *mut ITypeInfo, |
| ) -> HRESULT, |
| fn GetField( |
| pvData: PVOID, |
| szFieldName: LPCOLESTR, |
| pvarField: *mut VARIANT, |
| ) -> HRESULT, |
| fn GetFieldNoCopy( |
| pvData: PVOID, |
| szFieldName: LPCOLESTR, |
| pvarField: *mut VARIANT, |
| ppvDataCArray: *mut PVOID, |
| ) -> HRESULT, |
| fn PutField( |
| wFlags: ULONG, |
| pvData: PVOID, |
| szFieldName: LPCOLESTR, |
| pvarField: *mut VARIANT, |
| ) -> HRESULT, |
| fn PutFieldNoCopy( |
| wFlags: ULONG, |
| pvData: PVOID, |
| szFieldName: LPCOLESTR, |
| pvarField: *mut VARIANT, |
| ) -> HRESULT, |
| fn GetFieldNames( |
| pcNames: *mut ULONG, |
| rgBstrNames: *mut BSTR, |
| ) -> HRESULT, |
| fn IsMatchingType( |
| pRecordInfo: *mut IRecordInfo, |
| ) -> BOOL, |
| fn RecordCreate() -> PVOID, |
| fn RecordCreateCopy( |
| pvSource: PVOID, |
| ppvDest: *mut PVOID, |
| ) -> HRESULT, |
| fn RecordDestroy( |
| pvRecord: PVOID, |
| ) -> HRESULT, |
| }} |
| pub type LPTYPECOMP = *mut ITypeComp; |
| ENUM!{enum DESCKIND { |
| DESCKIND_NONE = 0, |
| DESCKIND_FUNCDESC = DESCKIND_NONE + 1, |
| DESCKIND_VARDESC = DESCKIND_FUNCDESC + 1, |
| DESCKIND_TYPECOMP = DESCKIND_VARDESC + 1, |
| DESCKIND_IMPLICITAPPOBJ = DESCKIND_TYPECOMP + 1, |
| DESCKIND_MAX = DESCKIND_IMPLICITAPPOBJ + 1, |
| }} |
| UNION!{union BINDPTR { |
| [usize; 1], |
| lpfuncdesc lpfuncdesc_mut: *mut FUNCDESC, |
| lpvardesc lpvardesc_mut: *mut VARDESC, |
| lptcomp lptcomp_mut: *mut ITypeComp, |
| }} |
| pub type LPBINDPTR = *mut BINDPTR; |
| RIDL!{#[uuid(0x00020403, 0x0000, 0x0000, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)] |
| interface ITypeComp(ITypeCompVtbl): IUnknown(IUnknownVtbl) { |
| fn Bind( |
| szName: LPOLESTR, |
| lHashVal: ULONG, |
| wFlags: WORD, |
| ppTInfo: *mut *mut ITypeInfo, |
| pDescKind: *mut DESCKIND, |
| pBindPtr: *mut BINDPTR, |
| ) -> HRESULT, |
| fn BindType( |
| szName: LPOLESTR, |
| lHashVal: ULONG, |
| ppTInfo: *mut *mut ITypeInfo, |
| ppTComp: *mut *mut ITypeComp, |
| ) -> HRESULT, |
| }} |
| ENUM!{enum SYSKIND { |
| SYS_WIN16 = 0, |
| SYS_WIN32, |
| SYS_MAC, |
| SYS_WIN64, |
| }} |
| STRUCT!{struct TLIBATTR { |
| guid: GUID, |
| lcid: LCID, |
| syskind: SYSKIND, |
| wMajorVerNum: WORD, |
| wMinorVerNum: WORD, |
| wLibFlags: WORD, |
| }} |
| RIDL!{#[uuid(0x00020402, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)] |
| interface ITypeLib(ITypeLibVtbl): IUnknown(IUnknownVtbl) { |
| fn GetTypeInfoCount() -> UINT, |
| fn GetTypeInfo( |
| index: UINT, |
| ppTInfo: *mut *mut ITypeInfo, |
| ) -> HRESULT, |
| fn GetTypeInfoType( |
| index: UINT, |
| pTKind: *mut TYPEKIND, |
| ) -> HRESULT, |
| fn GetTypeInfoOfGuid( |
| guid: REFGUID, |
| ppTInfo: *mut *mut ITypeInfo, |
| ) -> HRESULT, |
| fn GetLibAttr( |
| ppTLibAttr: *mut *mut TLIBATTR, |
| ) -> HRESULT, |
| fn GetTypeComp( |
| ppTComp: *mut *mut ITypeComp, |
| ) -> HRESULT, |
| fn GetDocumentation( |
| index: INT, |
| pbstrName: *mut BSTR, |
| pBstrDocString: *mut BSTR, |
| pdwHelpContext: *mut DWORD, |
| pBstrHelpFile: *mut BSTR, |
| ) -> HRESULT, |
| fn IsName( |
| szNameBuf: LPOLESTR, |
| lHashVal: ULONG, |
| pfName: *mut BOOL, |
| ) -> HRESULT, |
| fn FindName( |
| szNameBuf: LPOLESTR, |
| lHashVal: ULONG, |
| ppTInfo: *mut *mut ITypeInfo, |
| rgMemId: *mut MEMBERID, |
| pcFound: *mut USHORT, |
| ) -> HRESULT, |
| fn ReleaseTLibAttr( |
| pTLibAttr: *const TLIBATTR, |
| ) -> HRESULT, |
| }} |
| RIDL!{#[uuid(0x00020401, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)] |
| interface ITypeInfo(ITypeInfoVtbl): IUnknown(IUnknownVtbl) { |
| fn GetTypeAttr( |
| ppTypeAttr: *mut *mut TYPEATTR, |
| ) -> HRESULT, |
| fn GetTypeComp( |
| ppTComp: *mut *mut ITypeComp, |
| ) -> HRESULT, |
| fn GetFuncDesc( |
| index: UINT, |
| ppFunDesc: *mut *mut FUNCDESC, |
| ) -> HRESULT, |
| fn GetVarDesc( |
| index: UINT, |
| pPVarDesc: *mut *mut VARDESC, |
| ) -> HRESULT, |
| fn GetNames( |
| memid: MEMBERID, |
| rgBstrNames: *mut BSTR, |
| cMaxNames: UINT, |
| pcNames: *mut UINT, |
| ) -> HRESULT, |
| fn GetRefTypeOfImplType( |
| index: UINT, |
| pRefType: *mut HREFTYPE, |
| ) -> HRESULT, |
| fn GetImplTypeFlags( |
| index: UINT, |
| pImplTypeFlags: *mut INT, |
| ) -> HRESULT, |
| fn GetIDsOfNames( |
| rgszNames: *mut LPOLESTR, |
| cNames: UINT, |
| pMemId: *mut MEMBERID, |
| ) -> HRESULT, |
| fn Invoke( |
| pvInstance: PVOID, |
| memid: MEMBERID, |
| wFlags: WORD, |
| pDispParams: *mut DISPPARAMS, |
| pVarResult: *mut VARIANT, |
| pExcepInfo: *mut EXCEPINFO, |
| puArgErr: *mut UINT, |
| ) -> HRESULT, |
| fn GetDocumentation( |
| memid: MEMBERID, |
| pBstrName: *mut BSTR, |
| pBstrDocString: *mut BSTR, |
| pdwHelpContext: *mut DWORD, |
| pBstrHelpFile: *mut BSTR, |
| ) -> HRESULT, |
| fn GetDllEntry( |
| memid: MEMBERID, |
| invKind: INVOKEKIND, |
| pBstrDllName: *mut BSTR, |
| pBstrName: *mut BSTR, |
| pwOrdinal: *mut WORD, |
| ) -> HRESULT, |
| fn GetRefTypeInfo( |
| hRefType: HREFTYPE, |
| ppTInfo: *mut *mut ITypeInfo, |
| ) -> HRESULT, |
| fn AddressOfMember( |
| memid: MEMBERID, |
| invKind: INVOKEKIND, |
| ppv: *mut PVOID, |
| ) -> HRESULT, |
| fn CreateInstance( |
| pUnkOuter: *mut IUnknown, |
| riid: REFIID, |
| ppvObj: *mut PVOID, |
| ) -> HRESULT, |
| fn GetMops( |
| memid: MEMBERID, |
| pBstrMops: *mut BSTR, |
| ) -> HRESULT, |
| fn GetContainingTypeLib( |
| ppTLib: *mut *mut ITypeLib, |
| pIndex: *mut UINT, |
| ) -> HRESULT, |
| fn ReleaseTypeAttr( |
| pTypeAttr: *mut TYPEATTR, |
| ) -> (), |
| fn ReleaseFuncDesc( |
| pFuncDesc: *mut FUNCDESC, |
| ) -> (), |
| fn ReleaseVarDesc( |
| pVarDesc: *mut VARDESC, |
| ) -> (), |
| }} |
| RIDL!{#[uuid(0x1cf2b120, 0x547d, 0x101b, 0x8e, 0x65, 0x08, 0x00, 0x2b, 0x2b, 0xd1, 0x19)] |
| interface IErrorInfo(IErrorInfoVtbl): IUnknown(IUnknownVtbl) { |
| fn GetGUID( |
| pGUID: *mut GUID, |
| ) -> HRESULT, |
| fn GetSource( |
| pBstrSource: *mut BSTR, |
| ) -> HRESULT, |
| fn GetDescription( |
| pBstrDescription: *mut BSTR, |
| ) -> HRESULT, |
| fn GetHelpFile( |
| pBstrHelpFile: *mut BSTR, |
| ) -> HRESULT, |
| fn GetHelpContext( |
| pdwHelpContext: *mut DWORD, |
| ) -> HRESULT, |
| }} |
| RIDL!{#[uuid(0x22f03340, 0x547d, 0x101b, 0x8e, 0x65, 0x08, 0x00, 0x2b, 0x2b, 0xd1, 0x19)] |
| interface ICreateErrorInfo(ICreateErrorInfoVtbl): IUnknown(IUnknownVtbl) { |
| fn SetGUID( |
| rguid: REFGUID, |
| ) -> HRESULT, |
| fn SetSource( |
| szSource: LPOLESTR, |
| ) -> HRESULT, |
| fn SetDescription( |
| szDescription: LPOLESTR, |
| ) -> HRESULT, |
| fn SetHelpFile( |
| szHelpFile: LPOLESTR, |
| ) -> HRESULT, |
| fn SetHelpContext( |
| dwHelpContext: DWORD, |
| ) -> HRESULT, |
| }} |
| RIDL!{#[uuid(0x3127ca40, 0x446e, 0x11ce, 0x81, 0x35, 0x00, 0xaa, 0x00, 0x4b, 0xb8, 0x51)] |
| interface IErrorLog(IErrorLogVtbl): IUnknown(IUnknownVtbl) { |
| fn AddError( |
| pszPropName: LPCOLESTR, |
| pExcepInfo: *const EXCEPINFO, |
| ) -> HRESULT, |
| }} |
| pub type LPERRORLOG = *mut IErrorLog; |
