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