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