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