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