1 /** 2 * Windows API header module 3 * 4 * Translated from MinGW Windows headers 5 * 6 * License: $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost License 1.0) 7 * Source: $(DRUNTIMESRC core/sys/windows/_oaidl.d) 8 */ 9 /// Automatically imported and edited from the druntime module 10 /// core.sys.windows.oaidl for the auto-generated win32 package. 11 module win32.oaidl; 12 //version (Windows): 13 @system: 14 15 import win32.basetyps, win32.unknwn, win32.windef, win32.wtypes; 16 17 enum DISPID_UNKNOWN = -1; 18 enum DISPID_VALUE = 0; 19 enum DISPID_PROPERTYPUT = -3; 20 enum DISPID_NEWENUM = -4; 21 enum DISPID_EVALUATE = -5; 22 enum DISPID_CONSTRUCTOR = -6; 23 enum DISPID_DESTRUCTOR = -7; 24 enum DISPID_COLLECT = -8; 25 26 enum FADF_AUTO = 1; 27 enum FADF_STATIC = 2; 28 enum FADF_EMBEDDED = 4; 29 enum FADF_FIXEDSIZE = 16; 30 enum FADF_RECORD = 32; 31 enum FADF_HAVEIID = 64; 32 enum FADF_HAVEVARTYPE = 128; 33 enum FADF_BSTR = 256; 34 enum FADF_UNKNOWN = 512; 35 enum FADF_DISPATCH = 1024; 36 enum FADF_VARIANT = 2048; 37 enum FADF_RESERVED = 0xf0e8; 38 enum FADF_DATADELETED = 0x1000; 39 enum FADF_CREATEVECTOR = 0x2000; 40 41 enum PARAMFLAG_NONE = 0; 42 enum PARAMFLAG_FIN = 1; 43 enum PARAMFLAG_FOUT = 2; 44 enum PARAMFLAG_FLCID = 4; 45 enum PARAMFLAG_FRETVAL = 8; 46 enum PARAMFLAG_FOPT = 16; 47 enum PARAMFLAG_FHASDEFAULT = 32; 48 enum PARAMFLAG_FHASCUSTDATA = 64; 49 50 enum IDLFLAG_NONE = PARAMFLAG_NONE; 51 enum IDLFLAG_FIN = PARAMFLAG_FIN; 52 enum IDLFLAG_FOUT = PARAMFLAG_FOUT; 53 enum IDLFLAG_FLCID = PARAMFLAG_FLCID; 54 enum IDLFLAG_FRETVAL = PARAMFLAG_FRETVAL; 55 56 enum IMPLTYPEFLAG_FDEFAULT = 1; 57 enum IMPLTYPEFLAG_FSOURCE = 2; 58 enum IMPLTYPEFLAG_FRESTRICTED = 4; 59 enum IMPLTYPEFLAG_FDEFAULTVTABLE = 8; 60 61 62 enum SYSKIND { 63 SYS_WIN16, 64 SYS_WIN32, 65 SYS_MAC 66 } 67 68 enum LIBFLAGS { 69 LIBFLAG_FRESTRICTED = 1, 70 LIBFLAG_FCONTROL = 2, 71 LIBFLAG_FHIDDEN = 4, 72 LIBFLAG_FHASDISKIMAGE = 8 73 } 74 75 struct TLIBATTR { 76 GUID guid; 77 LCID lcid; 78 SYSKIND syskind; 79 WORD wMajorVerNum; 80 WORD wMinorVerNum; 81 WORD wLibFlags; 82 } 83 alias TLIBATTR* LPTLIBATTR; 84 85 alias CY CURRENCY; 86 87 struct SAFEARRAYBOUND { 88 ULONG cElements; 89 LONG lLbound; 90 } 91 alias SAFEARRAYBOUND* LPSAFEARRAYBOUND; 92 93 struct SAFEARR_BSTR { 94 ULONG Size; 95 wireBSTR* aBstr; 96 } 97 98 struct SAFEARR_UNKNOWN { 99 ULONG Size; 100 IUnknown* apUnknown; 101 } 102 103 struct SAFEARR_DISPATCH { 104 ULONG Size; 105 LPDISPATCH* apDispatch; 106 } 107 108 struct SAFEARR_VARIANT { 109 ULONG Size; 110 _wireVARIANT* aVariant; 111 } 112 113 enum SF_TYPE { 114 SF_ERROR=VARENUM.VT_ERROR, 115 SF_I1=VARENUM.VT_I1, 116 SF_I2=VARENUM.VT_I2, 117 SF_I4=VARENUM.VT_I4, 118 SF_I8=VARENUM.VT_I8, 119 SF_BSTR=VARENUM.VT_BSTR, 120 SF_UNKNOWN=VARENUM.VT_UNKNOWN, 121 SF_DISPATCH=VARENUM.VT_DISPATCH, 122 SF_VARIANT=VARENUM.VT_VARIANT 123 } 124 125 struct _wireBRECORD { 126 ULONG fFlags; 127 ULONG clSize; 128 LPRECORDINFO* pRecInfo; 129 byte* pRecord; 130 } 131 alias _wireBRECORD* wireBRECORD; 132 133 struct SAFEARR_BRECORD { 134 ULONG Size; 135 wireBRECORD* aRecord; 136 } 137 138 struct SAFEARR_HAVEIID { 139 ULONG Size; 140 IUnknown* apUnknown; 141 IID iid; 142 } 143 144 struct SAFEARRAYUNION { 145 ULONG sfType; 146 union _u { 147 SAFEARR_BSTR BstrStr; 148 SAFEARR_UNKNOWN UnknownStr; 149 SAFEARR_DISPATCH DispatchStr; 150 SAFEARR_VARIANT VariantStr; 151 SAFEARR_BRECORD RecordStr; 152 SAFEARR_HAVEIID HaveIidStr; 153 BYTE_SIZEDARR ByteStr; 154 WORD_SIZEDARR WordStr; 155 DWORD_SIZEDARR LongStr; 156 HYPER_SIZEDARR HyperStr; 157 } 158 _u u; 159 } 160 161 struct _wireSAFEARRAY { 162 USHORT cDims; 163 USHORT fFeatures; 164 ULONG cbElements; 165 ULONG cLocks; 166 SAFEARRAYUNION uArrayStructs; 167 SAFEARRAYBOUND[1] rgsabound; 168 } 169 alias _wireSAFEARRAY* wireSAFEARRAY; 170 171 alias wireSAFEARRAY* wirePSAFEARRAY; 172 173 struct SAFEARRAY { 174 USHORT cDims; 175 USHORT fFeatures; 176 ULONG cbElements; 177 ULONG cLocks; 178 PVOID pvData; 179 SAFEARRAYBOUND[1] rgsabound; 180 } 181 alias SAFEARRAY* LPSAFEARRAY; 182 183 struct VARIANT { 184 union { 185 struct { 186 VARTYPE vt; 187 WORD wReserved1; 188 WORD wReserved2; 189 WORD wReserved3; 190 union { 191 int lVal; 192 LONGLONG llVal; 193 ubyte bVal; 194 short iVal; 195 float fltVal; 196 double dblVal; 197 VARIANT_BOOL boolVal; 198 SCODE scode; 199 CY cyVal; 200 DATE date; 201 BSTR bstrVal; 202 IUnknown punkVal; 203 IDispatch pdispVal; 204 SAFEARRAY* parray; 205 ubyte* pbVal; 206 short* piVal; 207 int* plVal; 208 LONGLONG* pllVal; 209 float* pfltVal; 210 double* pdblVal; 211 VARIANT_BOOL* pboolVal; 212 _VARIANT_BOOL* pbool; 213 SCODE* pscode; 214 CY* pcyVal; 215 DATE* pdate; 216 BSTR* pbstrVal; 217 IUnknown* ppunkVal; 218 IDispatch* ppdispVal; 219 SAFEARRAY** pparray; 220 VARIANT* pvarVal; 221 void* byref; 222 CHAR cVal; 223 USHORT uiVal; 224 ULONG ulVal; 225 ULONGLONG ullVal; 226 INT intVal; 227 UINT uintVal; 228 DECIMAL* pdecVal; 229 CHAR* pcVal; 230 USHORT* puiVal; 231 ULONG* pulVal; 232 ULONGLONG* pullVal; 233 INT* pintVal; 234 UINT* puintVal; 235 struct { 236 PVOID pvRecord; 237 IRecordInfo pRecInfo; 238 } 239 } 240 } 241 DECIMAL decVal; 242 } 243 } 244 alias VARIANT* LPVARIANT; 245 246 alias VARIANT VARIANTARG; 247 alias VARIANT* LPVARIANTARG; 248 249 struct _wireVARIANT { 250 DWORD clSize; 251 DWORD rpcReserved; 252 USHORT vt; 253 USHORT wReserved1; 254 USHORT wReserved2; 255 USHORT wReserved3; 256 union { 257 LONG lVal; 258 LONGLONG llVal; 259 BYTE bVal; 260 SHORT iVal; 261 FLOAT fltVal; 262 DOUBLE dblVal; 263 VARIANT_BOOL boolVal; 264 SCODE scode; 265 CY cyVal; 266 DATE date; 267 wireBSTR bstrVal; 268 IUnknown punkVal; 269 LPDISPATCH pdispVal; 270 wirePSAFEARRAY parray; 271 wireBRECORD brecVal; 272 BYTE* pbVal; 273 SHORT* piVal; 274 LONG* plVal; 275 LONGLONG* pllVal; 276 FLOAT* pfltVal; 277 DOUBLE* pdblVal; 278 VARIANT_BOOL* pboolVal; 279 SCODE* pscode; 280 CY* pcyVal; 281 DATE* pdate; 282 wireBSTR* pbstrVal; 283 IUnknown* ppunkVal; 284 LPDISPATCH* ppdispVal; 285 wirePSAFEARRAY* pparray; 286 wireVARIANT* pvarVal; 287 CHAR cVal; 288 USHORT uiVal; 289 ULONG ulVal; 290 ULONGLONG ullVal; 291 INT intVal; 292 UINT uintVal; 293 DECIMAL decVal; 294 DECIMAL* pdecVal; 295 CHAR* pcVal; 296 USHORT* puiVal; 297 ULONG* pulVal; 298 ULONGLONG* pullVal; 299 INT* pintVal; 300 UINT* puintVal; 301 } 302 } 303 alias _wireVARIANT* wireVARIANT; 304 305 alias LONG DISPID; 306 alias DISPID MEMBERID; 307 alias DWORD HREFTYPE; 308 309 enum TYPEKIND { 310 TKIND_ENUM, TKIND_RECORD, TKIND_MODULE, TKIND_INTERFACE, TKIND_DISPATCH, 311 TKIND_COCLASS, TKIND_ALIAS, TKIND_UNION, TKIND_MAX 312 } 313 314 struct TYPEDESC { 315 union { 316 TYPEDESC* lptdesc; 317 ARRAYDESC* lpadesc; 318 HREFTYPE hreftype; 319 } 320 VARTYPE vt; 321 } 322 323 struct ARRAYDESC { 324 TYPEDESC tdescElem; 325 USHORT cDims; 326 SAFEARRAYBOUND[1] rgbounds; 327 } 328 329 struct PARAMDESCEX { 330 ULONG cBytes; 331 VARIANTARG varDefaultValue; 332 } 333 alias PARAMDESCEX* LPPARAMDESCEX; 334 335 struct PARAMDESC { 336 LPPARAMDESCEX pparamdescex; 337 USHORT wParamFlags; 338 } 339 alias PARAMDESC* LPPARAMDESC; 340 341 struct IDLDESC { 342 ULONG_PTR dwReserved; 343 USHORT wIDLFlags; 344 } 345 alias IDLDESC* LPIDLDESC; 346 347 struct ELEMDESC { 348 TYPEDESC tdesc; 349 union { 350 IDLDESC idldesc; 351 PARAMDESC paramdesc; 352 } 353 } 354 alias ELEMDESC* LPELEMDESC; 355 356 struct TYPEATTR { 357 GUID guid; 358 LCID lcid; 359 DWORD dwReserved; 360 MEMBERID memidConstructor; 361 MEMBERID memidDestructor; 362 LPOLESTR lpstrSchema; 363 ULONG cbSizeInstance; 364 TYPEKIND typekind; 365 WORD cFuncs; 366 WORD cVars; 367 WORD cImplTypes; 368 WORD cbSizeVft; 369 WORD cbAlignment; 370 WORD wTypeFlags; 371 WORD wMajorVerNum; 372 WORD wMinorVerNum; 373 TYPEDESC tdescAlias; 374 IDLDESC idldescType; 375 } 376 alias TYPEATTR* LPTYPEATTR; 377 378 struct DISPPARAMS { 379 VARIANTARG* rgvarg; 380 DISPID* rgdispidNamedArgs; 381 UINT cArgs; 382 UINT cNamedArgs; 383 } 384 385 struct EXCEPINFO { 386 WORD wCode; 387 WORD wReserved; 388 BSTR bstrSource; 389 BSTR bstrDescription; 390 BSTR bstrHelpFile; 391 DWORD dwHelpContext; 392 PVOID pvReserved; 393 extern (Windows) { 394 HRESULT function (EXCEPINFO* ) pfnDeferredFillIn; 395 } 396 SCODE scode; 397 } 398 alias EXCEPINFO* LPEXCEPINFO; 399 400 enum CALLCONV { 401 CC_FASTCALL, 402 CC_CDECL, 403 CC_MSCPASCAL, 404 CC_PASCAL=CC_MSCPASCAL, 405 CC_MACPASCAL, 406 CC_STDCALL, 407 CC_FPFASTCALL, 408 CC_SYSCALL, 409 CC_MPWCDECL, 410 CC_MPWPASCAL, 411 CC_MAX=CC_MPWPASCAL 412 } 413 414 enum FUNCKIND { 415 FUNC_VIRTUAL, 416 FUNC_PUREVIRTUAL, 417 FUNC_NONVIRTUAL, 418 FUNC_STATIC, 419 FUNC_DISPATCH 420 } 421 422 enum INVOKEKIND { 423 INVOKE_FUNC = 1, 424 INVOKE_PROPERTYGET = 2, 425 INVOKE_PROPERTYPUT = 4, 426 INVOKE_PROPERTYPUTREF = 8 427 } 428 429 struct FUNCDESC { 430 MEMBERID memid; 431 SCODE* lprgscode; 432 ELEMDESC* lprgelemdescParam; 433 FUNCKIND funckind; 434 INVOKEKIND invkind; 435 CALLCONV callconv; 436 SHORT cParams; 437 SHORT cParamsOpt; 438 SHORT oVft; 439 SHORT cScodes; 440 ELEMDESC elemdescFunc; 441 WORD wFuncFlags; 442 } 443 alias FUNCDESC* LPFUNCDESC; 444 445 enum VARKIND { 446 VAR_PERINSTANCE, VAR_STATIC, VAR_CONST, VAR_DISPATCH 447 } 448 449 struct VARDESC { 450 MEMBERID memid; 451 LPOLESTR lpstrSchema; 452 union { 453 ULONG oInst; 454 VARIANT* lpvarValue; 455 } 456 ELEMDESC elemdescVar; 457 WORD wVarFlags; 458 VARKIND varkind; 459 } 460 alias VARDESC* LPVARDESC; 461 462 enum TYPEFLAGS { 463 TYPEFLAG_FAPPOBJECT = 1, 464 TYPEFLAG_FCANCREATE = 2, 465 TYPEFLAG_FLICENSED = 4, 466 TYPEFLAG_FPREDECLID = 8, 467 TYPEFLAG_FHIDDEN = 16, 468 TYPEFLAG_FCONTROL = 32, 469 TYPEFLAG_FDUAL = 64, 470 TYPEFLAG_FNONEXTENSIBLE = 128, 471 TYPEFLAG_FOLEAUTOMATION = 256, 472 TYPEFLAG_FRESTRICTED = 512, 473 TYPEFLAG_FAGGREGATABLE = 1024, 474 TYPEFLAG_FREPLACEABLE = 2048, 475 TYPEFLAG_FDISPATCHABLE = 4096, 476 TYPEFLAG_FREVERSEBIND = 8192 477 } 478 479 enum FUNCFLAGS { 480 FUNCFLAG_FRESTRICTED = 1, 481 FUNCFLAG_FSOURCE = 2, 482 FUNCFLAG_FBINDABLE = 4, 483 FUNCFLAG_FREQUESTEDIT = 8, 484 FUNCFLAG_FDISPLAYBIND = 16, 485 FUNCFLAG_FDEFAULTBIND = 32, 486 FUNCFLAG_FHIDDEN = 64, 487 FUNCFLAG_FUSESGETLASTERROR = 128, 488 FUNCFLAG_FDEFAULTCOLLELEM = 256, 489 FUNCFLAG_FUIDEFAULT = 512, 490 FUNCFLAG_FNONBROWSABLE = 1024, 491 FUNCFLAG_FREPLACEABLE = 2048, 492 FUNCFLAG_FIMMEDIATEBIND = 4096 493 } 494 495 enum VARFLAGS { 496 VARFLAG_FREADONLY = 1, 497 VARFLAG_FSOURCE = 2, 498 VARFLAG_FBINDABLE = 4, 499 VARFLAG_FREQUESTEDIT = 8, 500 VARFLAG_FDISPLAYBIND = 16, 501 VARFLAG_FDEFAULTBIND = 32, 502 VARFLAG_FHIDDEN = 64, 503 VARFLAG_FRESTRICTED = 128, 504 VARFLAG_FDEFAULTCOLLELEM = 256, 505 VARFLAG_FUIDEFAULT = 512, 506 VARFLAG_FNONBROWSABLE = 1024, 507 VARFLAG_FREPLACEABLE = 2048, 508 VARFLAG_FIMMEDIATEBIND = 4096 509 } 510 511 struct CLEANLOCALSTORAGE { 512 IUnknown pInterface; 513 PVOID pStorage; 514 DWORD flags; 515 } 516 517 struct CUSTDATAITEM { 518 GUID guid; 519 VARIANTARG varValue; 520 } 521 alias CUSTDATAITEM* LPCUSTDATAITEM; 522 523 struct CUSTDATA { 524 DWORD cCustData; 525 LPCUSTDATAITEM prgCustData; 526 } 527 alias CUSTDATA* LPCUSTDATA; 528 529 enum DESCKIND { 530 DESCKIND_NONE = 0, 531 DESCKIND_FUNCDESC = DESCKIND_NONE+1, 532 DESCKIND_VARDESC = DESCKIND_FUNCDESC+1, 533 DESCKIND_TYPECOMP = DESCKIND_VARDESC+1, 534 DESCKIND_IMPLICITAPPOBJ = DESCKIND_TYPECOMP+1, 535 DESCKIND_MAX = DESCKIND_IMPLICITAPPOBJ+1 536 } 537 538 union BINDPTR { 539 LPFUNCDESC lpfuncdesc; 540 LPVARDESC lpvardesc; 541 LPTYPECOMP lptcomp; 542 } 543 alias BINDPTR* LPBINDPTR; 544 545 interface IDispatch : IUnknown { 546 HRESULT GetTypeInfoCount(UINT*); 547 HRESULT GetTypeInfo(UINT, LCID, LPTYPEINFO*); 548 HRESULT GetIDsOfNames(REFIID, LPOLESTR*, UINT, LCID, DISPID*); 549 HRESULT Invoke(DISPID, REFIID, LCID, WORD, DISPPARAMS*, VARIANT*, EXCEPINFO*, UINT*); 550 } 551 alias IDispatch LPDISPATCH; 552 553 interface IEnumVARIANT : IUnknown { 554 HRESULT Next(ULONG, VARIANT*, ULONG*); 555 HRESULT Skip(ULONG); 556 HRESULT Reset(); 557 HRESULT Clone(IEnumVARIANT*); 558 } 559 alias IEnumVARIANT LPENUMVARIANT; 560 561 interface ITypeComp : IUnknown { 562 HRESULT Bind(LPOLESTR, ULONG, WORD, LPTYPEINFO*, DESCKIND*, LPBINDPTR); 563 HRESULT BindType(LPOLESTR, ULONG, LPTYPEINFO*, LPTYPECOMP*); 564 } 565 alias ITypeComp LPTYPECOMP; 566 567 interface ITypeInfo : IUnknown { 568 HRESULT GetTypeAttr(LPTYPEATTR*); 569 HRESULT GetTypeComp(LPTYPECOMP*); 570 HRESULT GetFuncDesc(UINT, LPFUNCDESC*); 571 HRESULT GetVarDesc(UINT, LPVARDESC*); 572 HRESULT GetNames(MEMBERID, BSTR*, UINT, UINT*); 573 HRESULT GetRefTypeOfImplType(UINT, HREFTYPE*); 574 HRESULT GetImplTypeFlags(UINT, INT*); 575 HRESULT GetIDsOfNames(LPOLESTR*, UINT, MEMBERID*); 576 HRESULT Invoke(PVOID, MEMBERID, WORD, DISPPARAMS*, VARIANT*, EXCEPINFO*, 577 UINT*); 578 HRESULT GetDocumentation(MEMBERID, BSTR*, BSTR*, DWORD*, BSTR*); 579 HRESULT GetDllEntry(MEMBERID, INVOKEKIND, BSTR*, BSTR*, WORD*); 580 HRESULT GetRefTypeInfo(HREFTYPE, LPTYPEINFO*); 581 HRESULT AddressOfMember(MEMBERID, INVOKEKIND, PVOID*); 582 HRESULT CreateInstance(LPUNKNOWN, REFIID, PVOID*); 583 HRESULT GetMops(MEMBERID, BSTR*); 584 HRESULT GetContainingTypeLib(LPTYPELIB*, UINT*); 585 void ReleaseTypeAttr(LPTYPEATTR); 586 void ReleaseFuncDesc(LPFUNCDESC); 587 void ReleaseVarDesc(LPVARDESC); 588 } 589 alias ITypeInfo LPTYPEINFO; 590 591 interface ITypeInfo2 : ITypeInfo { 592 HRESULT GetTypeKind(TYPEKIND*); 593 HRESULT GetTypeFlags(ULONG*); 594 HRESULT GetFuncIndexOfMemId(MEMBERID, INVOKEKIND, UINT*); 595 HRESULT GetVarIndexOfMemId(MEMBERID, UINT*); 596 HRESULT GetCustData(REFGUID, VARIANT*); 597 HRESULT GetFuncCustData(UINT, REFGUID, VARIANT*); 598 HRESULT GetParamCustData(UINT, UINT, REFGUID, VARIANT*); 599 HRESULT GetVarCustData(UINT, REFGUID, VARIANT*); 600 HRESULT GetImplTypeCustData(UINT, REFGUID, VARIANT*); 601 HRESULT GetDocumentation2(MEMBERID, LCID, BSTR*, DWORD*, BSTR*); 602 HRESULT GetAllCustData(CUSTDATA*); 603 HRESULT GetAllFuncCustData(UINT, CUSTDATA*); 604 HRESULT GetAllParamCustData(UINT, UINT, CUSTDATA*); 605 HRESULT GetAllVarCustData(UINT, CUSTDATA*); 606 HRESULT GetAllImplTypeCustData(UINT, CUSTDATA*); 607 } 608 alias ITypeInfo2 LPTYPEINFO2; 609 610 interface ITypeLib : IUnknown { 611 UINT GetTypeInfoCount(); 612 HRESULT GetTypeInfo(UINT, ITypeInfo*); 613 HRESULT GetTypeInfoType(UINT, TYPEKIND*); 614 HRESULT GetTypeInfoOfGuid(REFGUID, ITypeInfo*); 615 HRESULT GetLibAttr(TLIBATTR**); 616 HRESULT GetTypeComp(ITypeComp); 617 HRESULT GetDocumentation(INT, BSTR*, BSTR*, DWORD*, BSTR*); 618 HRESULT IsName(LPOLESTR, ULONG, BOOL*); 619 HRESULT FindName(LPOLESTR, ULONG, ITypeInfo*, MEMBERID*, USHORT*); 620 void ReleaseTLibAttr(TLIBATTR*); 621 } 622 alias ITypeLib LPTYPELIB; 623 624 interface ITypeLib2 : ITypeLib { 625 HRESULT GetCustData(REFGUID, VARIANT*); 626 HRESULT GetLibStatistics(ULONG*, ULONG*); 627 HRESULT GetDocumentation2(INT, LCID, BSTR*, DWORD*, BSTR*); 628 HRESULT GetAllCustData(CUSTDATA*); 629 } 630 alias ITypeLib2 LPTYPELIB2; 631 632 interface IErrorInfo : IUnknown { 633 HRESULT GetGUID(GUID*); 634 HRESULT GetSource(BSTR*); 635 HRESULT GetDescription(BSTR*); 636 HRESULT GetHelpFile(BSTR*); 637 HRESULT GetHelpContext(DWORD*); 638 } 639 alias IErrorInfo LPERRORINFO; 640 641 interface ICreateErrorInfo : IUnknown { 642 HRESULT SetGUID(REFGUID); 643 HRESULT SetSource(LPOLESTR); 644 HRESULT SetDescription(LPOLESTR); 645 HRESULT SetHelpFile(LPOLESTR); 646 HRESULT SetHelpContext(DWORD); 647 } 648 alias ICreateErrorInfo LPCREATEERRORINFO; 649 650 interface ISupportErrorInfo : IUnknown { 651 HRESULT InterfaceSupportsErrorInfo(REFIID); 652 } 653 alias ISupportErrorInfo LPSUPPORTERRORINFO; 654 655 interface IRecordInfo : IUnknown { 656 HRESULT RecordInit(PVOID); 657 HRESULT RecordClear(PVOID); 658 HRESULT RecordCopy(PVOID, PVOID); 659 HRESULT GetGuid(GUID*); 660 HRESULT GetName(BSTR*); 661 HRESULT GetSize(ULONG*); 662 HRESULT GetTypeInfo(ITypeInfo*); 663 HRESULT GetField(PVOID, LPCOLESTR, VARIANT*); 664 HRESULT GetFieldNoCopy(PVOID, LPCOLESTR, VARIANT*, PVOID*); 665 HRESULT PutField (ULONG, PVOID, LPCOLESTR, VARIANT*); 666 HRESULT PutFieldNoCopy(ULONG, PVOID, LPCOLESTR, VARIANT*); 667 HRESULT GetFieldNames(ULONG*, BSTR*); 668 BOOL IsMatchingType(); 669 PVOID RecordCreate(); 670 HRESULT RecordCreateCopy(PVOID, PVOID*); 671 HRESULT RecordDestroy (PVOID); 672 } 673 alias IRecordInfo LPRECORDINFO; 674 675 interface ITypeMarshal : IUnknown { 676 HRESULT Size(PVOID, DWORD, PVOID, ULONG*); 677 HRESULT Marshal(PVOID, DWORD, PVOID, ULONG, BYTE*, ULONG*); 678 HRESULT Unmarshal(PVOID, DWORD, ULONG, BYTE*, ULONG*); 679 HRESULT Free(PVOID); 680 }