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