1 // Copyright © 2015, Connor Hilarides
2 // Licensed under the MIT License <LICENSE.md>
3 //! Mappings for the contents of OAIdl.h
4 pub type wireBRECORD = *mut _wireBRECORD;
5 pub type wireVARIANT = *mut _wireVARIANT;
6 STRUCT!{struct SAFEARRAYBOUND {
7     cElements: ::ULONG,
8     lLbound: ::LONG,
9 }}
10 STRUCT!{struct SAFEARR_BSTR {
11     Size: ::ULONG,
12     aBstr: *mut ::wireBSTR,
13 }}
14 STRUCT!{struct SAFEARR_UNKNOWN {
15     Size: ::ULONG,
16     apUnknown: *mut *mut ::IUnknown,
17 }}
18 STRUCT!{struct SAFEARR_DISPATCH {
19     Size: ::ULONG,
20     apDispatch: *mut *mut IDispatch,
21 }}
22 STRUCT!{struct SAFEARR_VARIANT {
23     Size: ::ULONG,
24     aVariant: *mut wireVARIANT,
25 }}
26 STRUCT!{struct SAFEARR_BRECORD {
27     Size: ::ULONG,
28     aRecord: *mut wireBRECORD,
29 }}
30 STRUCT!{struct SAFEARR_HAVEIID {
31     Size: ::ULONG,
32     apUnknown: *mut *mut ::IUnknown,
33     iid: ::IID,
34 }}
35 ENUM!{enum SF_TYPE {
36     SF_ERROR = ::VT_ERROR.0,
37     SF_I1 = ::VT_I1.0,
38     SF_I2 = ::VT_I2.0,
39     SF_I4 = ::VT_I4.0,
40     SF_I8 = ::VT_I8.0,
41     SF_BSTR = ::VT_BSTR.0,
42     SF_UNKNOWN = ::VT_UNKNOWN.0,
43     SF_DISPATCH = ::VT_DISPATCH.0,
44     SF_VARIANT = ::VT_VARIANT.0,
45     SF_RECORD = ::VT_RECORD.0,
46     SF_HAVEIID = ::VT_UNKNOWN.0 | ::VT_RESERVED.0,
47 }}
48 STRUCT!{struct SAFEARRAYUNION {
49     sfType: ::ULONG,
50     u: __MIDL_IOleAutomationTypes_0001,
51 }}
52 #[cfg(target_arch = "x86_64")]
53 STRUCT!{struct __MIDL_IOleAutomationTypes_0001 {
54     data0: u32,
55     data1: [u32; 6],
56 }}
57 #[cfg(target_arch = "x86")]
58 STRUCT!{struct __MIDL_IOleAutomationTypes_0001 {
59     data0: u32,
60     data1: [u32; 5],
61 }}
62 UNION!(__MIDL_IOleAutomationTypes_0001, data0, BstrStr, BstrStr_mut, SAFEARR_BSTR);
63 UNION!(__MIDL_IOleAutomationTypes_0001, data0, UnknownStr, UnknownStr_mut, SAFEARR_UNKNOWN);
64 UNION!(__MIDL_IOleAutomationTypes_0001, data0, DispatchStr, DispatchStr_mut, SAFEARR_DISPATCH);
65 UNION!(__MIDL_IOleAutomationTypes_0001, data0, VariantStr, VariantStr_mut, SAFEARR_VARIANT);
66 UNION!(__MIDL_IOleAutomationTypes_0001, data0, RecordStr, RecordStr_mut, SAFEARR_BRECORD);
67 UNION!(__MIDL_IOleAutomationTypes_0001, data0, HaveIidStr, HaveIidStr_mut, SAFEARR_HAVEIID);
68 UNION!(__MIDL_IOleAutomationTypes_0001, data0, ByteStr, ByteStr_mut, ::BYTE_SIZEDARR);
69 UNION!(__MIDL_IOleAutomationTypes_0001, data0, WordStr, WordStr_mut, ::WORD_SIZEDARR);
70 UNION!(__MIDL_IOleAutomationTypes_0001, data0, LongStr, LongStr_mut, ::DWORD_SIZEDARR);
71 UNION!(__MIDL_IOleAutomationTypes_0001, data0, HyperStr, HyperStr_mut, ::HYPER_SIZEDARR);
72 STRUCT!{struct _wireSAFEARRAY {
73     cDims: ::USHORT,
74     fFeatures: ::USHORT,
75     cbElements: ::ULONG,
76     cLocks: ::ULONG,
77     uArrayStructs: SAFEARRAYUNION,
78     rgsaBound: [SAFEARRAYBOUND; 1],
79 }}
80 pub type wireSAFEARRAY = *mut _wireSAFEARRAY;
81 pub type wirePSAFEARRAY = *mut wireSAFEARRAY;
82 STRUCT!{struct SAFEARRAY {
83     cDims: ::USHORT,
84     fFeatures: ::USHORT,
85     cbElements: ::ULONG,
86     cLocks: ::ULONG,
87     pvData: ::PVOID,
88     rgsabound: [SAFEARRAYBOUND; 1],
89 }}
90 pub type LPSAFEARRAY = *mut SAFEARRAY;
91 pub const FADF_AUTO: ::DWORD = 0x1;
92 pub const FADF_STATIC: ::DWORD = 0x2;
93 pub const FADF_EMBEDDED: ::DWORD = 0x4;
94 pub const FADF_FIXEDSIZE: ::DWORD = 0x10;
95 pub const FADF_RECORD: ::DWORD = 0x20;
96 pub const FADF_HAVEIID: ::DWORD = 0x40;
97 pub const FADF_HAVEVARTYPE: ::DWORD = 0x80;
98 pub const FADF_BSTR: ::DWORD = 0x100;
99 pub const FADF_UNKNOWN: ::DWORD = 0x200;
100 pub const FADF_DISPATCH: ::DWORD = 0x400;
101 pub const FADF_VARIANT: ::DWORD = 0x800;
102 pub const FADF_RESERVED: ::DWORD = 0xf008;
103 #[cfg(target_arch = "x86_64")]
104 STRUCT!{struct VARIANT {
105     data0: u64,
106     data1: u64,
107     data2: u64,
108 }}
109 #[cfg(target_arch = "x86")]
110 STRUCT!{struct VARIANT {
111     data0: u64,
112     data1: u32,
113     data2: u32,
114 }}
115 UNION!(VARIANT, data0, vt, vt_mut, ::VARTYPE);
116 UNION!(VARIANT, data1, llVal, llVal_mut, ::LONGLONG);
117 UNION!(VARIANT, data1, lVal, lVal_mut, ::LONG);
118 UNION!(VARIANT, data1, bVal, bVal_mut, ::BYTE);
119 UNION!(VARIANT, data1, iVal, iVal_mut, ::SHORT);
120 UNION!(VARIANT, data1, fltVal, fltVal_mut, ::FLOAT);
121 UNION!(VARIANT, data1, dblVal, dblVal_mut, ::DOUBLE);
122 UNION!(VARIANT, data1, boolVal, boolVal_mut, ::VARIANT_BOOL);
123 UNION!(VARIANT, data1, scode, scode_mut, ::SCODE);
124 UNION!(VARIANT, data1, cyVal, cyVal_mut, ::CY);
125 UNION!(VARIANT, data1, date, date_mut, ::DATE);
126 UNION!(VARIANT, data1, bstrVal, bstrVal_mut, ::BSTR);
127 UNION!(VARIANT, data1, punkVal, punkVal_mut, *mut ::IUnknown);
128 UNION!(VARIANT, data1, pdispVal, pdispVal_mut, *mut IDispatch);
129 UNION!(VARIANT, data1, parray, parray_mut, *mut SAFEARRAY);
130 UNION!(VARIANT, data1, pllVal, pllVal_mut, *mut ::LONGLONG);
131 UNION!(VARIANT, data1, plVal, plVal_mut, *mut ::LONG);
132 UNION!(VARIANT, data1, pbVal, pbVal_mut, *mut ::BYTE);
133 UNION!(VARIANT, data1, piVal, piVal_mut, *mut ::SHORT);
134 UNION!(VARIANT, data1, pfltVal, pfltVal_mut, *mut ::FLOAT);
135 UNION!(VARIANT, data1, pdblVal, pdblVal_mut, *mut ::DOUBLE);
136 UNION!(VARIANT, data1, pboolVal, pboolVal_mut, *mut ::VARIANT_BOOL);
137 UNION!(VARIANT, data1, pscode, pscode_mut, *mut ::SCODE);
138 UNION!(VARIANT, data1, pcyVal, pcyVal_mut, *mut ::CY);
139 UNION!(VARIANT, data1, pdate, pdate_mut, *mut ::DATE);
140 UNION!(VARIANT, data1, pbstrVal, pbstrVal_mut, *mut ::BSTR);
141 UNION!(VARIANT, data1, ppunkVal, ppunkVal_mut, *mut *mut ::IUnknown);
142 UNION!(VARIANT, data1, ppdispVal, ppdispVal_mut, *mut *mut IDispatch);
143 UNION!(VARIANT, data1, pparray, pparray_mut, *mut *mut SAFEARRAY);
144 UNION!(VARIANT, data1, pvarVal, pvarVal_mut, *mut VARIANT);
145 UNION!(VARIANT, data1, byref, byref_mut, ::PVOID);
146 UNION!(VARIANT, data1, cVal, cVal_mut, ::CHAR);
147 UNION!(VARIANT, data1, uiVal, uiVal_mut, ::USHORT);
148 UNION!(VARIANT, data1, ulVal, ulVal_mut, ::ULONG);
149 UNION!(VARIANT, data1, ullVal, ullVal_mut, ::ULONGLONG);
150 UNION!(VARIANT, data1, intVal, intVal_mut, ::INT);
151 UNION!(VARIANT, data1, uintVal, uintVal_mut, ::UINT);
152 UNION!(VARIANT, data1, pdecVal, pdecVal_mut, *mut ::DECIMAL);
153 UNION!(VARIANT, data1, pcVal, pcVal_mut, *mut ::CHAR);
154 UNION!(VARIANT, data1, puiVal, puiVal_mut, *mut ::USHORT);
155 UNION!(VARIANT, data1, pulVal, pulVal_mut, *mut ::ULONG);
156 UNION!(VARIANT, data1, pullVal, pullVal_mut, *mut ::ULONGLONG);
157 UNION!(VARIANT, data1, pintVal, pintVal_mut, *mut ::INT);
158 UNION!(VARIANT, data1, puintVal, puintVal_mut, *mut ::UINT);
159 UNION!(VARIANT, data1, pvRecord, pvRecord_mut, ::PVOID);
160 UNION!(VARIANT, data2, pRecInfo, pRecInfo_mut, *mut IRecordInfo);
161 UNION!(VARIANT, data0, decVal, decVal_mut, ::DECIMAL);
162 pub type LPVARIANT = *mut VARIANT;
163 pub type VARIANTARG = VARIANT;
164 pub type LPVARIANTARG = *mut VARIANT;
165 pub type REFVARIANT = *const VARIANT;
166 STRUCT!{struct _wireBRECORD {
167     fFlags: ::ULONG,
168     clSize: ::ULONG,
169     pRecInfo: *mut IRecordInfo,
170     pRecord: *mut ::BYTE,
171 }}
172 STRUCT!{struct _wireVARIANT {
173     clSize: ::DWORD,
174     rpcReserved: ::DWORD,
175     vt: ::USHORT,
176     wReserved1: ::USHORT,
177     wReserved2: ::USHORT,
178     wReserved3: ::USHORT,
179     data0: u64,
180     data1: u64,
181 }}
182 UNION!(_wireVARIANT, data0, llVal, llVal_mut, ::LONGLONG);
183 UNION!(_wireVARIANT, data0, lVal, lVal_mut, ::LONG);
184 UNION!(_wireVARIANT, data0, bVal, bVal_mut, ::BYTE);
185 UNION!(_wireVARIANT, data0, iVal, iVal_mut, ::SHORT);
186 UNION!(_wireVARIANT, data0, fltVal, fltVal_mut, ::FLOAT);
187 UNION!(_wireVARIANT, data0, dblVal, dblVal_mut, ::DOUBLE);
188 UNION!(_wireVARIANT, data0, boolVal, boolVal_mut, ::VARIANT_BOOL);
189 UNION!(_wireVARIANT, data0, scode, scode_mut, ::SCODE);
190 UNION!(_wireVARIANT, data0, cyVal, cyVal_mut, ::CY);
191 UNION!(_wireVARIANT, data0, date, date_mut, ::DATE);
192 UNION!(_wireVARIANT, data0, bstrVal, bstrVal_mut, ::wireBSTR);
193 UNION!(_wireVARIANT, data0, punkVal, punkVal_mut, *mut ::IUnknown);
194 UNION!(_wireVARIANT, data0, pdispVal, pdispVal_mut, *mut IDispatch);
195 UNION!(_wireVARIANT, data0, parray, parray_mut, wirePSAFEARRAY);
196 UNION!(_wireVARIANT, data0, brecVal, brecVal_mut, wireBRECORD);
197 UNION!(_wireVARIANT, data0, pllVal, pllVal_mut, *mut ::LONGLONG);
198 UNION!(_wireVARIANT, data0, plVal, plVal_mut, *mut ::LONG);
199 UNION!(_wireVARIANT, data0, pbVal, pbVal_mut, *mut ::BYTE);
200 UNION!(_wireVARIANT, data0, piVal, piVal_mut, *mut ::SHORT);
201 UNION!(_wireVARIANT, data0, pfltVal, pfltVal_mut, *mut ::FLOAT);
202 UNION!(_wireVARIANT, data0, pdblVal, pdblVal_mut, *mut ::DOUBLE);
203 UNION!(_wireVARIANT, data0, pboolVal, pboolVal_mut, *mut ::VARIANT_BOOL);
204 UNION!(_wireVARIANT, data0, pscode, pscode_mut, *mut ::SCODE);
205 UNION!(_wireVARIANT, data0, pcyVal, pcyVal_mut, *mut ::CY);
206 UNION!(_wireVARIANT, data0, pdate, pdate_mut, *mut ::DATE);
207 UNION!(_wireVARIANT, data0, pbstrVal, pbstrVal_mut, *mut ::wireBSTR);
208 UNION!(_wireVARIANT, data0, ppunkVal, ppunkVal_mut, *mut *mut ::IUnknown);
209 UNION!(_wireVARIANT, data0, ppdispVal, ppdispVal_mut, *mut *mut IDispatch);
210 UNION!(_wireVARIANT, data0, pparray, pparray_mut, *mut wirePSAFEARRAY);
211 UNION!(_wireVARIANT, data0, pvarVal, pvarVal_mut, *mut wireVARIANT);
212 UNION!(_wireVARIANT, data0, cVal, cVal_mut, ::CHAR);
213 UNION!(_wireVARIANT, data0, uiVal, uiVal_mut, ::USHORT);
214 UNION!(_wireVARIANT, data0, ulVal, ulVal_mut, ::ULONG);
215 UNION!(_wireVARIANT, data0, ullVal, ullVal_mut, ::ULONGLONG);
216 UNION!(_wireVARIANT, data0, intVal, intVal_mut, ::INT);
217 UNION!(_wireVARIANT, data0, uintVal, uintVal_mut, ::UINT);
218 UNION!(_wireVARIANT, data0, decVal, decVal_mut, ::DECIMAL);
219 UNION!(_wireVARIANT, data0, pcVal, pcVal_mut, *mut ::CHAR);
220 UNION!(_wireVARIANT, data0, puiVal, puiVal_mut, *mut ::USHORT);
221 UNION!(_wireVARIANT, data0, pulVal, pulVal_mut, *mut ::ULONG);
222 UNION!(_wireVARIANT, data0, pullVal, pullVal_mut, *mut ::ULONGLONG);
223 UNION!(_wireVARIANT, data0, pintVal, pintVal_mut, *mut ::INT);
224 UNION!(_wireVARIANT, data0, puintVal, puintVal_mut, *mut ::UINT);
225 UNION!(_wireVARIANT, data0, pdecVal, pdecVal_mut, *mut ::DECIMAL);
226 pub type DISPID = ::LONG;
227 pub type MEMBERID = DISPID;
228 pub type HREFTYPE = ::DWORD;
229 ENUM!{enum TYPEKIND {
230     TKIND_ENUM = 0,
231     TKIND_RECORD,
232     TKIND_MODULE,
233     TKIND_INTERFACE,
234     TKIND_DISPATCH,
235     TKIND_COCLASS,
236     TKIND_ALIAS,
237     TKIND_UNION,
238     TKIND_MAX,
239 }}
240 #[cfg(target_arch = "x86_64")]
241 STRUCT!{struct TYPEDESC {
242     data: u64,
243     vt: ::VARTYPE,
244 }}
245 #[cfg(target_arch = "x86")]
246 STRUCT!{struct TYPEDESC {
247     data: u32,
248     vt: ::VARTYPE,
249 }}
250 UNION!(TYPEDESC, data, lptdesc, lptdesc_mut, *mut TYPEDESC);
251 UNION!(TYPEDESC, data, lpadesc, lpadesc_mut, *mut ARRAYDESC);
252 UNION!(TYPEDESC, data, hreftype, hreftype_mut, HREFTYPE);
253 STRUCT!{struct ARRAYDESC {
254     tdescElem: TYPEDESC,
255     cDims: ::USHORT,
256     rgbounds: [SAFEARRAYBOUND; 1],
257 }}
258 STRUCT!{struct PARAMDESCEX {
259     cBytes: ::ULONG,
260     varDefaultValue: VARIANTARG,
261 }}
262 pub type LPPARAMDESCEX = *mut PARAMDESCEX;
263 STRUCT!{struct PARAMDESC {
264     pparamdescex: LPPARAMDESCEX,
265     wParamFlags: ::USHORT,
266 }}
267 pub type LPPARAMDESC = *mut PARAMDESC;
268 pub const PARAMFLAG_NONE: ::DWORD = 0;
269 pub const PARAMFLAG_FIN: ::DWORD = 0x1;
270 pub const PARAMFLAG_FOUT: ::DWORD = 0x2;
271 pub const PARAMFLAG_FLCID: ::DWORD = 0x4;
272 pub const PARAMFLAG_FRETVAL: ::DWORD = 0x8;
273 pub const PARAMFLAG_FOPT: ::DWORD = 0x10;
274 pub const PARAMFLAG_FHASDEFAULT: ::DWORD = 0x20;
275 pub const PARAMFLAG_FHASCUSTDATA: ::DWORD = 0x40;
276 STRUCT!{struct IDLDESC {
277     dwReserved: ::ULONG_PTR,
278     wIDLFlags: ::USHORT,
279 }}
280 pub type LPIDLDESC = *mut IDLDESC;
281 pub const IDLFLAG_NONE: ::DWORD = PARAMFLAG_NONE;
282 pub const IDLFLAG_FIN: ::DWORD = PARAMFLAG_FIN;
283 pub const IDLFLAG_FOUT: ::DWORD = PARAMFLAG_FOUT;
284 pub const IDLFLAG_FLCID: ::DWORD = PARAMFLAG_FLCID;
285 pub const IDLFLAG_FRETVAL: ::DWORD = PARAMFLAG_FRETVAL;
286 STRUCT!{struct ELEMDESC {
287     tdesc: TYPEDESC,
288     idldesc: IDLDESC,
289 }}
290 UNION!(ELEMDESC, idldesc, paramdesc, paramdesc_mut, PARAMDESC);
291 pub type LPELEMDESC = *mut ELEMDESC;
292 STRUCT!{struct TYPEATTR {
293     guid: ::GUID,
294     lcid: ::LCID,
295     dwReserved: ::DWORD,
296     memidConstructor: ::MEMBERID,
297     memidDestructor: ::MEMBERID,
298     lpstrSchema: ::LPOLESTR,
299     cbSizeInstance: ::ULONG,
300     typekind: ::TYPEKIND,
301     cFuncs: ::WORD,
302     cVars: ::WORD,
303     cImplTypes: ::WORD,
304     cbSizeVft: ::WORD,
305     cbAlignment: ::WORD,
306     wTypeFlags: ::WORD,
307     wMajorVerNum: ::WORD,
308     wMinorVerNum: ::WORD,
309     tdescAlias: ::TYPEDESC,
310     idldescType: ::IDLDESC,
311 }}
312 pub type LPTYPEATTR = *mut TYPEATTR;
313 STRUCT!{struct DISPPARAMS {
314     rgvarg: *mut VARIANTARG,
315     rgdispidNamedArgs: *mut DISPID,
316     cArgs: ::UINT,
317     cNamedArgs: ::UINT,
318 }}
319 STRUCT!{nodebug struct EXCEPINFO {
320     wCode: ::WORD,
321     wReserved: ::WORD,
322     bstrSource: ::BSTR,
323     bstrDescription: ::BSTR,
324     bstrHelpFile: ::BSTR,
325     dwHelpContext: ::DWORD,
326     pvReserved: ::PVOID,
327     pfnDeferredFillIn: Option<unsafe extern "system" fn(einfo: *mut EXCEPINFO) -> ::HRESULT>,
328     scode: ::SCODE,
329 }}
330 ENUM!{enum CALLCONV {
331     CC_FASTCALL = 0,
332     CC_CDECL = 1,
333     CC_MSCPASCAL,
334     CC_PASCAL,
335     CC_MACPASCAL,
336     CC_STDCALL,
337     CC_FPFASTCALL,
338     CC_SYSCALL,
339     CC_MPWCDECL,
340     CC_MPWPASCAL,
341     CC_MAX,
342 }}
343 ENUM!{enum FUNCKIND {
344     FUNC_VIRTUAL = 0,
345     FUNC_PUREVIRTUAL,
346     FUNC_NONVIRTUAL,
347     FUNC_STATIC,
348     FUNC_DISPATCH,
349 }}
350 FLAGS!{enum INVOKEKIND {
351     INVOKE_FUNC = 1,
352     INVOKE_PROPERTYGET = 2,
353     INVOKE_PROPERTYPUT = 4,
354     INVOKE_PROPERTYPUTREF = 8,
355 }}
356 STRUCT!{struct FUNCDESC {
357     memid: ::MEMBERID,
358     lprgscode: *mut ::SCODE,
359     lprgelemdescParam: *mut ::ELEMDESC,
360     funckind: ::FUNCKIND,
361     invkind: ::INVOKEKIND,
362     callconv: ::CALLCONV,
363     cParams: ::SHORT,
364     cParamsOpt: ::SHORT,
365     oVft: ::SHORT,
366     cScodes: ::SHORT,
367     elemdescFunc: ::ELEMDESC,
368     wFuncFlags: ::WORD,
369 }}
370 pub type LPFUNCDESC = *mut FUNCDESC;
371 ENUM!{enum VARKIND {
372     VAR_PERINSTANCE = 0,
373     VAR_STATIC,
374     VAR_CONST,
375     VAR_DISPATCH,
376 }}
377 pub const IMPLTYPEFLAG_FDEFAULT: ::DWORD = 0x1;
378 pub const IMPLTYPEFLAG_FSOURCE: ::DWORD = 0x2;
379 pub const IMPLTYPEFLAG_FRESTRICTED: ::DWORD = 0x4;
380 pub const IMPLTYPEFLAG_FDEFAULTVTABLE: ::DWORD = 0x8;
381 STRUCT!{struct VARDESC {
382     memid: MEMBERID,
383     lpstrSchema: ::LPOLESTR,
384     lpvarValue: *mut VARIANT,
385     elemdescVar: ::ELEMDESC,
386     wVarFlags: ::WORD,
387     varkind: VARKIND,
388 }}
389 UNION!(VARDESC, lpvarValue, oInst, oInst_mut, ::ULONG);
390 pub type LPVARDESC = *mut VARDESC;
391 FLAGS!{enum TYPEFLAGS {
392     TYPEFLAG_FAPPOBJECT = 0x1,
393     TYPEFLAG_FCANCREATE = 0x2,
394     TYPEFLAG_FLICENSED  = 0x4,
395     TYPEFLAG_FPREDECLID = 0x8,
396     TYPEFLAG_FHIDDEN = 0x10,
397     TYPEFLAG_FCONTROL = 0x20,
398     TYPEFLAG_FDUAL = 0x40,
399     TYPEFLAG_FNONEXTENSIBLE = 0x80,
400     TYPEFLAG_FOLEAUTOMATION = 0x100,
401     TYPEFLAG_FRESTRICTED = 0x200,
402     TYPEFLAG_FAGGREGATABLE = 0x400,
403     TYPEFLAG_FREPLACEABLE = 0x800,
404     TYPEFLAG_FDISPATCHABLE = 0x1000,
405     TYPEFLAG_FREVERSEBIND = 0x2000,
406     TYPEFLAG_FPROXY = 0x4000,
407 }}
408 FLAGS!{enum FUNCFLAGS {
409     FUNCFLAG_FRESTRICTED = 0x1,
410     FUNCFLAG_FSOURCE = 0x2,
411     FUNCFLAG_FBINDABLE = 0x4,
412     FUNCFLAG_FREQUESTEDIT = 0x8,
413     FUNCFLAG_FDISPLAYBIND = 0x10,
414     FUNCFLAG_FDEFAULTBIND = 0x20,
415     FUNCFLAG_FHIDDEN = 0x40,
416     FUNCFLAG_FUSESGETLASTERROR = 0x80,
417     FUNCFLAG_FDEFAULTCOLLELEM = 0x100,
418     FUNCFLAG_FUIDEFAULT = 0x200,
419     FUNCFLAG_FNONBROWSABLE = 0x400,
420     FUNCFLAG_FREPLACEABLE = 0x800,
421     FUNCFLAG_FIMMEDIATEBIND = 0x1000,
422 }}
423 FLAGS!{enum VARFLAGS {
424     VARFLAG_FREADONLY = 0x1,
425     VARFLAG_FSOURCE = 0x2,
426     VARFLAG_FBINDABLE = 0x4,
427     VARFLAG_FREQUESTEDIT = 0x8,
428     VARFLAG_FDISPLAYBIND = 0x10,
429     VARFLAG_FDEFAULTBIND = 0x20,
430     VARFLAG_FHIDDEN = 0x40,
431     VARFLAG_FRESTRICTED = 0x80,
432     VARFLAG_FDEFAULTCOLLELEM = 0x100,
433     VARFLAG_FUIDEFAULT = 0x200,
434     VARFLAG_FNONBROWSABLE = 0x400,
435     VARFLAG_FREPLACEABLE = 0x800,
436     VARFLAG_FIMMEDIATEBIND = 0x1000,
437 }}
438 STRUCT!{struct CLEANLOCALSTORAGE {
439     pInterface: *mut ::IUnknown,
440     pStorage: ::PVOID,
441     flags: ::DWORD,
442 }}
443 STRUCT!{struct CUSTDATAITEM {
444     guid: ::GUID,
445     varValue: VARIANTARG,
446 }}
447 pub type LPCUSTDATAITEM = *mut CUSTDATAITEM;
448 STRUCT!{struct CUSTDATA {
449     cCustData: ::DWORD,
450     prgCustData: LPCUSTDATAITEM,
451 }}
452 pub type LPCUSTDATA = *mut CUSTDATA;
453 pub type LPCREATETYPEINFO = *mut ICreateTypeInfo;
454 RIDL!(
455 interface ICreateTypeInfo(ICreateTypeInfoVtbl): IUnknown(IUnknownVtbl) {
456     fn SetGuid(&mut self, guid: ::REFGUID) -> ::HRESULT,
457     fn SetTypeFlags(&mut self, uTypeFlags: ::UINT) -> ::HRESULT,
458     fn SetDocString(&mut self, pStrDoc: ::LPOLESTR) -> ::HRESULT,
459     fn SetHelpContext(&mut self, dwHelpContext: ::DWORD) -> ::HRESULT,
460     fn SetVersion(&mut self, wMajorVerNum: ::WORD, wMinorVerNum: ::WORD) -> ::HRESULT,
461     fn AddRefTypeInfo(&mut self, pTInfo: *mut ITypeInfo) -> ::HRESULT,
462     fn AddFuncDesc(&mut self, index: ::UINT, pFuncDesc: *mut FUNCDESC) -> ::HRESULT,
463     fn SetImplTypeFlags(&mut self, index: ::UINT, implTypeFlags: ::INT) -> ::HRESULT,
464     fn SetAlignment(&mut self, cbAlignment: ::WORD) -> ::HRESULT,
465     fn SetSchema(&mut self, pStrSchema: ::LPOLESTR) -> ::HRESULT,
466     fn AddVarDesc(&mut self, index: ::UINT, pVarDesc: *mut VARDESC) -> ::HRESULT,
467     fn SetFuncAndParamNames(
468         &mut self, index: ::UINT, rgszNames: *mut ::LPOLESTR, cNames: ::UINT
469     ) -> ::HRESULT,
470     fn SetVarName(&mut self, index: ::UINT, szName: ::LPOLESTR) -> ::HRESULT,
471     fn SetTypeDescAlias(&mut self, pTDescAlias: *mut TYPEDESC) -> ::HRESULT,
472     fn DefineFuncAsDllEntry(
473         &mut self, index: ::UINT, szDllName: ::LPOLESTR, szProcName: ::LPOLESTR
474     ) -> ::HRESULT,
475     fn SetFuncDocString(&mut self, index: ::UINT, szDocString: ::LPOLESTR) -> ::HRESULT,
476     fn SetVarDocString(&mut self, index: ::UINT, szDocString: ::LPOLESTR) -> ::HRESULT,
477     fn SetFuncHelpContext(&mut self, index: ::UINT, dwHelpContext: ::DWORD) -> ::HRESULT,
478     fn SetVarHelpContext(&mut self, index: ::UINT, dwHelpContext: ::DWORD) -> ::HRESULT,
479     fn SetMops(&mut self, index: ::UINT, bstrMops: ::BSTR) -> ::HRESULT,
480     fn SetTypeIdldesc(&mut self, pIdlDesc: *mut IDLDESC) -> ::HRESULT,
481     fn LayOut(&mut self) -> ::HRESULT
482 }
483 );
484 // FIXME: Implement these interfaces
485 #[repr(C)] #[derive(Clone, Copy, Debug)]
486 pub struct ICreateTypeInfo2;
487 #[repr(C)] #[derive(Clone, Copy, Debug)]
488 pub struct ICreateTypeLib;
489 #[repr(C)] #[derive(Clone, Copy, Debug)]
490 pub struct ICreateTypeLib2;
491 pub type LPDISPATCH = *mut IDispatch;
492 pub const DISPID_UNKNOWN: ::INT = -1;
493 pub const DISPID_VALUE: ::INT = 0;
494 pub const DISPID_PROPERTYPUT: ::INT = -3;
495 pub const DISPID_NEWENUM: ::INT = -4;
496 pub const DISPID_EVALUATE: ::INT = -5;
497 pub const DISPID_CONSTRUCTOR: ::INT = -6;
498 pub const DISPID_DESTRUCTOR: ::INT = -7;
499 pub const DISPID_COLLECT: ::INT = -8;
500 RIDL!(
501 interface IDispatch(IDispatchVtbl): IUnknown(IUnknownVtbl) {
502     fn GetTypeInfoCount(&mut self, pctinfo: *mut ::UINT) -> ::HRESULT,
503     fn GetTypeInfo(
504         &mut self, iTInfo: ::UINT, lcid: ::LCID, ppTInfo: *mut *mut ITypeInfo
505     ) -> ::HRESULT,
506     fn GetIDsOfNames(
507         &mut self, riid: ::REFIID, rgszNames: *mut ::LPOLESTR, cNames: ::UINT, lcid: ::LCID,
508         rgDispId: *mut ::DISPID
509     ) -> ::HRESULT,
510     fn Invoke(
511         &mut self, dispIdMember: ::DISPID, riid: ::REFIID, lcid: ::LCID, wFlags: ::WORD,
512         pDispParams: *mut ::DISPPARAMS, pVarResult: *mut VARIANT, pExcepInfo: *mut ::EXCEPINFO,
513         puArgErr: *mut ::UINT
514     ) -> ::HRESULT
515 }
516 );
517 // FIXME: Implement these interfaces
518 #[repr(C)] #[derive(Clone, Copy, Debug)]
519 pub struct IEnumVARIANT;
520 #[repr(C)] #[derive(Clone, Copy, Debug)]
521 pub struct ITypeComp;
522 RIDL!(
523 interface ITypeInfo(ITypeInfoVtbl): IUnknown(IUnknownVtbl) {
524     fn GetTypeAttr(&mut self, ppTypeAttr: *mut *mut TYPEATTR) -> ::HRESULT,
525     fn GetTypeComp(&mut self, ppTComp: *mut *mut ITypeComp) -> ::HRESULT,
526     fn GetFuncDesc(&mut self, index: ::UINT, ppFunDesc: *mut *mut FUNCDESC) -> ::HRESULT,
527     fn GetVarDesc(&mut self, index: ::UINT, pPVarDesc: *mut *mut VARDESC) -> ::HRESULT,
528     fn GetNames(
529         &mut self, memid: MEMBERID, rgBstrNames: *mut ::BSTR, cMaxNames: ::UINT,
530         pcNames: *mut ::UINT
531     ) -> ::HRESULT,
532     fn GetRefTypeOfImplType(&mut self, index: ::UINT, pRefType: *mut HREFTYPE) -> ::HRESULT,
533     fn GetImplTypeFlags(&mut self, index: ::UINT, pImplTypeFlags: *mut ::INT) -> ::HRESULT,
534     fn GetIDsOfNames(
535         &mut self, rgszNames: *mut ::LPOLESTR, cNames: ::UINT, pMemId: *mut MEMBERID
536     ) -> ::HRESULT,
537     fn Invoke(
538         &mut self, pvInstance: ::PVOID, memid: MEMBERID, wFlags: ::WORD,
539         pDispParams: *mut DISPPARAMS, pVarResult: *mut VARIANT, pExcepInfo: *mut EXCEPINFO,
540         puArgErr: *mut ::UINT
541     ) -> ::HRESULT,
542     fn GetDocumentation(
543         &mut self, memid: MEMBERID, pBstrName: *mut ::BSTR, pBstrDocString: *mut ::BSTR,
544         pdwHelpContext: *mut ::DWORD, pBstrHelpFile: *mut ::BSTR
545     ) -> ::HRESULT,
546     fn GetDllEntry(
547         &mut self, memid: MEMBERID, invKind: ::INVOKEKIND, pBstrDllName: *mut ::BSTR,
548         pBstrName: *mut ::BSTR, pwOrdinal: *mut ::WORD
549     ) -> ::HRESULT,
550     fn GetRefTypeInfo(&mut self, hRefType: HREFTYPE, ppTInfo: *mut *mut ITypeInfo) -> ::HRESULT,
551     fn AddressOfMember(
552         &mut self, memid: MEMBERID, invKind: ::INVOKEKIND, ppv: *mut ::PVOID
553     ) -> ::HRESULT,
554     fn CreateInstance(
555         &mut self, pUnkOuter: *mut ::IUnknown, riid: ::REFIID, ppvObj: *mut ::PVOID
556     ) -> ::HRESULT,
557     fn GetMops(&mut self, memid: MEMBERID, pBstrMops: *mut ::BSTR) -> ::HRESULT,
558     fn GetContainingTypeLib(
559         &mut self, ppTLib: *mut *mut ITypeLib, pIndex: *mut ::UINT
560     ) -> ::HRESULT,
561     fn ReleaseTypeAttr(&mut self, pTypeAttr: *mut TYPEATTR) -> (),
562     fn ReleaseFuncDesc(&mut self, pFuncDesc: *mut FUNCDESC) -> (),
563     fn ReleaseVarDesc(&mut self, pVarDesc: *mut VARDESC) -> ()
564 }
565 );
566 // FIXME: Implement these interfaces
567 #[repr(C)] #[derive(Clone, Copy, Debug)]
568 pub struct ITypeInfo2;
569 #[repr(C)] #[derive(Clone, Copy, Debug)]
570 pub struct ITypeLib;
571 #[repr(C)] #[derive(Clone, Copy, Debug)]
572 pub struct ITypeLib2;
573 #[repr(C)] #[derive(Clone, Copy, Debug)]
574 pub struct ITypeChangeEvents;
575 #[repr(C)] #[derive(Clone, Copy, Debug)]
576 pub struct IErrorInfo;
577 #[repr(C)] #[derive(Clone, Copy, Debug)]
578 pub struct ICreateErrorInfo;
579 #[repr(C)] #[derive(Clone, Copy, Debug)]
580 pub struct ISupportErrorInfo;
581 #[repr(C)] #[derive(Clone, Copy, Debug)]
582 pub struct ITypeFactory;
583 #[repr(C)] #[derive(Clone, Copy, Debug)]
584 pub struct ITypeMarshal;
585 #[repr(C)] #[derive(Clone, Copy, Debug)]
586 pub struct IRecordInfo;
587 #[repr(C)] #[derive(Clone, Copy, Debug)]
588 pub struct IErrorLog;
589 #[repr(C)] #[derive(Clone, Copy, Debug)]
590 pub struct IPropertyBag;
591