vendor/winapi-0.3.3/src/um/oaidl.rs

   1 // Copyright © 2015-2017 winapi-rs developers
   2 // Licensed under the Apache License, Version 2.0
   3 // <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   4 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
   5 // All files in the project carrying such notice may not be copied, modified, or distributed
   6 // except according to those terms.
   7 //! Mappings for the contents of OAIdl.h
   8 use shared::basetsd::ULONG_PTR;
   9 use shared::guiddef::{GUID, IID, REFGUID, REFIID};
  10 use shared::minwindef::{BOOL, BYTE, DWORD, FLOAT, INT, UINT, ULONG, USHORT, WORD};
  11 use shared::rpcndr::byte;
  12 use shared::wtypes::{
  13     BSTR, CY, DATE, DECIMAL, VARIANT_BOOL, VARTYPE, VT_BSTR, VT_DISPATCH, VT_ERROR,
  14     VT_I1, VT_I2, VT_I4, VT_I8, VT_RECORD, VT_RESERVED, VT_UNKNOWN, VT_VARIANT,
  15     wireBSTR
  16 };
  17 use shared::wtypesbase::{
  18     BYTE_SIZEDARR, DOUBLE, DWORD_SIZEDARR, HYPER_SIZEDARR, LPCOLESTR, LPOLESTR, SCODE,
  19     WORD_SIZEDARR
  20 };
  21 use um::unknwnbase::{IUnknown, IUnknownVtbl};
  22 use um::winnt::{CHAR, HRESULT, LCID, LONG, LONGLONG, PVOID, SHORT, ULONGLONG};
  23 pub type CURRENCY = CY;
  24 STRUCT!{struct SAFEARRAYBOUND {
  25     cElements: ULONG,
  26     lLbound: LONG,
  27 }}
  28 pub type LPSAFEARRAYBOUND = *mut SAFEARRAYBOUND;
  29 pub type wireBRECORD = *mut _wireBRECORD;
  30 pub type wireVARIANT = *mut _wireVARIANT;
  31 STRUCT!{struct SAFEARR_BSTR {
  32     Size: ULONG,
  33     aBstr: *mut wireBSTR,
  34 }}
  35 STRUCT!{struct SAFEARR_UNKNOWN {
  36     Size: ULONG,
  37     apUnknown: *mut *mut IUnknown,
  38 }}
  39 STRUCT!{struct SAFEARR_DISPATCH {
  40     Size: ULONG,
  41     apDispatch: *mut *mut IDispatch,
  42 }}
  43 STRUCT!{struct SAFEARR_VARIANT {
  44     Size: ULONG,
  45     aVariant: *mut wireVARIANT,
  46 }}
  47 STRUCT!{struct SAFEARR_BRECORD {
  48     Size: ULONG,
  49     aRecord: *mut wireBRECORD,
  50 }}
  51 STRUCT!{struct SAFEARR_HAVEIID {
  52     Size: ULONG,
  53     apUnknown: *mut *mut IUnknown,
  54     iid: IID,
  55 }}
  56 ENUM!{enum SF_TYPE {
  57     SF_ERROR = VT_ERROR,
  58     SF_I1 = VT_I1,
  59     SF_I2 = VT_I2,
  60     SF_I4 = VT_I4,
  61     SF_I8 = VT_I8,
  62     SF_BSTR = VT_BSTR,
  63     SF_UNKNOWN = VT_UNKNOWN,
  64     SF_DISPATCH = VT_DISPATCH,
  65     SF_VARIANT = VT_VARIANT,
  66     SF_RECORD = VT_RECORD,
  67     SF_HAVEIID = VT_UNKNOWN | VT_RESERVED,
  68 }}
  69 #[cfg(target_arch = "x86")]
  70 UNION!{union __MIDL_IOleAutomationTypes_0001 {
  71     [u32; 6],
  72     BstrStr BstrStr_mut: SAFEARR_BSTR,
  73     UnknownStr UnknownStr_mut: SAFEARR_UNKNOWN,
  74     DispatchStr DispatchStr_mut: SAFEARR_DISPATCH,
  75     VariantStr VariantStr_mut: SAFEARR_VARIANT,
  76     RecordStr RecordStr_mut: SAFEARR_BRECORD,
  77     HaveIidStr HaveIidStr_mut: SAFEARR_HAVEIID,
  78     ByteStr ByteStr_mut: BYTE_SIZEDARR,
  79     WordStr WordStr_mut: WORD_SIZEDARR,
  80     LongStr LongStr_mut: DWORD_SIZEDARR,
  81     HyperStr HyperStr_mut: HYPER_SIZEDARR,
  82 }}
  83 #[cfg(target_arch = "x86_64")]
  84 UNION!{union __MIDL_IOleAutomationTypes_0001 {
  85     [u64; 4],
  86     BstrStr BstrStr_mut: SAFEARR_BSTR,
  87     UnknownStr UnknownStr_mut: SAFEARR_UNKNOWN,
  88     DispatchStr DispatchStr_mut: SAFEARR_DISPATCH,
  89     VariantStr VariantStr_mut: SAFEARR_VARIANT,
  90     RecordStr RecordStr_mut: SAFEARR_BRECORD,
  91     HaveIidStr HaveIidStr_mut: SAFEARR_HAVEIID,
  92     ByteStr ByteStr_mut: BYTE_SIZEDARR,
  93     WordStr WordStr_mut: WORD_SIZEDARR,
  94     LongStr LongStr_mut: DWORD_SIZEDARR,
  95     HyperStr HyperStr_mut: HYPER_SIZEDARR,
  96 }}
  97 STRUCT!{struct SAFEARRAYUNION {
  98     sfType: ULONG,
  99     u: __MIDL_IOleAutomationTypes_0001,
 100 }}
 101 STRUCT!{struct _wireSAFEARRAY {
 102     cDims: USHORT,
 103     fFeatures: USHORT,
 104     cbElements: ULONG,
 105     cLocks: ULONG,
 106     uArrayStructs: SAFEARRAYUNION,
 107     rgsaBound: [SAFEARRAYBOUND; 1],
 108 }}
 109 pub type wireSAFEARRAY = *mut _wireSAFEARRAY;
 110 pub type wirePSAFEARRAY = *mut wireSAFEARRAY;
 111 STRUCT!{struct SAFEARRAY {
 112     cDims: USHORT,
 113     fFeatures: USHORT,
 114     cbElements: ULONG,
 115     cLocks: ULONG,
 116     pvData: PVOID,
 117     rgsabound: [SAFEARRAYBOUND; 1],
 118 }}
 119 pub type LPSAFEARRAY = *mut SAFEARRAY;
 120 pub const FADF_AUTO: DWORD = 0x1;
 121 pub const FADF_STATIC: DWORD = 0x2;
 122 pub const FADF_EMBEDDED: DWORD = 0x4;
 123 pub const FADF_FIXEDSIZE: DWORD = 0x10;
 124 pub const FADF_RECORD: DWORD = 0x20;
 125 pub const FADF_HAVEIID: DWORD = 0x40;
 126 pub const FADF_HAVEVARTYPE: DWORD = 0x80;
 127 pub const FADF_BSTR: DWORD = 0x100;
 128 pub const FADF_UNKNOWN: DWORD = 0x200;
 129 pub const FADF_DISPATCH: DWORD = 0x400;
 130 pub const FADF_VARIANT: DWORD = 0x800;
 131 pub const FADF_RESERVED: DWORD = 0xf008;
 132 STRUCT!{struct __tagBRECORD {
 133     pvRecord: PVOID,
 134     pRecInfo: *mut IRecordInfo,
 135 }}
 136 UNION!{union VARIANT_n3 {
 137     [u64; 1] [u64; 2],
 138     llVal llVal_mut: LONGLONG,
 139     lVal lVal_mut: LONG,
 140     bVal bVal_mut: BYTE,
 141     iVal iVal_mut: SHORT,
 142     fltVal fltVal_mut: FLOAT,
 143     dblVal dblVal_mut: DOUBLE,
 144     boolVal boolVal_mut: VARIANT_BOOL,
 145     scode scode_mut: SCODE,
 146     cyVal cyVal_mut: CY,
 147     date date_mut: DATE,
 148     bstrVal bstrVal_mut: BSTR,
 149     punkVal punkVal_mut: *mut IUnknown,
 150     pdispVal pdispVal_mut: *mut IDispatch,
 151     parray parray_mut: *mut SAFEARRAY,
 152     pbVal pbVal_mut: *mut BYTE,
 153     piVal piVal_mut: *mut SHORT,
 154     plVal plVal_mut: *mut LONG,
 155     pllVal pllVal_mut: *mut LONGLONG,
 156     pfltVal pfltVal_mut: *mut FLOAT,
 157     pdblVal pdblVal_mut: *mut DOUBLE,
 158     pboolVal pboolVal_mut: *mut VARIANT_BOOL,
 159     pscode pscode_mut: *mut SCODE,
 160     pcyVal pcyVal_mut: *mut CY,
 161     pdate pdate_mut: *mut DATE,
 162     pbstrVal pbstrVal_mut: *mut BSTR,
 163     ppunkVal ppunkVal_mut: *mut *mut IUnknown,
 164     ppdispVal ppdispVal_mut: *mut *mut IDispatch,
 165     pparray pparray_mut: *mut *mut SAFEARRAY,
 166     pvarVal pvarVal_mut: *mut VARIANT,
 167     byref byref_mut: PVOID,
 168     cVal cVal_mut: CHAR,
 169     uiVal uiVal_mut: USHORT,
 170     ulVal ulVal_mut: ULONG,
 171     ullVal ullVal_mut: ULONGLONG,
 172     intVal intVal_mut: INT,
 173     uintVal uintVal_mut: UINT,
 174     pdecVal pdecVal_mut: *mut DECIMAL,
 175     pcVal pcVal_mut: *mut CHAR,
 176     puiVal puiVal_mut: *mut USHORT,
 177     pulVal pulVal_mut: *mut ULONG,
 178     pullVal pullVal_mut: *mut ULONGLONG,
 179     pintVal pintVal_mut: *mut INT,
 180     puintVal puintVal_mut: *mut UINT,
 181     n4 n4_mut: __tagBRECORD,
 182 }}
 183 STRUCT!{struct __tagVARIANT {
 184     vt: VARTYPE,
 185     wReserved1: WORD,
 186     wReserved2: WORD,
 187     wReserved3: WORD,
 188     n3: VARIANT_n3,
 189 }}
 190 UNION!{union VARIANT_n1 {
 191     [u64; 2] [u64; 3],
 192     n2 n2_mut: __tagVARIANT,
 193     decVal decVal_mut: DECIMAL,
 194 }}
 195 STRUCT!{struct VARIANT {
 196     n1: VARIANT_n1,
 197 }}
 198 pub type LPVARIANT = *mut VARIANT;
 199 pub type VARIANTARG = VARIANT;
 200 pub type LPVARIANTARG = *mut VARIANT;
 201 pub type REFVARIANT = *const VARIANT;
 202 STRUCT!{struct _wireBRECORD {
 203     fFlags: ULONG,
 204     clSize: ULONG,
 205     pRecInfo: *mut IRecordInfo,
 206     pRecord: *mut byte,
 207 }}
 208 UNION!{union _wireVARIANT_u {
 209     [u64; 2],
 210     llVal llVal_mut: LONGLONG,
 211     lVal lVal_mut: LONG,
 212     bVal bVal_mut: BYTE,
 213     iVal iVal_mut: SHORT,
 214     fltVal fltVal_mut: FLOAT,
 215     dblVal dblVal_mut: DOUBLE,
 216     boolVal boolVal_mut: VARIANT_BOOL,
 217     scode scode_mut: SCODE,
 218     cyVal cyVal_mut: CY,
 219     date date_mut: DATE,
 220     bstrVal bstrVal_mut: wireBSTR,
 221     punkVal punkVal_mut: *mut IUnknown,
 222     pdispVal pdispVal_mut: *mut IDispatch,
 223     parray parray_mut: wirePSAFEARRAY,
 224     brecVal brecVal_mut: wireBRECORD,
 225     pbVal pbVal_mut: *mut BYTE,
 226     piVal piVal_mut: *mut SHORT,
 227     plVal plVal_mut: *mut LONG,
 228     pllVal pllVal_mut: *mut LONGLONG,
 229     pfltVal pfltVal_mut: *mut FLOAT,
 230     pdblVal pdblVal_mut: *mut DOUBLE,
 231     pboolVal pboolVal_mut: *mut VARIANT_BOOL,
 232     pscode pscode_mut: *mut SCODE,
 233     pcyVal pcyVal_mut: *mut CY,
 234     pdate pdate_mut: *mut DATE,
 235     pbstrVal pbstrVal_mut: *mut wireBSTR,
 236     ppunkVal ppunkVal_mut: *mut *mut IUnknown,
 237     ppdispVal ppdispVal_mut: *mut *mut IDispatch,
 238     pparray pparray_mut: *mut wirePSAFEARRAY,
 239     pvarVal pvarVal_mut: *mut wireVARIANT,
 240     cVal cVal_mut: CHAR,
 241     uiVal uiVal_mut: USHORT,
 242     ulVal ulVal_mut: ULONG,
 243     ullVal ullVal_mut: ULONGLONG,
 244     intVal intVal_mut: INT,
 245     uintVal uintVal_mut: UINT,
 246     decVal decVal_mut: DECIMAL,
 247     pdecVal pdecVal_mut: *mut DECIMAL,
 248     pcVal pcVal_mut: *mut CHAR,
 249     puiVal puiVal_mut: *mut USHORT,
 250     pulVal pulVal_mut: *mut ULONG,
 251     pullVal pullVal_mut: *mut ULONGLONG,
 252     pintVal pintVal_mut: *mut INT,
 253     puintVal puintVal_mut: *mut UINT,
 254 }}
 255 STRUCT!{struct _wireVARIANT {
 256     clSize: DWORD,
 257     rpcReserved: DWORD,
 258     vt: USHORT,
 259     wReserved1: USHORT,
 260     wReserved2: USHORT,
 261     wReserved3: USHORT,
 262     u: _wireVARIANT_u,
 263 }}
 264 pub type DISPID = LONG;
 265 pub type MEMBERID = DISPID;
 266 pub type HREFTYPE = DWORD;
 267 ENUM!{enum TYPEKIND {
 268     TKIND_ENUM = 0,
 269     TKIND_RECORD,
 270     TKIND_MODULE,
 271     TKIND_INTERFACE,
 272     TKIND_DISPATCH,
 273     TKIND_COCLASS,
 274     TKIND_ALIAS,
 275     TKIND_UNION,
 276     TKIND_MAX,
 277 }}
 278 UNION!{union TYPEDESC_u {
 279     [usize; 1],
 280     lptdesc lptdesc_mut: *mut TYPEDESC,
 281     lpadesc lpadesc_mut: *mut ARRAYDESC,
 282     hreftype hreftype_mut: HREFTYPE,
 283 }}
 284 STRUCT!{struct TYPEDESC {
 285     u: TYPEDESC_u,
 286     vt: VARTYPE,
 287 }}
 288 STRUCT!{struct ARRAYDESC {
 289     tdescElem: TYPEDESC,
 290     cDims: USHORT,
 291     rgbounds: [SAFEARRAYBOUND; 1],
 292 }}
 293 STRUCT!{struct PARAMDESCEX {
 294     cBytes: ULONG,
 295     varDefaultValue: VARIANTARG,
 296 }}
 297 pub type LPPARAMDESCEX = *mut PARAMDESCEX;
 298 STRUCT!{struct PARAMDESC {
 299     pparamdescex: LPPARAMDESCEX,
 300     wParamFlags: USHORT,
 301 }}
 302 pub type LPPARAMDESC = *mut PARAMDESC;
 303 pub const PARAMFLAG_NONE: DWORD = 0;
 304 pub const PARAMFLAG_FIN: DWORD = 0x1;
 305 pub const PARAMFLAG_FOUT: DWORD = 0x2;
 306 pub const PARAMFLAG_FLCID: DWORD = 0x4;
 307 pub const PARAMFLAG_FRETVAL: DWORD = 0x8;
 308 pub const PARAMFLAG_FOPT: DWORD = 0x10;
 309 pub const PARAMFLAG_FHASDEFAULT: DWORD = 0x20;
 310 pub const PARAMFLAG_FHASCUSTDATA: DWORD = 0x40;
 311 STRUCT!{struct IDLDESC {
 312     dwReserved: ULONG_PTR,
 313     wIDLFlags: USHORT,
 314 }}
 315 pub type LPIDLDESC = *mut IDLDESC;
 316 pub const IDLFLAG_NONE: DWORD = PARAMFLAG_NONE;
 317 pub const IDLFLAG_FIN: DWORD = PARAMFLAG_FIN;
 318 pub const IDLFLAG_FOUT: DWORD = PARAMFLAG_FOUT;
 319 pub const IDLFLAG_FLCID: DWORD = PARAMFLAG_FLCID;
 320 pub const IDLFLAG_FRETVAL: DWORD = PARAMFLAG_FRETVAL;
 321 UNION!{union ELEMDESC_u {
 322     [usize; 2],
 323     idldesc idldesc_mut: IDLDESC,
 324     paramdesc paramdesc_mut: PARAMDESC,
 325 }}
 326 STRUCT!{struct ELEMDESC {
 327     tdesc: TYPEDESC,
 328     u: ELEMDESC_u,
 329 }}
 330 pub type LPELEMDESC = *mut ELEMDESC;
 331 STRUCT!{struct TYPEATTR {
 332     guid: GUID,
 333     lcid: LCID,
 334     dwReserved: DWORD,
 335     memidConstructor: MEMBERID,
 336     memidDestructor: MEMBERID,
 337     lpstrSchema: LPOLESTR,
 338     cbSizeInstance: ULONG,
 339     typekind: TYPEKIND,
 340     cFuncs: WORD,
 341     cVars: WORD,
 342     cImplTypes: WORD,
 343     cbSizeVft: WORD,
 344     cbAlignment: WORD,
 345     wTypeFlags: WORD,
 346     wMajorVerNum: WORD,
 347     wMinorVerNum: WORD,
 348     tdescAlias: TYPEDESC,
 349     idldescType: IDLDESC,
 350 }}
 351 pub type LPTYPEATTR = *mut TYPEATTR;
 352 STRUCT!{struct DISPPARAMS {
 353     rgvarg: *mut VARIANTARG,
 354     rgdispidNamedArgs: *mut DISPID,
 355     cArgs: UINT,
 356     cNamedArgs: UINT,
 357 }}
 358 STRUCT!{struct EXCEPINFO {
 359     wCode: WORD,
 360     wReserved: WORD,
 361     bstrSource: BSTR,
 362     bstrDescription: BSTR,
 363     bstrHelpFile: BSTR,
 364     dwHelpContext: DWORD,
 365     pvReserved: PVOID,
 366     pfnDeferredFillIn: Option<unsafe extern "system" fn(
 367         einfo: *mut EXCEPINFO,
 368     ) -> HRESULT>,
 369     scode: SCODE,
 370 }}
 371 ENUM!{enum CALLCONV {
 372     CC_FASTCALL = 0,
 373     CC_CDECL = 1,
 374     CC_MSCPASCAL,
 375     CC_PASCAL,
 376     CC_MACPASCAL,
 377     CC_STDCALL,
 378     CC_FPFASTCALL,
 379     CC_SYSCALL,
 380     CC_MPWCDECL,
 381     CC_MPWPASCAL,
 382     CC_MAX,
 383 }}
 384 ENUM!{enum FUNCKIND {
 385     FUNC_VIRTUAL = 0,
 386     FUNC_PUREVIRTUAL,
 387     FUNC_NONVIRTUAL,
 388     FUNC_STATIC,
 389     FUNC_DISPATCH,
 390 }}
 391 ENUM!{enum INVOKEKIND {
 392     INVOKE_FUNC = 1,
 393     INVOKE_PROPERTYGET = 2,
 394     INVOKE_PROPERTYPUT = 4,
 395     INVOKE_PROPERTYPUTREF = 8,
 396 }}
 397 STRUCT!{struct FUNCDESC {
 398     memid: MEMBERID,
 399     lprgscode: *mut SCODE,
 400     lprgelemdescParam: *mut ELEMDESC,
 401     funckind: FUNCKIND,
 402     invkind: INVOKEKIND,
 403     callconv: CALLCONV,
 404     cParams: SHORT,
 405     cParamsOpt: SHORT,
 406     oVft: SHORT,
 407     cScodes: SHORT,
 408     elemdescFunc: ELEMDESC,
 409     wFuncFlags: WORD,
 410 }}
 411 pub type LPFUNCDESC = *mut FUNCDESC;
 412 ENUM!{enum VARKIND {
 413     VAR_PERINSTANCE = 0,
 414     VAR_STATIC,
 415     VAR_CONST,
 416     VAR_DISPATCH,
 417 }}
 418 pub const IMPLTYPEFLAG_FDEFAULT: DWORD = 0x1;
 419 pub const IMPLTYPEFLAG_FSOURCE: DWORD = 0x2;
 420 pub const IMPLTYPEFLAG_FRESTRICTED: DWORD = 0x4;
 421 pub const IMPLTYPEFLAG_FDEFAULTVTABLE: DWORD = 0x8;
 422 UNION!{union VARDESC_u {
 423     [usize; 1],
 424     oInst oInst_mut: ULONG,
 425     lpvarValue lpvarValue_mut: *mut VARIANT,
 426 }}
 427 STRUCT!{struct VARDESC {
 428     memid: MEMBERID,
 429     lpstrSchema: LPOLESTR,
 430     u: VARDESC_u,
 431     elemdescVar: ELEMDESC,
 432     wVarFlags: WORD,
 433     varkind: VARKIND,
 434 }}
 435 pub type LPVARDESC = *mut VARDESC;
 436 ENUM!{enum TYPEFLAGS {
 437     TYPEFLAG_FAPPOBJECT = 0x1,
 438     TYPEFLAG_FCANCREATE = 0x2,
 439     TYPEFLAG_FLICENSED = 0x4,
 440     TYPEFLAG_FPREDECLID = 0x8,
 441     TYPEFLAG_FHIDDEN = 0x10,
 442     TYPEFLAG_FCONTROL = 0x20,
 443     TYPEFLAG_FDUAL = 0x40,
 444     TYPEFLAG_FNONEXTENSIBLE = 0x80,
 445     TYPEFLAG_FOLEAUTOMATION = 0x100,
 446     TYPEFLAG_FRESTRICTED = 0x200,
 447     TYPEFLAG_FAGGREGATABLE = 0x400,
 448     TYPEFLAG_FREPLACEABLE = 0x800,
 449     TYPEFLAG_FDISPATCHABLE = 0x1000,
 450     TYPEFLAG_FREVERSEBIND = 0x2000,
 451     TYPEFLAG_FPROXY = 0x4000,
 452 }}
 453 ENUM!{enum FUNCFLAGS {
 454     FUNCFLAG_FRESTRICTED = 0x1,
 455     FUNCFLAG_FSOURCE = 0x2,
 456     FUNCFLAG_FBINDABLE = 0x4,
 457     FUNCFLAG_FREQUESTEDIT = 0x8,
 458     FUNCFLAG_FDISPLAYBIND = 0x10,
 459     FUNCFLAG_FDEFAULTBIND = 0x20,
 460     FUNCFLAG_FHIDDEN = 0x40,
 461     FUNCFLAG_FUSESGETLASTERROR = 0x80,
 462     FUNCFLAG_FDEFAULTCOLLELEM = 0x100,
 463     FUNCFLAG_FUIDEFAULT = 0x200,
 464     FUNCFLAG_FNONBROWSABLE = 0x400,
 465     FUNCFLAG_FREPLACEABLE = 0x800,
 466     FUNCFLAG_FIMMEDIATEBIND = 0x1000,
 467 }}
 468 ENUM!{enum VARFLAGS {
 469     VARFLAG_FREADONLY = 0x1,
 470     VARFLAG_FSOURCE = 0x2,
 471     VARFLAG_FBINDABLE = 0x4,
 472     VARFLAG_FREQUESTEDIT = 0x8,
 473     VARFLAG_FDISPLAYBIND = 0x10,
 474     VARFLAG_FDEFAULTBIND = 0x20,
 475     VARFLAG_FHIDDEN = 0x40,
 476     VARFLAG_FRESTRICTED = 0x80,
 477     VARFLAG_FDEFAULTCOLLELEM = 0x100,
 478     VARFLAG_FUIDEFAULT = 0x200,
 479     VARFLAG_FNONBROWSABLE = 0x400,
 480     VARFLAG_FREPLACEABLE = 0x800,
 481     VARFLAG_FIMMEDIATEBIND = 0x1000,
 482 }}
 483 STRUCT!{struct CLEANLOCALSTORAGE {
 484     pInterface: *mut IUnknown,
 485     pStorage: PVOID,
 486     flags: DWORD,
 487 }}
 488 STRUCT!{struct CUSTDATAITEM {
 489     guid: GUID,
 490     varValue: VARIANTARG,
 491 }}
 492 pub type LPCUSTDATAITEM = *mut CUSTDATAITEM;
 493 STRUCT!{struct CUSTDATA {
 494     cCustData: DWORD,
 495     prgCustData: LPCUSTDATAITEM,
 496 }}
 497 pub type LPCUSTDATA = *mut CUSTDATA;
 498 pub type LPCREATETYPEINFO = *mut ICreateTypeInfo;
 499 RIDL!{#[uuid(0x00020405, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
 500 interface ICreateTypeInfo(ICreateTypeInfoVtbl): IUnknown(IUnknownVtbl) {
 501     fn SetGuid(
 502         guid: REFGUID,
 503     ) -> HRESULT,
 504     fn SetTypeFlags(
 505         uTypeFlags: UINT,
 506     ) -> HRESULT,
 507     fn SetDocString(
 508         pStrDoc: LPOLESTR,
 509     ) -> HRESULT,
 510     fn SetHelpContext(
 511         dwHelpContext: DWORD,
 512     ) -> HRESULT,
 513     fn SetVersion(
 514         wMajorVerNum: WORD,
 515         wMinorVerNum: WORD,
 516     ) -> HRESULT,
 517     fn AddRefTypeInfo(
 518         pTInfo: *mut ITypeInfo,
 519     ) -> HRESULT,
 520     fn AddFuncDesc(
 521         index: UINT,
 522         pFuncDesc: *mut FUNCDESC,
 523     ) -> HRESULT,
 524     fn SetImplTypeFlags(
 525         index: UINT,
 526         implTypeFlags: INT,
 527     ) -> HRESULT,
 528     fn SetAlignment(
 529         cbAlignment: WORD,
 530     ) -> HRESULT,
 531     fn SetSchema(
 532         pStrSchema: LPOLESTR,
 533     ) -> HRESULT,
 534     fn AddVarDesc(
 535         index: UINT,
 536         pVarDesc: *mut VARDESC,
 537     ) -> HRESULT,
 538     fn SetFuncAndParamNames(
 539         index: UINT,
 540         rgszNames: *mut LPOLESTR,
 541         cNames: UINT,
 542     ) -> HRESULT,
 543     fn SetVarName(
 544         index: UINT,
 545         szName: LPOLESTR,
 546     ) -> HRESULT,
 547     fn SetTypeDescAlias(
 548         pTDescAlias: *mut TYPEDESC,
 549     ) -> HRESULT,
 550     fn DefineFuncAsDllEntry(
 551         index: UINT,
 552         szDllName: LPOLESTR,
 553         szProcName: LPOLESTR,
 554     ) -> HRESULT,
 555     fn SetFuncDocString(
 556         index: UINT,
 557         szDocString: LPOLESTR,
 558     ) -> HRESULT,
 559     fn SetVarDocString(
 560         index: UINT,
 561         szDocString: LPOLESTR,
 562     ) -> HRESULT,
 563     fn SetFuncHelpContext(
 564         index: UINT,
 565         dwHelpContext: DWORD,
 566     ) -> HRESULT,
 567     fn SetVarHelpContext(
 568         index: UINT,
 569         dwHelpContext: DWORD,
 570     ) -> HRESULT,
 571     fn SetMops(
 572         index: UINT,
 573         bstrMops: BSTR,
 574     ) -> HRESULT,
 575     fn SetTypeIdldesc(
 576         pIdlDesc: *mut IDLDESC,
 577     ) -> HRESULT,
 578     fn LayOut() -> HRESULT,
 579 }}
 580 // LPCREATETYPEINFO2
 581 // ICreateTypeInfo2
 582 // LPCREATETYPELIB
 583 // ICreateTypeLib
 584 // LPCREATETYPELIB2
 585 // ICreateTypeLib2
 586 pub type LPDISPATCH = *mut IDispatch;
 587 pub const DISPID_UNKNOWN: INT = -1;
 588 pub const DISPID_VALUE: INT = 0;
 589 pub const DISPID_PROPERTYPUT: INT = -3;
 590 pub const DISPID_NEWENUM: INT = -4;
 591 pub const DISPID_EVALUATE: INT = -5;
 592 pub const DISPID_CONSTRUCTOR: INT = -6;
 593 pub const DISPID_DESTRUCTOR: INT = -7;
 594 pub const DISPID_COLLECT: INT = -8;
 595 RIDL!{#[uuid(0x00020400, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
 596 interface IDispatch(IDispatchVtbl): IUnknown(IUnknownVtbl) {
 597     fn GetTypeInfoCount(
 598         pctinfo: *mut UINT,
 599     ) -> HRESULT,
 600     fn GetTypeInfo(
 601         iTInfo: UINT,
 602         lcid: LCID,
 603         ppTInfo: *mut *mut ITypeInfo,
 604     ) -> HRESULT,
 605     fn GetIDsOfNames(
 606         riid: REFIID,
 607         rgszNames: *mut LPOLESTR,
 608         cNames: UINT,
 609         lcid: LCID,
 610         rgDispId: *mut DISPID,
 611     ) -> HRESULT,
 612     fn Invoke(
 613         dispIdMember: DISPID,
 614         riid: REFIID,
 615         lcid: LCID,
 616         wFlags: WORD,
 617         pDispParams: *mut DISPPARAMS,
 618         pVarResult: *mut VARIANT,
 619         pExcepInfo: *mut EXCEPINFO,
 620         puArgErr: *mut UINT,
 621     ) -> HRESULT,
 622 }}
 623 // IDispatch_RemoteInvoke_Proxy
 624 // IDispatch_RemoteInvoke_Stub
 625 // LPENUMVARIANT
 626 // IEnumVARIANT
 627 // IEnumVARIANT_RemoteNext_Proxy
 628 // IEnumVARIANT_RemoteNext_Stub
 629 pub enum IRecordInfo {} // FIXME
 630 pub enum ITypeComp {} // FIXME
 631 ENUM!{enum SYSKIND {
 632     SYS_WIN16 = 0,
 633     SYS_WIN32,
 634     SYS_MAC,
 635     SYS_WIN64,
 636 }}
 637 STRUCT!{struct TLIBATTR {
 638     guid: GUID,
 639     lcid: LCID,
 640     syskind: SYSKIND,
 641     wMajorVerNum: WORD,
 642     wMinorVerNum: WORD,
 643     wLibFlags: WORD,
 644 }}
 645 RIDL!{#[uuid(0x00020402, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
 646 interface ITypeLib(ITypeLibVtbl): IUnknown(IUnknownVtbl) {
 647     fn GetTypeInfoCount() -> UINT,
 648     fn GetTypeInfo(
 649         index: UINT,
 650         ppTInfo: *mut *mut ITypeInfo,
 651     ) -> HRESULT,
 652     fn GetTypeInfoType(
 653         index: UINT,
 654         pTKind: *mut TYPEKIND,
 655     ) -> HRESULT,
 656     fn GetTypeInfoOfGuid(
 657         guid: REFGUID,
 658         ppTInfo: *mut *mut ITypeInfo,
 659     ) -> HRESULT,
 660     fn GetLibAttr(
 661         ppTLibAttr: *mut *mut TLIBATTR,
 662     ) -> HRESULT,
 663     fn GetTypeComp(
 664         ppTComp: *mut *mut ITypeComp,
 665     ) -> HRESULT,
 666     fn GetDocumentation(
 667         index: INT,
 668         pbstrName: *mut BSTR,
 669         pBstrDocString: *mut BSTR,
 670         pdwHelpContext: *mut DWORD,
 671         pBstrHelpFile: *mut BSTR,
 672     ) -> HRESULT,
 673     fn IsName(
 674         szNameBuf: LPOLESTR,
 675         lHashVal: ULONG,
 676         pfName: *mut BOOL,
 677     ) -> HRESULT,
 678     fn FindName(
 679         szNameBuf: LPOLESTR,
 680         lHashVal: ULONG,
 681         ppTInfo: *mut *mut ITypeInfo,
 682         rgMemId: *mut MEMBERID,
 683         pcFound: *mut USHORT,
 684     ) -> HRESULT,
 685     fn ReleaseTLibAttr(
 686         pTLibAttr: *const TLIBATTR,
 687     ) -> HRESULT,
 688 }}
 689 RIDL!(#[uuid(0x00020401, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
 690 interface ITypeInfo(ITypeInfoVtbl): IUnknown(IUnknownVtbl) {
 691     fn GetTypeAttr(
 692         ppTypeAttr: *mut *mut TYPEATTR,
 693     ) -> HRESULT,
 694     fn GetTypeComp(
 695         ppTComp: *mut *mut ITypeComp,
 696     ) -> HRESULT,
 697     fn GetFuncDesc(
 698         index: UINT,
 699         ppFunDesc: *mut *mut FUNCDESC,
 700     ) -> HRESULT,
 701     fn GetVarDesc(
 702         index: UINT,
 703         pPVarDesc: *mut *mut VARDESC,
 704     ) -> HRESULT,
 705     fn GetNames(
 706         memid: MEMBERID,
 707         rgBstrNames: *mut BSTR,
 708         cMaxNames: UINT,
 709         pcNames: *mut UINT,
 710     ) -> HRESULT,
 711     fn GetRefTypeOfImplType(
 712         index: UINT,
 713         pRefType: *mut HREFTYPE,
 714     ) -> HRESULT,
 715     fn GetImplTypeFlags(
 716         index: UINT,
 717         pImplTypeFlags: *mut INT,
 718     ) -> HRESULT,
 719     fn GetIDsOfNames(
 720         rgszNames: *mut LPOLESTR,
 721         cNames: UINT,
 722         pMemId: *mut MEMBERID,
 723     ) -> HRESULT,
 724     fn Invoke(
 725         pvInstance: PVOID,
 726         memid: MEMBERID,
 727         wFlags: WORD,
 728         pDispParams: *mut DISPPARAMS,
 729         pVarResult: *mut VARIANT,
 730         pExcepInfo: *mut EXCEPINFO,
 731         puArgErr: *mut UINT,
 732     ) -> HRESULT,
 733     fn GetDocumentation(
 734         memid: MEMBERID,
 735         pBstrName: *mut BSTR,
 736         pBstrDocString: *mut BSTR,
 737         pdwHelpContext: *mut DWORD,
 738         pBstrHelpFile: *mut BSTR,
 739     ) -> HRESULT,
 740     fn GetDllEntry(
 741         memid: MEMBERID,
 742         invKind: INVOKEKIND,
 743         pBstrDllName: *mut BSTR,
 744         pBstrName: *mut BSTR,
 745         pwOrdinal: *mut WORD,
 746     ) -> HRESULT,
 747     fn GetRefTypeInfo(
 748         hRefType: HREFTYPE,
 749         ppTInfo: *mut *mut ITypeInfo,
 750     ) -> HRESULT,
 751     fn AddressOfMember(
 752         memid: MEMBERID,
 753         invKind: INVOKEKIND,
 754         ppv: *mut PVOID,
 755     ) -> HRESULT,
 756     fn CreateInstance(
 757         pUnkOuter: *mut IUnknown,
 758         riid: REFIID,
 759         ppvObj: *mut PVOID,
 760     ) -> HRESULT,
 761     fn GetMops(
 762         memid: MEMBERID,
 763         pBstrMops: *mut BSTR,
 764     ) -> HRESULT,
 765     fn GetContainingTypeLib(
 766         ppTLib: *mut *mut ITypeLib,
 767         pIndex: *mut UINT,
 768     ) -> HRESULT,
 769     fn ReleaseTypeAttr(
 770         pTypeAttr: *mut TYPEATTR,
 771     ) -> (),
 772     fn ReleaseFuncDesc(
 773         pFuncDesc: *mut FUNCDESC,
 774     ) -> (),
 775     fn ReleaseVarDesc(
 776         pVarDesc: *mut VARDESC,
 777     ) -> (),
 778 }
 779 );
 780 RIDL!(#[uuid(0x3127ca40, 0x446e, 0x11ce, 0x81, 0x35, 0x00, 0xaa, 0x00, 0x4b, 0xb8, 0x51)]
 781 interface IErrorLog(IErrorLogVtbl): IUnknown(IUnknownVtbl) {
 782     fn AddError(
 783         pszPropName: LPCOLESTR,
 784         pExcepInfo: *const EXCEPINFO,
 785     ) -> HRESULT,
 786 });
 787 pub type LPERRORLOG = *mut IErrorLog;