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/_objidl.d) 8 */ 9 // TODO (Don): 10 // # why is "alias IPSFactoryBuffer* LPPSFACTORYBUFFER;" in this file, 11 // rather than in objfwd ? 12 // # do we need the proxies that are defined in this file? 13 /// Automatically imported and edited from the druntime module 14 /// core.sys.windows.objidl for the auto-generated win32 package. 15 module win32.objidl; 16 //version (Windows): 17 @system: 18 19 import win32.unknwn; 20 import win32.objfwd; 21 import win32.windef; 22 import win32.basetyps; 23 import win32.oleidl; 24 import win32.wtypes; 25 import win32.winbase; // for FILETIME 26 import win32.rpcdce; 27 28 struct STATSTG { 29 LPOLESTR pwcsName; 30 DWORD type; 31 ULARGE_INTEGER cbSize; 32 FILETIME mtime; 33 FILETIME ctime; 34 FILETIME atime; 35 DWORD grfMode; 36 DWORD grfLocksSupported; 37 CLSID clsid; 38 DWORD grfStateBits; 39 DWORD reserved; 40 } 41 42 enum STGTY { 43 STGTY_STORAGE = 1, 44 STGTY_STREAM, 45 STGTY_LOCKBYTES, 46 STGTY_PROPERTY 47 } 48 49 enum STREAM_SEEK { 50 STREAM_SEEK_SET, 51 STREAM_SEEK_CUR, 52 STREAM_SEEK_END 53 } 54 55 struct INTERFACEINFO { 56 LPUNKNOWN pUnk; 57 IID iid; 58 WORD wMethod; 59 } 60 alias INTERFACEINFO* LPINTERFACEINFO; 61 62 enum CALLTYPE { 63 CALLTYPE_TOPLEVEL = 1, 64 CALLTYPE_NESTED, 65 CALLTYPE_ASYNC, 66 CALLTYPE_TOPLEVEL_CALLPENDING, 67 CALLTYPE_ASYNC_CALLPENDING 68 } 69 70 enum PENDINGTYPE { 71 PENDINGTYPE_TOPLEVEL = 1, 72 PENDINGTYPE_NESTED 73 } 74 75 enum PENDINGMSG { 76 PENDINGMSG_CANCELCALL = 0, 77 PENDINGMSG_WAITNOPROCESS, 78 PENDINGMSG_WAITDEFPROCESS 79 } 80 81 alias OLECHAR** SNB; 82 83 enum DATADIR { 84 DATADIR_GET = 1, 85 DATADIR_SET 86 } 87 alias WORD CLIPFORMAT; 88 alias CLIPFORMAT* LPCLIPFORMAT; 89 90 struct DVTARGETDEVICE { 91 DWORD tdSize; 92 WORD tdDriverNameOffset; 93 WORD tdDeviceNameOffset; 94 WORD tdPortNameOffset; 95 WORD tdExtDevmodeOffset; 96 BYTE[1] tdData; 97 } 98 99 struct FORMATETC { 100 CLIPFORMAT cfFormat; 101 DVTARGETDEVICE* ptd; 102 DWORD dwAspect; 103 LONG lindex; 104 DWORD tymed; 105 } 106 alias FORMATETC* LPFORMATETC; 107 108 struct RemSTGMEDIUM { 109 DWORD tymed; 110 DWORD dwHandleType; 111 ULONG pData; 112 uint pUnkForRelease; 113 uint cbData; 114 BYTE[1] data; 115 } 116 117 struct HLITEM { 118 ULONG uHLID; 119 LPWSTR pwzFriendlyName; 120 } 121 122 struct STATDATA { 123 FORMATETC formatetc; 124 DWORD grfAdvf; 125 IAdviseSink pAdvSink; 126 DWORD dwConnection; 127 } 128 129 struct STATPROPSETSTG { 130 FMTID fmtid; 131 CLSID clsid; 132 DWORD grfFlags; 133 FILETIME mtime; 134 FILETIME ctime; 135 FILETIME atime; 136 } 137 138 enum EXTCONN { 139 EXTCONN_STRONG = 1, 140 EXTCONN_WEAK = 2, 141 EXTCONN_CALLABLE = 4 142 } 143 144 struct MULTI_QI { 145 const(IID)* pIID; 146 IUnknown pItf; 147 HRESULT hr; 148 } 149 150 struct AUTH_IDENTITY { 151 USHORT* User; 152 ULONG UserLength; 153 USHORT* Domain; 154 ULONG DomainLength; 155 USHORT* Password; 156 ULONG PasswordLength; 157 ULONG Flags; 158 } 159 160 struct COAUTHINFO { 161 DWORD dwAuthnSvc; 162 DWORD dwAuthzSvc; 163 LPWSTR pwszServerPrincName; 164 DWORD dwAuthnLevel; 165 DWORD dwImpersonationLevel; 166 AUTH_IDENTITY* pAuthIdentityData; 167 DWORD dwCapabilities; 168 } 169 170 struct COSERVERINFO { 171 DWORD dwReserved1; 172 LPWSTR pwszName; 173 COAUTHINFO* pAuthInfo; 174 DWORD dwReserved2; 175 } 176 177 struct BIND_OPTS { 178 DWORD cbStruct; 179 DWORD grfFlags; 180 DWORD grfMode; 181 DWORD dwTickCountDeadline; 182 } 183 alias BIND_OPTS* LPBIND_OPTS; 184 185 struct BIND_OPTS2 { 186 DWORD cbStruct; 187 DWORD grfFlags; 188 DWORD grfMode; 189 DWORD dwTickCountDeadline; 190 DWORD dwTrackFlags; 191 DWORD dwClassContext; 192 LCID locale; 193 COSERVERINFO* pServerInfo; 194 } 195 alias BIND_OPTS2* LPBIND_OPTS2; 196 197 enum BIND_FLAGS { 198 BIND_MAYBOTHERUSER = 1, 199 BIND_JUSTTESTEXISTENCE 200 } 201 202 struct STGMEDIUM { 203 DWORD tymed; 204 union { 205 HBITMAP hBitmap; 206 PVOID hMetaFilePict; 207 HENHMETAFILE hEnhMetaFile; 208 HGLOBAL hGlobal; 209 LPWSTR lpszFileName; 210 LPSTREAM pstm; 211 LPSTORAGE pstg; 212 } 213 LPUNKNOWN pUnkForRelease; 214 } 215 alias STGMEDIUM* LPSTGMEDIUM; 216 217 enum LOCKTYPE { 218 LOCK_WRITE = 1, 219 LOCK_EXCLUSIVE = 2, 220 LOCK_ONLYONCE = 4 221 } 222 223 alias uint RPCOLEDATAREP; 224 225 struct RPCOLEMESSAGE { 226 PVOID reserved1; 227 RPCOLEDATAREP dataRepresentation; 228 PVOID Buffer; 229 ULONG cbBuffer; 230 ULONG iMethod; 231 PVOID[5] reserved2; 232 ULONG rpcFlags; 233 } 234 alias RPCOLEMESSAGE* PRPCOLEMESSAGE; 235 236 enum MKSYS { 237 MKSYS_NONE, 238 MKSYS_GENERICCOMPOSITE, 239 MKSYS_FILEMONIKER, 240 MKSYS_ANTIMONIKER, 241 MKSYS_ITEMMONIKER, 242 MKSYS_POINTERMONIKER 243 } 244 245 enum MKREDUCE { 246 MKRREDUCE_ALL, 247 MKRREDUCE_ONE = 196608, 248 MKRREDUCE_TOUSER = 131072, 249 MKRREDUCE_THROUGHUSER = 65536 250 } 251 252 struct RemSNB { 253 uint ulCntStr; 254 uint ulCntChar; 255 OLECHAR[1] rgString = 0; 256 } 257 258 enum ADVF { 259 ADVF_NODATA = 1, 260 ADVF_PRIMEFIRST = 2, 261 ADVF_ONLYONCE = 4, 262 ADVFCACHE_NOHANDLER = 8, 263 ADVFCACHE_FORCEBUILTIN = 16, 264 ADVFCACHE_ONSAVE = 32, 265 ADVF_DATAONSTOP = 64 266 } 267 268 enum TYMED { 269 TYMED_HGLOBAL = 1, 270 TYMED_FILE = 2, 271 TYMED_ISTREAM = 4, 272 TYMED_ISTORAGE = 8, 273 TYMED_GDI = 16, 274 TYMED_MFPICT = 32, 275 TYMED_ENHMF = 64, 276 TYMED_NULL = 0 277 } 278 279 enum SERVERCALL { 280 SERVERCALL_ISHANDLED, 281 SERVERCALL_REJECTED, 282 SERVERCALL_RETRYLATER 283 } 284 285 struct CAUB { 286 ULONG cElems; 287 ubyte* pElems; 288 } 289 290 struct CAI { 291 ULONG cElems; 292 short* pElems; 293 } 294 295 struct CAUI { 296 ULONG cElems; 297 USHORT* pElems; 298 } 299 300 struct CAL { 301 ULONG cElems; 302 int* pElems; 303 } 304 305 struct CAUL { 306 ULONG cElems; 307 ULONG* pElems; 308 } 309 310 struct CAFLT { 311 ULONG cElems; 312 float* pElems; 313 } 314 315 struct CADBL { 316 ULONG cElems; 317 double* pElems; 318 } 319 320 struct CACY { 321 ULONG cElems; 322 CY* pElems; 323 } 324 325 struct CADATE { 326 ULONG cElems; 327 DATE* pElems; 328 } 329 330 struct CABSTR { 331 ULONG cElems; 332 BSTR* pElems; 333 } 334 335 struct CABSTRBLOB { 336 ULONG cElems; 337 BSTRBLOB* pElems; 338 } 339 340 struct CABOOL { 341 ULONG cElems; 342 VARIANT_BOOL* pElems; 343 } 344 345 struct CASCODE { 346 ULONG cElems; 347 SCODE* pElems; 348 } 349 350 struct CAH { 351 ULONG cElems; 352 LARGE_INTEGER* pElems; 353 } 354 355 struct CAUH { 356 ULONG cElems; 357 ULARGE_INTEGER* pElems; 358 } 359 360 struct CALPSTR { 361 ULONG cElems; 362 LPSTR* pElems; 363 } 364 365 struct CALPWSTR { 366 ULONG cElems; 367 LPWSTR* pElems; 368 } 369 370 struct CAFILETIME { 371 ULONG cElems; 372 FILETIME* pElems; 373 } 374 375 struct CACLIPDATA { 376 ULONG cElems; 377 CLIPDATA* pElems; 378 } 379 380 struct CACLSID { 381 ULONG cElems; 382 CLSID* pElems; 383 } 384 alias PROPVARIANT* LPPROPVARIANT; 385 386 struct CAPROPVARIANT { 387 ULONG cElems; 388 LPPROPVARIANT pElems; 389 } 390 391 struct PROPVARIANT { 392 VARTYPE vt; 393 WORD wReserved1; 394 WORD wReserved2; 395 WORD wReserved3; 396 union { 397 CHAR cVal = 0; 398 UCHAR bVal; 399 short iVal; 400 USHORT uiVal; 401 VARIANT_BOOL boolVal; 402 int lVal; 403 ULONG ulVal; 404 float fltVal; 405 SCODE scode; 406 LARGE_INTEGER hVal; 407 ULARGE_INTEGER uhVal; 408 double dblVal; 409 CY cyVal; 410 DATE date; 411 FILETIME filetime; 412 CLSID* puuid; 413 BLOB blob; 414 CLIPDATA* pclipdata; 415 LPSTREAM pStream; 416 LPSTORAGE pStorage; 417 BSTR bstrVal; 418 BSTRBLOB bstrblobVal; 419 LPSTR pszVal; 420 LPWSTR pwszVal; 421 CAUB caub; 422 CAI cai; 423 CAUI caui; 424 CABOOL cabool; 425 CAL cal; 426 CAUL caul; 427 CAFLT caflt; 428 CASCODE cascode; 429 CAH cah; 430 CAUH cauh; 431 CADBL cadbl; 432 CACY cacy; 433 CADATE cadate; 434 CAFILETIME cafiletime; 435 CACLSID cauuid; 436 CACLIPDATA caclipdata; 437 CABSTR cabstr; 438 CABSTRBLOB cabstrblob; 439 CALPSTR calpstr; 440 CALPWSTR calpwstr; 441 CAPROPVARIANT capropvar; 442 } 443 } 444 445 struct PROPSPEC { 446 ULONG ulKind; 447 union { 448 PROPID propid; 449 LPOLESTR lpwstr; 450 } 451 } 452 453 struct STATPROPSTG { 454 LPOLESTR lpwstrName; 455 PROPID propid; 456 VARTYPE vt; 457 } 458 459 enum PROPSETFLAG { 460 PROPSETFLAG_DEFAULT, 461 PROPSETFLAG_NONSIMPLE, 462 PROPSETFLAG_ANSI, 463 PROPSETFLAG_UNBUFFERED = 4 464 } 465 466 struct STORAGELAYOUT { 467 DWORD LayoutType; 468 OLECHAR* pwcsElementName; 469 LARGE_INTEGER cOffset; 470 LARGE_INTEGER cBytes; 471 } 472 473 struct SOLE_AUTHENTICATION_SERVICE { 474 DWORD dwAuthnSvc; 475 DWORD dwAuthzSvc; 476 OLECHAR* pPrincipalName; 477 HRESULT hr; 478 } 479 480 enum OLECHAR* COLE_DEFAULT_PRINCIPAL = cast ( OLECHAR* )(-1); 481 482 enum EOLE_AUTHENTICATION_CAPABILITIES { 483 EOAC_NONE = 0, 484 EOAC_MUTUAL_AUTH = 0x1, 485 EOAC_SECURE_REFS = 0x2, 486 EOAC_ACCESS_CONTROL = 0x4, 487 EOAC_APPID = 0x8, 488 EOAC_DYNAMIC = 0x10, 489 EOAC_STATIC_CLOAKING = 0x20, 490 EOAC_DYNAMIC_CLOAKING = 0x40, 491 EOAC_ANY_AUTHORITY = 0x80, 492 EOAC_MAKE_FULLSIC = 0x100, 493 EOAC_REQUIRE_FULLSIC = 0x200, 494 EOAC_AUTO_IMPERSONATE = 0x400, 495 EOAC_DEFAULT = 0x800, 496 EOAC_DISABLE_AAA = 0x1000, 497 EOAC_NO_CUSTOM_MARSHAL = 0x2000 498 } 499 500 struct SOLE_AUTHENTICATION_INFO { 501 DWORD dwAuthnSvc; 502 DWORD dwAuthzSvc; 503 void* pAuthInfo; 504 } 505 506 enum void* COLE_DEFAULT_AUTHINFO = cast( void* )(-1 ); 507 508 struct SOLE_AUTHENTICATION_LIST { 509 DWORD cAuthInfo; 510 SOLE_AUTHENTICATION_INFO* aAuthInfo; 511 } 512 513 interface IEnumFORMATETC : IUnknown { 514 HRESULT Next(ULONG, FORMATETC*, ULONG*); 515 HRESULT Skip(ULONG); 516 HRESULT Reset(); 517 HRESULT Clone(IEnumFORMATETC*); 518 } 519 520 interface IEnumHLITEM : IUnknown { 521 HRESULT Next(ULONG, HLITEM*, ULONG*); 522 HRESULT Skip(ULONG); 523 HRESULT Reset(); 524 HRESULT Clone(IEnumHLITEM*); 525 } 526 527 interface IEnumSTATDATA : IUnknown { 528 HRESULT Next(ULONG, STATDATA*, ULONG*); 529 HRESULT Skip(ULONG); 530 HRESULT Reset(); 531 HRESULT Clone(IEnumSTATDATA*); 532 } 533 534 interface IEnumSTATPROPSETSTG : IUnknown { 535 HRESULT Next(ULONG, STATPROPSETSTG*, ULONG*); 536 HRESULT Skip(ULONG); 537 HRESULT Reset(); 538 HRESULT Clone(IEnumSTATPROPSETSTG*); 539 } 540 541 interface IEnumSTATPROPSTG : IUnknown { 542 HRESULT Next(ULONG, STATPROPSTG*, ULONG*); 543 HRESULT Skip(ULONG); 544 HRESULT Reset(); 545 HRESULT Clone(IEnumSTATPROPSTG*); 546 } 547 548 interface IEnumSTATSTG : IUnknown { 549 HRESULT Next(ULONG, STATSTG*, ULONG*); 550 HRESULT Skip(ULONG); 551 HRESULT Reset(); 552 HRESULT Clone(IEnumSTATSTG*); 553 } 554 555 interface IEnumString : IUnknown { 556 HRESULT Next(ULONG, LPOLESTR*, ULONG*); 557 HRESULT Skip(ULONG); 558 HRESULT Reset(); 559 HRESULT Clone(IEnumString*); 560 } 561 562 interface IEnumMoniker : IUnknown { 563 HRESULT Next(ULONG, IMoniker*, ULONG*); 564 HRESULT Skip(ULONG); 565 HRESULT Reset(); 566 HRESULT Clone(IEnumMoniker*); 567 } 568 569 570 interface IEnumUnknown : IUnknown { 571 HRESULT Next(ULONG, IUnknown*, ULONG*); 572 HRESULT Skip(ULONG); 573 HRESULT Reset(); 574 HRESULT Clone(IEnumUnknown*); 575 } 576 577 interface ISequentialStream : IUnknown { 578 HRESULT Read(void*, ULONG, ULONG*); 579 HRESULT Write(void* , ULONG, ULONG*); 580 } 581 582 interface IStream : ISequentialStream { 583 HRESULT Seek(LARGE_INTEGER, DWORD, ULARGE_INTEGER*); 584 HRESULT SetSize(ULARGE_INTEGER); 585 HRESULT CopyTo(IStream, ULARGE_INTEGER, ULARGE_INTEGER*, ULARGE_INTEGER*); 586 HRESULT Commit(DWORD); 587 HRESULT Revert(); 588 HRESULT LockRegion(ULARGE_INTEGER, ULARGE_INTEGER, DWORD); 589 HRESULT UnlockRegion(ULARGE_INTEGER, ULARGE_INTEGER, DWORD); 590 HRESULT Stat(STATSTG*, DWORD); 591 HRESULT Clone(LPSTREAM*); 592 } 593 594 interface IMarshal : IUnknown { 595 HRESULT GetUnmarshalClass(REFIID, PVOID, DWORD, PVOID, DWORD, CLSID*); 596 HRESULT GetMarshalSizeMax(REFIID, PVOID, DWORD, PVOID, DWORD, ULONG*); 597 HRESULT MarshalInterface(IStream, REFIID, PVOID, DWORD, PVOID, DWORD); 598 HRESULT UnmarshalInterface(IStream, REFIID, void**); 599 HRESULT ReleaseMarshalData(IStream); 600 HRESULT DisconnectObject(DWORD); 601 } 602 603 interface IStdMarshalInfo : IUnknown { 604 HRESULT GetClassForHandler(DWORD, PVOID, CLSID*); 605 } 606 607 interface IMalloc : IUnknown { 608 void* Alloc(SIZE_T); 609 void* Realloc(void*, SIZE_T); 610 void Free(void*); 611 SIZE_T GetSize(void*); 612 int DidAlloc(void*); 613 void HeapMinimize(); 614 } 615 616 interface IMallocSpy : IUnknown { 617 SIZE_T PreAlloc(SIZE_T); 618 void* PostAlloc(void*); 619 void* PreFree(void*, BOOL); 620 void PostFree(BOOL); 621 SIZE_T PreRealloc(void*, SIZE_T, void**, BOOL); 622 void* PostRealloc(void*, BOOL); 623 void* PreGetSize(void*, BOOL); 624 SIZE_T PostGetSize(SIZE_T, BOOL); 625 void* PreDidAlloc(void*, BOOL); 626 int PostDidAlloc(void*, BOOL, int); 627 void PreHeapMinimize(); 628 void PostHeapMinimize(); 629 } 630 631 interface IMessageFilter : IUnknown { 632 DWORD HandleInComingCall(DWORD, HTASK, DWORD, LPINTERFACEINFO); 633 DWORD RetryRejectedCall(HTASK, DWORD, DWORD); 634 DWORD MessagePending(HTASK, DWORD, DWORD); 635 } 636 637 638 interface IPersist : IUnknown { 639 HRESULT GetClassID(CLSID*); 640 } 641 642 interface IPersistStream : IPersist { 643 HRESULT IsDirty(); 644 HRESULT Load(IStream); 645 HRESULT Save(IStream, BOOL); 646 HRESULT GetSizeMax(PULARGE_INTEGER); 647 } 648 649 interface IRunningObjectTable : IUnknown { 650 HRESULT Register(DWORD, LPUNKNOWN, LPMONIKER, PDWORD); 651 HRESULT Revoke(DWORD); 652 HRESULT IsRunning(LPMONIKER); 653 HRESULT GetObject(LPMONIKER, LPUNKNOWN*); 654 HRESULT NoteChangeTime(DWORD, LPFILETIME); 655 HRESULT GetTimeOfLastChange(LPMONIKER, LPFILETIME); 656 HRESULT EnumRunning(IEnumMoniker*); 657 } 658 659 interface IBindCtx : IUnknown { 660 HRESULT RegisterObjectBound(LPUNKNOWN); 661 HRESULT RevokeObjectBound(LPUNKNOWN); 662 HRESULT ReleaseBoundObjects(); 663 HRESULT SetBindOptions(LPBIND_OPTS); 664 HRESULT GetBindOptions(LPBIND_OPTS); 665 HRESULT GetRunningObjectTable(IRunningObjectTable*); 666 HRESULT RegisterObjectParam(LPOLESTR, IUnknown); 667 HRESULT GetObjectParam(LPOLESTR, IUnknown*); 668 HRESULT EnumObjectParam(IEnumString*); 669 HRESULT RevokeObjectParam(LPOLESTR); 670 } 671 672 interface IMoniker: IPersistStream { 673 HRESULT BindToObject(IBindCtx, IMoniker, REFIID, PVOID*); 674 HRESULT BindToStorage(IBindCtx, IMoniker, REFIID, PVOID*); 675 HRESULT Reduce(IBindCtx, DWORD, IMoniker*, IMoniker*); 676 HRESULT ComposeWith(IMoniker, BOOL, IMoniker*); 677 HRESULT Enum(BOOL, IEnumMoniker*); 678 HRESULT IsEqual(IMoniker); 679 HRESULT Hash(PDWORD); 680 HRESULT IsRunning(IBindCtx, IMoniker, IMoniker); 681 HRESULT GetTimeOfLastChange(IBindCtx, IMoniker, LPFILETIME); 682 HRESULT Inverse(IMoniker*); 683 HRESULT CommonPrefixWith(IMoniker, IMoniker*); 684 HRESULT RelativePathTo(IMoniker, IMoniker*); 685 HRESULT GetDisplayName(IBindCtx, IMoniker, LPOLESTR*); 686 HRESULT ParseDisplayName(IBindCtx, IMoniker, LPOLESTR, ULONG*, IMoniker*); 687 HRESULT IsSystemMoniker(PDWORD); 688 } 689 690 interface IPersistStorage : IPersist 691 { 692 HRESULT IsDirty(); 693 HRESULT InitNew(LPSTORAGE); 694 HRESULT Load(LPSTORAGE); 695 HRESULT Save(LPSTORAGE, BOOL); 696 HRESULT SaveCompleted(LPSTORAGE); 697 HRESULT HandsOffStorage(); 698 } 699 700 interface IPersistFile : IPersist 701 { 702 HRESULT IsDirty(); 703 HRESULT Load(LPCOLESTR, DWORD); 704 HRESULT Save(LPCOLESTR, BOOL); 705 HRESULT SaveCompleted(LPCOLESTR); 706 HRESULT GetCurFile(LPOLESTR*); 707 } 708 709 interface IAdviseSink : IUnknown { 710 HRESULT QueryInterface(REFIID, PVOID*); 711 ULONG AddRef(); 712 ULONG Release(); 713 void OnDataChange(FORMATETC*, STGMEDIUM*); 714 void OnViewChange(DWORD, LONG); 715 void OnRename(IMoniker); 716 void OnSave(); 717 void OnClose(); 718 } 719 720 interface IAdviseSink2 : IAdviseSink 721 { 722 void OnLinkSrcChange(IMoniker); 723 } 724 725 interface IDataObject : IUnknown { 726 HRESULT GetData(FORMATETC*, STGMEDIUM*); 727 HRESULT GetDataHere(FORMATETC*, STGMEDIUM*); 728 HRESULT QueryGetData(FORMATETC*); 729 HRESULT GetCanonicalFormatEtc(FORMATETC*, FORMATETC*); 730 HRESULT SetData(FORMATETC*, STGMEDIUM*, BOOL); 731 HRESULT EnumFormatEtc(DWORD, IEnumFORMATETC*); 732 HRESULT DAdvise(FORMATETC*, DWORD, IAdviseSink, PDWORD); 733 HRESULT DUnadvise(DWORD); 734 HRESULT EnumDAdvise(IEnumSTATDATA*); 735 } 736 737 interface IDataAdviseHolder : IUnknown { 738 HRESULT Advise(IDataObject, FORMATETC*, DWORD, IAdviseSink, PDWORD); 739 HRESULT Unadvise(DWORD); 740 HRESULT EnumAdvise(IEnumSTATDATA*); 741 HRESULT SendOnDataChange(IDataObject, DWORD, DWORD); 742 } 743 744 interface IStorage : IUnknown { 745 HRESULT CreateStream(LPCWSTR, DWORD, DWORD, DWORD, IStream); 746 HRESULT OpenStream(LPCWSTR, PVOID, DWORD, DWORD, IStream); 747 HRESULT CreateStorage(LPCWSTR, DWORD, DWORD, DWORD, IStorage); 748 HRESULT OpenStorage(LPCWSTR, IStorage, DWORD, SNB, DWORD, IStorage); 749 HRESULT CopyTo(DWORD, IID* , SNB, IStorage); 750 HRESULT MoveElementTo(LPCWSTR, IStorage, LPCWSTR, DWORD); 751 HRESULT Commit(DWORD); 752 HRESULT Revert(); 753 HRESULT EnumElements(DWORD, PVOID, DWORD, IEnumSTATSTG); 754 HRESULT DestroyElement(LPCWSTR); 755 HRESULT RenameElement(LPCWSTR, LPCWSTR); 756 HRESULT SetElementTimes(LPCWSTR, FILETIME* , FILETIME* , FILETIME* ); 757 HRESULT SetClass(REFCLSID); 758 HRESULT SetStateBits(DWORD, DWORD); 759 HRESULT Stat(STATSTG*, DWORD); 760 } 761 762 // FIXME: GetClassID from IPersist not there - what to do about it? 763 interface IRootStorage : IPersist { 764 HRESULT QueryInterface(REFIID, PVOID*); 765 ULONG AddRef(); 766 ULONG Release(); 767 HRESULT SwitchToFile(LPOLESTR); 768 } 769 770 interface IRpcChannelBuffer : IUnknown { 771 HRESULT GetBuffer(RPCOLEMESSAGE*, REFIID); 772 HRESULT SendReceive(RPCOLEMESSAGE*, PULONG); 773 HRESULT FreeBuffer(RPCOLEMESSAGE*); 774 HRESULT GetDestCtx(PDWORD, PVOID*); 775 HRESULT IsConnected(); 776 } 777 778 interface IRpcProxyBuffer : IUnknown { 779 HRESULT Connect(IRpcChannelBuffer); 780 void Disconnect(); 781 } 782 783 interface IRpcStubBuffer : IUnknown { 784 HRESULT Connect(LPUNKNOWN); 785 void Disconnect(); 786 HRESULT Invoke(RPCOLEMESSAGE*, LPRPCSTUBBUFFER); 787 LPRPCSTUBBUFFER IsIIDSupported(REFIID); 788 ULONG CountRefs(); 789 HRESULT DebugServerQueryInterface(PVOID*); 790 HRESULT DebugServerRelease(PVOID); 791 } 792 793 interface IPSFactoryBuffer : IUnknown { 794 HRESULT CreateProxy(LPUNKNOWN, REFIID, LPRPCPROXYBUFFER*, PVOID*); 795 HRESULT CreateStub(REFIID, LPUNKNOWN, LPRPCSTUBBUFFER*); 796 } 797 alias IPSFactoryBuffer LPPSFACTORYBUFFER; 798 799 interface ILockBytes : IUnknown { 800 HRESULT ReadAt(ULARGE_INTEGER, PVOID, ULONG, ULONG*); 801 HRESULT WriteAt(ULARGE_INTEGER, PCVOID, ULONG, ULONG*); 802 HRESULT Flush(); 803 HRESULT SetSize(ULARGE_INTEGER); 804 HRESULT LockRegion(ULARGE_INTEGER, ULARGE_INTEGER, DWORD); 805 HRESULT UnlockRegion(ULARGE_INTEGER, ULARGE_INTEGER, DWORD); 806 HRESULT Stat(STATSTG*, DWORD); 807 } 808 809 interface IExternalConnection : IUnknown { 810 HRESULT AddConnection(DWORD, DWORD); 811 HRESULT ReleaseConnection(DWORD, DWORD, BOOL); 812 } 813 814 interface IRunnableObject : IUnknown { 815 HRESULT GetRunningClass(LPCLSID); 816 HRESULT Run(LPBC); 817 BOOL IsRunning(); 818 HRESULT LockRunning(BOOL, BOOL); 819 HRESULT SetContainedObject(BOOL); 820 } 821 822 interface IROTData : IUnknown { 823 HRESULT GetComparisonData(PVOID, ULONG, PULONG); 824 } 825 826 interface IChannelHook : IUnknown { 827 void ClientGetSize(REFGUID, REFIID, PULONG); 828 void ClientFillBuffer(REFGUID, REFIID, PULONG, PVOID); 829 void ClientNotify(REFGUID, REFIID, ULONG, PVOID, DWORD, HRESULT); 830 void ServerNotify(REFGUID, REFIID, ULONG, PVOID, DWORD); 831 void ServerGetSize(REFGUID, REFIID, HRESULT, PULONG); 832 void ServerFillBuffer(REFGUID, REFIID, PULONG, PVOID, HRESULT); 833 } 834 835 interface IPropertyStorage : IUnknown { 836 HRESULT ReadMultiple(ULONG, PROPSPEC* , PROPVARIANT*); 837 HRESULT WriteMultiple(ULONG, PROPSPEC* , PROPVARIANT*, PROPID); 838 HRESULT DeleteMultiple(ULONG, PROPSPEC* ); 839 HRESULT ReadPropertyNames(ULONG, PROPID* , LPWSTR*); 840 HRESULT WritePropertyNames(ULONG, PROPID* , LPWSTR* ); 841 HRESULT DeletePropertyNames(ULONG, PROPID* ); 842 HRESULT SetClass(REFCLSID); 843 HRESULT Commit(DWORD); 844 HRESULT Revert(); 845 HRESULT Enum(IEnumSTATPROPSTG*); 846 HRESULT Stat(STATPROPSTG*); 847 HRESULT SetTimes(FILETIME* , FILETIME* , FILETIME* ); 848 } 849 850 interface IPropertySetStorage : IUnknown { 851 HRESULT Create(REFFMTID, CLSID*, DWORD, DWORD, LPPROPERTYSTORAGE*); 852 HRESULT Open(REFFMTID, DWORD, LPPROPERTYSTORAGE*); 853 HRESULT Delete(REFFMTID); 854 HRESULT Enum(IEnumSTATPROPSETSTG*); 855 } 856 857 interface IClientSecurity : IUnknown { 858 HRESULT QueryBlanket(PVOID, PDWORD, PDWORD, OLECHAR**, PDWORD, PDWORD, RPC_AUTH_IDENTITY_HANDLE**, PDWORD*); 859 HRESULT SetBlanket(PVOID, DWORD, DWORD, LPWSTR, DWORD, DWORD, RPC_AUTH_IDENTITY_HANDLE*, DWORD); 860 HRESULT CopyProxy(LPUNKNOWN, LPUNKNOWN*); 861 } 862 863 interface IServerSecurity : IUnknown { 864 HRESULT QueryBlanket(PDWORD, PDWORD, OLECHAR**, PDWORD, PDWORD, RPC_AUTHZ_HANDLE*, PDWORD*); 865 HRESULT ImpersonateClient(); 866 HRESULT RevertToSelf(); 867 HRESULT IsImpersonating(); 868 } 869 870 interface IClassActivator : IUnknown { 871 HRESULT GetClassObject(REFCLSID, DWORD, LCID, REFIID, PVOID*); 872 } 873 874 interface IFillLockBytes : IUnknown { 875 HRESULT FillAppend(void* , ULONG, PULONG); 876 HRESULT FillAt(ULARGE_INTEGER, void* , ULONG, PULONG); 877 HRESULT SetFillSize(ULARGE_INTEGER); 878 HRESULT Terminate(BOOL); 879 } 880 881 interface IProgressNotify : IUnknown { 882 HRESULT OnProgress(DWORD, DWORD, BOOL, BOOL); 883 } 884 885 interface ILayoutStorage : IUnknown { 886 HRESULT LayoutScript(STORAGELAYOUT*, DWORD, DWORD); 887 HRESULT BeginMonitor(); 888 HRESULT EndMonitor(); 889 HRESULT ReLayoutDocfile(OLECHAR*); 890 } 891 892 interface IGlobalInterfaceTable : IUnknown { 893 HRESULT RegisterInterfaceInGlobal(IUnknown, REFIID, DWORD*); 894 HRESULT RevokeInterfaceFromGlobal(DWORD); 895 HRESULT GetInterfaceFromGlobal(DWORD, REFIID, void**); 896 } 897 898 /+ 899 // These are probably unnecessary for D. 900 extern (Windows) { 901 HRESULT IMarshal_GetUnmarshalClass_Proxy(IMarshal, REFIID, void*, DWORD, void*, DWORD, CLSID*); 902 void IMarshal_GetUnmarshalClass_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 903 HRESULT IMarshal_GetMarshalSizeMax_Proxy(IMarshal, REFIID, void*, DWORD, void*, DWORD, DWORD*); 904 void IMarshal_GetMarshalSizeMax_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 905 HRESULT IMarshal_MarshalInterface_Proxy(IMarshal, IStream, REFIID, void*, DWORD, void*, DWORD); 906 void IMarshal_MarshalInterface_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 907 HRESULT IMarshal_UnmarshalInterface_Proxy(IMarshal, IStream, REFIID, void**); 908 void IMarshal_UnmarshalInterface_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 909 HRESULT IMarshal_ReleaseMarshalData_Proxy(IMarshal, IStream); 910 void IMarshal_ReleaseMarshalData_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 911 HRESULT IMarshal_DisconnectObject_Proxy(IMarshal, DWORD); 912 void IMarshal_DisconnectObject_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 913 void* IMalloc_Alloc_Proxy(IMalloc, ULONG); 914 void IMalloc_Alloc_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 915 void* IMalloc_Realloc_Proxy(IMalloc, void*, ULONG); 916 void IMalloc_Realloc_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 917 void IMalloc_Free_Proxy(IMalloc, void*); 918 void IMalloc_Free_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 919 ULONG IMalloc_GetSize_Proxy(IMalloc, void*); 920 void IMalloc_GetSize_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 921 int IMalloc_DidAlloc_Proxy(IMalloc, void*); 922 void IMalloc_DidAlloc_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 923 void IMalloc_HeapMinimize_Proxy(IMalloc); 924 void IMalloc_HeapMinimize_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 925 ULONG IMallocSpy_PreAlloc_Proxy(IMallocSpy, ULONG cbRequest); 926 void IMallocSpy_PreAlloc_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 927 void* IMallocSpy_PostAlloc_Proxy(IMallocSpy, void*); 928 void IMallocSpy_PostAlloc_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 929 void* IMallocSpy_PreFree_Proxy(IMallocSpy, void*, BOOL); 930 void IMallocSpy_PreFree_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 931 void IMallocSpy_PostFree_Proxy(IMallocSpy, BOOL); 932 void IMallocSpy_PostFree_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 933 ULONG IMallocSpy_PreRealloc_Proxy(IMallocSpy, void*, ULONG, void**, BOOL); 934 void IMallocSpy_PreRealloc_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 935 void* IMallocSpy_PostRealloc_Proxy(IMallocSpy, void*, BOOL); 936 void IMallocSpy_PostRealloc_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 937 void* IMallocSpy_PreGetSize_Proxy(IMallocSpy, void*, BOOL); 938 void IMallocSpy_PreGetSize_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 939 ULONG IMallocSpy_PostGetSize_Proxy(IMallocSpy, ULONG, BOOL); 940 void IMallocSpy_PostGetSize_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 941 void* IMallocSpy_PreDidAlloc_Proxy(IMallocSpy, void*, BOOL); 942 void IMallocSpy_PreDidAlloc_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 943 int IMallocSpy_PostDidAlloc_Proxy(IMallocSpy, void*, BOOL, int); 944 void IMallocSpy_PostDidAlloc_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 945 void IMallocSpy_PreHeapMinimize_Proxy(IMallocSpy ); 946 void IMallocSpy_PreHeapMinimize_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 947 void IMallocSpy_PostHeapMinimize_Proxy(IMallocSpy); 948 void IMallocSpy_PostHeapMinimize_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 949 HRESULT IStdMarshalInfo_GetClassForHandler_Proxy(IStdMarshalInfo, DWORD, void*, CLSID*); 950 void IStdMarshalInfo_GetClassForHandler_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 951 DWORD IExternalConnection_AddConnection_Proxy(IExternalConnection, DWORD, DWORD); 952 void IExternalConnection_AddConnection_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 953 DWORD IExternalConnection_ReleaseConnection_Proxy(IExternalConnection, DWORD, DWORD, BOOL); 954 void IExternalConnection_ReleaseConnection_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 955 HRESULT IEnumUnknown_RemoteNext_Proxy(IEnumUnknown, ULONG, IUnknown*, ULONG*); 956 void IEnumUnknown_RemoteNext_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 957 HRESULT IEnumUnknown_Skip_Proxy(IEnumUnknown, ULONG); 958 void IEnumUnknown_Skip_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 959 HRESULT IEnumUnknown_Reset_Proxy(IEnumUnknown ); 960 void IEnumUnknown_Reset_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 961 HRESULT IEnumUnknown_Clone_Proxy(IEnumUnknown, IEnumUnknown*); 962 void IEnumUnknown_Clone_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 963 HRESULT IBindCtx_RegisterObjectBound_Proxy(IBindCtx, IUnknownpunk); 964 void IBindCtx_RegisterObjectBound_Stub(IRpcStubBuffer, IRpcChannelBuffer_pRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 965 HRESULT IBindCtx_RevokeObjectBound_Proxy(IBindCtx, IUnknownpunk); 966 void IBindCtx_RevokeObjectBound_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 967 HRESULT IBindCtx_ReleaseBoundObjects_Proxy(IBindCtx); 968 void IBindCtx_ReleaseBoundObjects_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 969 HRESULT IBindCtx_SetBindOptions_Proxy(IBindCtx, BIND_OPTS*); 970 void IBindCtx_SetBindOptions_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 971 HRESULT IBindCtx_GetBindOptions_Proxy(IBindCtx, BIND_OPTS*pbindopts); 972 void IBindCtx_GetBindOptions_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 973 HRESULT IBindCtx_GetRunningObjectTable_Proxy(IBindCtx, IRunningObjectTable*); 974 void IBindCtx_GetRunningObjectTable_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 975 HRESULT IBindCtx_RegisterObjectParam_Proxy(IBindCtx, LPCSTR, IUnknown); 976 void IBindCtx_RegisterObjectParam_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 977 HRESULT IBindCtx_GetObjectParam_Proxy(IBindCtx, LPCSTR, IUnknown*); 978 void IBindCtx_GetObjectParam_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 979 HRESULT IBindCtx_EnumObjectParam_Proxy(IBindCtx, IEnumString*); 980 void IBindCtx_EnumObjectParam_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 981 HRESULT IBindCtx_RevokeObjectParam_Proxy(IBindCtx, LPCSTR); 982 void IBindCtx_RevokeObjectParam_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 983 HRESULT IEnumMoniker_RemoteNext_Proxy(IEnumMoniker, ULONG, IMoniker*, ULONG*); 984 void IEnumMoniker_RemoteNext_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 985 HRESULT IEnumMoniker_Skip_Proxy(IEnumMoniker, ULONG); 986 void IEnumMoniker_Skip_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 987 HRESULT IEnumMoniker_Reset_Proxy(IEnumMoniker); 988 void IEnumMoniker_Reset_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 989 HRESULT IEnumMoniker_Clone_Proxy(IEnumMoniker, IEnumMoniker*); 990 void IEnumMoniker_Clone_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 991 HRESULT IRunnableObject_GetRunningClass_Proxy(IRunnableObject, LPCLSID); 992 void IRunnableObject_GetRunningClass_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 993 HRESULT IRunnableObject_Run_Proxy(IRunnableObject, LPBINDCTX); 994 void IRunnableObject_Run_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 995 BOOL IRunnableObject_IsRunning_Proxy(IRunnableObject); 996 void IRunnableObject_IsRunning_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 997 HRESULT IRunnableObject_LockRunning_Proxy(IRunnableObject, BOOL, BOOL); 998 void IRunnableObject_LockRunning_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 999 HRESULT IRunnableObject_SetContainedObject_Proxy(IRunnableObject, BOOL); 1000 void IRunnableObject_SetContainedObject_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1001 HRESULT IRunningObjectTable_Register_Proxy(IRunningObjectTable, DWORD, IUnknown, IMoniker, DWORD*); 1002 void IRunningObjectTable_Register_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1003 HRESULT IRunningObjectTable_Revoke_Proxy(IRunningObjectTable, DWORD); 1004 void IRunningObjectTable_Revoke_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1005 HRESULT IRunningObjectTable_IsRunning_Proxy(IRunningObjectTable, IMoniker); 1006 void IRunningObjectTable_IsRunning_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1007 HRESULT IRunningObjectTable_GetObject_Proxy(IRunningObjectTable, IMoniker, IUnknown*); 1008 void IRunningObjectTable_GetObject_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1009 HRESULT IRunningObjectTable_NoteChangeTime_Proxy(IRunningObjectTable, DWORD, FILETIME*); 1010 void IRunningObjectTable_NoteChangeTime_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1011 HRESULT IRunningObjectTable_GetTimeOfLastChange_Proxy(IRunningObjectTable, IMoniker, FILETIME*); 1012 void IRunningObjectTable_GetTimeOfLastChange_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1013 HRESULT IRunningObjectTable_EnumRunning_Proxy(IRunningObjectTable, IEnumMoniker*); 1014 void IRunningObjectTable_EnumRunning_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1015 HRESULT IPersist_GetClassID_Proxy(IPersist, CLSID*); 1016 void IPersist_GetClassID_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1017 HRESULT IPersistStream_IsDirty_Proxy(IPersistStream); 1018 void IPersistStream_IsDirty_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1019 HRESULT IPersistStream_Load_Proxy(IPersistStream, IStream); 1020 void IPersistStream_Load_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1021 HRESULT IPersistStream_Save_Proxy(IPersistStream, IStream, BOOL); 1022 void IPersistStream_Save_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1023 HRESULT IPersistStream_GetSizeMax_Proxy(IPersistStream, ULARGE_INTEGER*); 1024 void IPersistStream_GetSizeMax_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1025 HRESULT IMoniker_RemoteBindToObject_Proxy(IMoniker, IBindCtx, IMoniker, REFIID, IUnknown*); 1026 void IMoniker_RemoteBindToObject_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1027 HRESULT IMoniker_RemoteBindToStorage_Proxy(IMoniker, IBindCtx, IMoniker, REFIID, IUnknown*); 1028 void IMoniker_RemoteBindToStorage_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1029 HRESULT IMoniker_Reduce_Proxy(IMoniker, IBindCtx, DWORD, IMoniker*, IMoniker*); 1030 void IMoniker_Reduce_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1031 HRESULT IMoniker_ComposeWith_Proxy(IMoniker, IMoniker, BOOL, IMoniker*); 1032 void IMoniker_ComposeWith_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1033 HRESULT IMoniker_Enum_Proxy(IMoniker, BOOL, IEnumMoniker*); 1034 void IMoniker_Enum_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1035 HRESULT IMoniker_IsEqual_Proxy(IMoniker, IMoniker); 1036 void IMoniker_IsEqual_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1037 HRESULT IMoniker_Hash_Proxy(IMoniker, DWORD*); 1038 void IMoniker_Hash_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1039 HRESULT IMoniker_IsRunning_Proxy(IMoniker, IBindCtx, IMoniker, IMoniker); 1040 void IMoniker_IsRunning_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1041 HRESULT IMoniker_GetTimeOfLastChange_Proxy(IMoniker, IBindCtx, IMoniker, FILETIME*); 1042 void IMoniker_GetTimeOfLastChange_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1043 HRESULT IMoniker_Inverse_Proxy(IMoniker, IMoniker*); 1044 void IMoniker_Inverse_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1045 HRESULT IMoniker_CommonPrefixWith_Proxy(IMoniker, IMoniker, IMoniker*); 1046 void IMoniker_CommonPrefixWith_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1047 HRESULT IMoniker_RelativePathTo_Proxy(IMoniker, IMoniker, IMoniker*); 1048 void IMoniker_RelativePathTo_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1049 HRESULT IMoniker_GetDisplayName_Proxy(IMoniker, IBindCtx, IMoniker, LPCSTR*); 1050 void IMoniker_GetDisplayName_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1051 HRESULT IMoniker_ParseDisplayName_Proxy(IMoniker, IBindCtx, IMoniker, LPCSTR, ULONG*, IMoniker*); 1052 void IMoniker_ParseDisplayName_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1053 HRESULT IMoniker_IsSystemMoniker_Proxy(IMoniker, DWORD*); 1054 void IMoniker_IsSystemMoniker_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1055 HRESULT IROTData_GetComparisonData_Proxy(IROTData, BYTE*, ULONG cbMax, ULONG*); 1056 void IROTData_GetComparisonData_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1057 HRESULT IEnumString_RemoteNext_Proxy(IEnumString, ULONG, LPCSTR*rgelt, ULONG*); 1058 void IEnumString_RemoteNext_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1059 HRESULT IEnumString_Skip_Proxy(IEnumString, ULONG); 1060 void IEnumString_Skip_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1061 HRESULT IEnumString_Reset_Proxy(IEnumString); 1062 void IEnumString_Reset_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1063 HRESULT IEnumString_Clone_Proxy(IEnumString, IEnumString*); 1064 void IEnumString_Clone_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1065 HRESULT IStream_RemoteRead_Proxy(IStream, BYTE*, ULONG, ULONG*); 1066 void IStream_RemoteRead_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1067 HRESULT IStream_RemoteWrite_Proxy(IStream, BYTE*pv, ULONG, ULONG*); 1068 void IStream_RemoteWrite_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1069 HRESULT IStream_RemoteSeek_Proxy(IStream, LARGE_INTEGER, DWORD, ULARGE_INTEGER*); 1070 void IStream_RemoteSeek_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1071 HRESULT IStream_SetSize_Proxy(IStream, ULARGE_INTEGER); 1072 void IStream_SetSize_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1073 HRESULT IStream_RemoteCopyTo_Proxy(IStream, IStream, ULARGE_INTEGER, ULARGE_INTEGER*, ULARGE_INTEGER*); 1074 void IStream_RemoteCopyTo_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1075 HRESULT IStream_Commit_Proxy(IStream, DWORD); 1076 void IStream_Commit_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1077 HRESULT IStream_Revert_Proxy(IStream); 1078 void IStream_Revert_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1079 HRESULT IStream_LockRegion_Proxy(IStream, ULARGE_INTEGER, ULARGE_INTEGER, DWORD); 1080 void IStream_LockRegion_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1081 HRESULT IStream_UnlockRegion_Proxy(IStream, ULARGE_INTEGER, ULARGE_INTEGER, DWORD); 1082 void IStream_UnlockRegion_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1083 HRESULT IStream_Stat_Proxy(IStream, STATSTG*, DWORD); 1084 void IStream_Stat_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1085 HRESULT IStream_Clone_Proxy(IStream, IStream*); 1086 void IStream_Clone_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1087 HRESULT IEnumSTATSTG_RemoteNext_Proxy(IEnumSTATSTG, ULONG, STATSTG*, ULONG*); 1088 void IEnumSTATSTG_RemoteNext_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1089 HRESULT IEnumSTATSTG_Skip_Proxy(IEnumSTATSTG, ULONG celt); 1090 void IEnumSTATSTG_Skip_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1091 HRESULT IEnumSTATSTG_Reset_Proxy(IEnumSTATSTG); 1092 void IEnumSTATSTG_Reset_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1093 HRESULT IEnumSTATSTG_Clone_Proxy(IEnumSTATSTG, IEnumSTATSTG*); 1094 void IEnumSTATSTG_Clone_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1095 HRESULT IStorage_CreateStream_Proxy(IStorage, OLECHAR*, DWORD, DWORD, DWORD, IStream*); 1096 void IStorage_CreateStream_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1097 HRESULT IStorage_RemoteOpenStream_Proxy(IStorage, const(OLECHAR)*, uint, BYTE*, DWORD, DWORD, IStream*); 1098 void IStorage_RemoteOpenStream_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1099 HRESULT IStorage_CreateStorage_Proxy(IStorage, OLECHAR*, DWORD, DWORD, DWORD, IStorage*); 1100 void IStorage_CreateStorage_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1101 HRESULT IStorage_OpenStorage_Proxy(IStorage, OLECHAR*, IStorage, DWORD, SNB, DWORD, IStorage*); 1102 void IStorage_OpenStorage_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1103 HRESULT IStorage_CopyTo_Proxy(IStorage, DWORD, const(IID)*, SNB, IStorage); 1104 void IStorage_CopyTo_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1105 HRESULT IStorage_MoveElementTo_Proxy(IStorage, const(OLECHAR)*, IStorage, const(OLECHAR)*, DWORD); 1106 void IStorage_MoveElementTo_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1107 HRESULT IStorage_Commit_Proxy(IStorage, DWORD); 1108 void IStorage_Commit_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1109 HRESULT IStorage_Revert_Proxy(IStorage); 1110 void IStorage_Revert_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1111 HRESULT IStorage_RemoteEnumElements_Proxy(IStorage, DWORD, uint, BYTE*, DWORD, IEnumSTATSTG*); 1112 void IStorage_RemoteEnumElements_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1113 HRESULT IStorage_DestroyElement_Proxy(IStorage, OLECHAR*); 1114 void IStorage_DestroyElement_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1115 HRESULT IStorage_RenameElement_Proxy(IStorage, const(OLECHAR)*, const(OLECHAR)*); 1116 void IStorage_RenameElement_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1117 HRESULT IStorage_SetElementTimes_Proxy(IStorage, const(OLECHAR)*, const(FILETIME)*, const(FILETIME)*, const(FILETIME)*); 1118 void IStorage_SetElementTimes_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1119 HRESULT IStorage_SetClass_Proxy(IStorage, REFCLSID); 1120 void IStorage_SetClass_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1121 HRESULT IStorage_SetStateBits_Proxy(IStorage, DWORD, DWORD); 1122 void IStorage_SetStateBits_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1123 HRESULT IStorage_Stat_Proxy(IStorage, STATSTG*, DWORD); 1124 void IStorage_Stat_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1125 HRESULT IPersistFile_IsDirty_Proxy(IPersistFile); 1126 void IPersistFile_IsDirty_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1127 HRESULT IPersistFile_Load_Proxy(IPersistFile, LPCOLESTR, DWORD); 1128 void IPersistFile_Load_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1129 HRESULT IPersistFile_Save_Proxy(IPersistFile, LPCOLESTR pszFileName, BOOL); 1130 void IPersistFile_Save_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1131 HRESULT IPersistFile_SaveCompleted_Proxy(IPersistFile, LPCOLESTR); 1132 void IPersistFile_SaveCompleted_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1133 HRESULT IPersistFile_GetCurFile_Proxy(IPersistFile, LPCSTR*); 1134 void IPersistFile_GetCurFile_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1135 HRESULT IPersistStorage_IsDirty_Proxy(IPersistStorage); 1136 void IPersistStorage_IsDirty_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1137 HRESULT IPersistStorage_InitNew_Proxy(IPersistStorage, IStorage); 1138 void IPersistStorage_InitNew_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1139 HRESULT IPersistStorage_Load_Proxy(IPersistStorage, IStorage); 1140 void IPersistStorage_Load_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1141 HRESULT IPersistStorage_Save_Proxy(IPersistStorage, IStorage, BOOL); 1142 void IPersistStorage_Save_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1143 HRESULT IPersistStorage_SaveCompleted_Proxy(IPersistStorage, IStorage); 1144 void IPersistStorage_SaveCompleted_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1145 HRESULT IPersistStorage_HandsOffStorage_Proxy(IPersistStorage); 1146 void IPersistStorage_HandsOffStorage_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1147 HRESULT ILockBytes_RemoteReadAt_Proxy(ILockBytes, ULARGE_INTEGER, BYTE*, ULONG, ULONG*); 1148 void ILockBytes_RemoteReadAt_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1149 HRESULT ILockBytes_RemoteWriteAt_Proxy(ILockBytes, ULARGE_INTEGER, BYTE*pv, ULONG, ULONG*); 1150 void ILockBytes_RemoteWriteAt_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1151 HRESULT ILockBytes_Flush_Proxy(ILockBytes); 1152 void ILockBytes_Flush_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1153 HRESULT ILockBytes_SetSize_Proxy(ILockBytes, ULARGE_INTEGER); 1154 void ILockBytes_SetSize_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1155 HRESULT ILockBytes_LockRegion_Proxy(ILockBytes, ULARGE_INTEGER, ULARGE_INTEGER, DWORD); 1156 void ILockBytes_LockRegion_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1157 HRESULT ILockBytes_UnlockRegion_Proxy(ILockBytes, ULARGE_INTEGER, ULARGE_INTEGER, DWORD); 1158 void ILockBytes_UnlockRegion_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1159 HRESULT ILockBytes_Stat_Proxy(ILockBytes, STATSTG*, DWORD); 1160 void ILockBytes_Stat_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1161 HRESULT IEnumFORMATETC_RemoteNext_Proxy(IEnumFORMATETC, ULONG, FORMATETC*, ULONG*); 1162 void IEnumFORMATETC_RemoteNext_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1163 HRESULT IEnumFORMATETC_Skip_Proxy(IEnumFORMATETC, ULONG); 1164 void IEnumFORMATETC_Skip_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1165 HRESULT IEnumFORMATETC_Reset_Proxy(IEnumFORMATETC); 1166 void IEnumFORMATETC_Reset_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1167 HRESULT IEnumFORMATETC_Clone_Proxy(IEnumFORMATETC, IEnumFORMATETC*); 1168 void IEnumFORMATETC_Clone_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1169 HRESULT IEnumFORMATETC_Next_Proxy(IEnumFORMATETC, ULONG, FORMATETC*, ULONG*); 1170 HRESULT IEnumFORMATETC_Next_Stub(IEnumFORMATETC, ULONG, FORMATETC*, ULONG*); 1171 HRESULT IEnumSTATDATA_RemoteNext_Proxy(IEnumSTATDATA, ULONG, STATDATA*, ULONG*); 1172 void IEnumSTATDATA_RemoteNext_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1173 HRESULT IEnumSTATDATA_Skip_Proxy(IEnumSTATDATA, ULONG); 1174 void IEnumSTATDATA_Skip_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1175 HRESULT IEnumSTATDATA_Reset_Proxy(IEnumSTATDATA); 1176 void IEnumSTATDATA_Reset_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1177 HRESULT IEnumSTATDATA_Clone_Proxy(IEnumSTATDATA, IEnumSTATDATA*); 1178 void IEnumSTATDATA_Clone_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1179 HRESULT IEnumSTATDATA_Next_Proxy(IEnumSTATDATA, ULONG, STATDATA*, ULONG*); 1180 HRESULT IEnumSTATDATA_Next_Stub(IEnumSTATDATA, ULONG, STATDATA*, ULONG*); 1181 HRESULT IRootStorage_SwitchToFile_Proxy(IRootStorage, LPCSTR); 1182 void IRootStorage_SwitchToFile_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1183 void IAdviseSink_RemoteOnDataChange_Proxy(IAdviseSink, FORMATETC*, RemSTGMEDIUM*); 1184 void IAdviseSink_RemoteOnDataChange_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1185 void IAdviseSink_RemoteOnViewChange_Proxy(IAdviseSink, DWORD, LONG); 1186 void IAdviseSink_RemoteOnViewChange_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1187 void IAdviseSink_RemoteOnRename_Proxy(IAdviseSink, IMoniker); 1188 void IAdviseSink_RemoteOnRename_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1189 void IAdviseSink_RemoteOnSave_Proxy(IAdviseSink); 1190 void IAdviseSink_RemoteOnSave_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1191 HRESULT IAdviseSink_RemoteOnClose_Proxy(IAdviseSink); 1192 void IAdviseSink_RemoteOnClose_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1193 void IAdviseSink_OnDataChange_Proxy(IAdviseSink, FORMATETC*, STGMEDIUM*); 1194 void IAdviseSink_OnDataChange_Stub(IAdviseSink, FORMATETC*, RemSTGMEDIUM*); 1195 void IAdviseSink_OnViewChange_Proxy(IAdviseSink, DWORD, LONG); 1196 void IAdviseSink_OnViewChange_Stub(IAdviseSink, DWORD, LONG); 1197 void IAdviseSink_OnRename_Proxy(IAdviseSink, IMoniker); 1198 void IAdviseSink_OnRename_Stub(IAdviseSink, IMoniker); 1199 void IAdviseSink_OnSave_Proxy(IAdviseSink); 1200 void IAdviseSink_OnSave_Stub(IAdviseSink); 1201 void IAdviseSink_OnClose_Proxy(IAdviseSink); 1202 HRESULT IAdviseSink_OnClose_Stub(IAdviseSink); 1203 void IAdviseSink2_RemoteOnLinkSrcChange_Proxy(IAdviseSink2, IMoniker); 1204 void IAdviseSink2_RemoteOnLinkSrcChange_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1205 void IAdviseSink2_OnLinkSrcChange_Proxy(IAdviseSink2, IMoniker); 1206 void IAdviseSink2_OnLinkSrcChange_Stub(IAdviseSink2, IMoniker); 1207 HRESULT IDataObject_RemoteGetData_Proxy(IDataObject, FORMATETC*, RemSTGMEDIUM**); 1208 void IDataObject_RemoteGetData_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1209 HRESULT IDataObject_RemoteGetDataHere_Proxy(IDataObject, FORMATETC*, RemSTGMEDIUM**); 1210 void IDataObject_RemoteGetDataHere_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1211 HRESULT IDataObject_QueryGetData_Proxy(IDataObject, FORMATETC*); 1212 void IDataObject_QueryGetData_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1213 HRESULT IDataObject_GetCanonicalFormatEtc_Proxy(IDataObject, FORMATETC*, FORMATETC*); 1214 void IDataObject_GetCanonicalFormatEtc_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1215 HRESULT IDataObject_RemoteSetData_Proxy(IDataObject, FORMATETC*, RemSTGMEDIUM*, BOOL); 1216 void IDataObject_RemoteSetData_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1217 HRESULT IDataObject_EnumFormatEtc_Proxy(IDataObject, DWORD, IEnumFORMATETC*); 1218 void IDataObject_EnumFormatEtc_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1219 HRESULT IDataObject_DAdvise_Proxy(IDataObject, FORMATETC*, DWORD, IAdviseSink, DWORD*); 1220 void IDataObject_DAdvise_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1221 HRESULT IDataObject_DUnadvise_Proxy(IDataObject, DWORD); 1222 void IDataObject_DUnadvise_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1223 HRESULT IDataObject_EnumDAdvise_Proxy(IDataObject, IEnumSTATDATA*); 1224 void IDataObject_EnumDAdvise_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1225 HRESULT IDataObject_GetData_Proxy(IDataObject, FORMATETC*, STGMEDIUM*); 1226 HRESULT IDataObject_GetData_Stub(IDataObject, FORMATETC*, RemSTGMEDIUM**); 1227 HRESULT IDataObject_GetDataHere_Proxy(IDataObject, FORMATETC*, STGMEDIUM*); 1228 HRESULT IDataObject_GetDataHere_Stub(IDataObject, FORMATETC*, RemSTGMEDIUM**); 1229 HRESULT IDataObject_SetData_Proxy(IDataObject, FORMATETC*, STGMEDIUM*, BOOL); 1230 HRESULT IDataObject_SetData_Stub(IDataObject, FORMATETC*, RemSTGMEDIUM*, BOOL); 1231 HRESULT IDataAdviseHolder_Advise_Proxy(IDataAdviseHolder, IDataObject, FORMATETC*, DWORD, IAdviseSink, DWORD*); 1232 void IDataAdviseHolder_Advise_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1233 HRESULT IDataAdviseHolder_Unadvise_Proxy(IDataAdviseHolder, DWORD); 1234 void IDataAdviseHolder_Unadvise_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1235 HRESULT IDataAdviseHolder_EnumAdvise_Proxy(IDataAdviseHolder, IEnumSTATDATA*); 1236 void IDataAdviseHolder_EnumAdvise_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1237 HRESULT IDataAdviseHolder_SendOnDataChange_Proxy(IDataAdviseHolder, IDataObject, DWORD, DWORD); 1238 void IDataAdviseHolder_SendOnDataChange_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1239 DWORD IMessageFilter_HandleInComingCall_Proxy(IMessageFilter, DWORD, HTASK, DWORD, LPINTERFACEINFO); 1240 void IMessageFilter_HandleInComingCall_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1241 DWORD IMessageFilter_RetryRejectedCall_Proxy(IMessageFilter, HTASK, DWORD, DWORD); 1242 void IMessageFilter_RetryRejectedCall_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1243 DWORD IMessageFilter_MessagePending_Proxy(IMessageFilter, HTASK, DWORD, DWORD); 1244 void IMessageFilter_MessagePending_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1245 HRESULT IRpcChannelBuffer_GetBuffer_Proxy(IRpcChannelBuffer, RPCOLEMESSAGE*, REFIID); 1246 void IRpcChannelBuffer_GetBuffer_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1247 HRESULT IRpcChannelBuffer_SendReceive_Proxy(IRpcChannelBuffer, RPCOLEMESSAGE*, ULONG*); 1248 void IRpcChannelBuffer_SendReceive_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1249 HRESULT IRpcChannelBuffer_FreeBuffer_Proxy(IRpcChannelBuffer, RPCOLEMESSAGE*); 1250 void IRpcChannelBuffer_FreeBuffer_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1251 HRESULT IRpcChannelBuffer_GetDestCtx_Proxy(IRpcChannelBuffer, DWORD*, void**); 1252 void IRpcChannelBuffer_GetDestCtx_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1253 HRESULT IRpcChannelBuffer_IsConnected_Proxy(IRpcChannelBuffer); 1254 void IRpcChannelBuffer_IsConnected_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1255 HRESULT IRpcProxyBuffer_Connect_Proxy(IRpcProxyBuffer, IRpcChannelBufferpRpcChannelBuffer); 1256 void IRpcProxyBuffer_Connect_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1257 void IRpcProxyBuffer_Disconnect_Proxy(IRpcProxyBuffer); 1258 void IRpcProxyBuffer_Disconnect_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1259 HRESULT IRpcStubBuffer_Connect_Proxy(IRpcStubBuffer, IUnknown); 1260 void IRpcStubBuffer_Connect_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1261 void IRpcStubBuffer_Disconnect_Proxy(IRpcStubBuffer); 1262 void IRpcStubBuffer_Disconnect_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1263 HRESULT IRpcStubBuffer_Invoke_Proxy(IRpcStubBuffer, RPCOLEMESSAGE*, IRpcChannelBuffer); 1264 void IRpcStubBuffer_Invoke_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1265 IRpcStubBufferIRpcStubBuffer_IsIIDSupported_Proxy(IRpcStubBuffer, REFIID); 1266 void IRpcStubBuffer_IsIIDSupported_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1267 ULONG IRpcStubBuffer_CountRefs_Proxy(IRpcStubBuffer); 1268 void IRpcStubBuffer_CountRefs_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1269 HRESULT IRpcStubBuffer_DebugServerQueryInterface_Proxy(IRpcStubBuffer, void**); 1270 void IRpcStubBuffer_DebugServerQueryInterface_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1271 void IRpcStubBuffer_DebugServerRelease_Proxy(IRpcStubBuffer, void*); 1272 void IRpcStubBuffer_DebugServerRelease_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1273 HRESULT IPSFactoryBuffer_CreateProxy_Proxy(IPSFactoryBuffer, IUnknown, REFIID, IRpcProxyBuffer*, void**); 1274 void IPSFactoryBuffer_CreateProxy_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1275 HRESULT IPSFactoryBuffer_CreateStub_Proxy(IPSFactoryBuffer, REFIID, IUnknown, IRpcStubBuffer*); 1276 void IPSFactoryBuffer_CreateStub_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD); 1277 void SNB_to_xmit(SNB*, RemSNB**); 1278 void SNB_from_xmit(RemSNB*, SNB*); 1279 void SNB_free_inst(SNB*); 1280 void SNB_free_xmit(RemSNB*); 1281 HRESULT IEnumUnknown_Next_Proxy(IEnumUnknown, ULONG, IUnknown*, ULONG*); 1282 HRESULT IEnumUnknown_Next_Stub(IEnumUnknown, ULONG, IUnknown*, ULONG*); 1283 HRESULT IEnumMoniker_Next_Proxy(IEnumMoniker, ULONG, IMoniker*, ULONG*); 1284 HRESULT IEnumMoniker_Next_Stub(IEnumMoniker, ULONG, IMoniker*, ULONG*); 1285 HRESULT IMoniker_BindToObject_Proxy(IMoniker, IBindCtx, IMoniker, REFIID, void**); 1286 HRESULT IMoniker_BindToObject_Stub(IMoniker, IBindCtx, IMoniker, REFIID, IUnknown*); 1287 HRESULT IMoniker_BindToStorage_Proxy(IMoniker, IBindCtx, IMoniker, REFIID, void**); 1288 HRESULT IMoniker_BindToStorage_Stub(IMoniker, IBindCtx, IMoniker, REFIID, IUnknown*); 1289 HRESULT IEnumString_Next_Proxy(IEnumString, ULONG, LPCSTR*, ULONG*); 1290 HRESULT IEnumString_Next_Stub(IEnumString, ULONG, LPCSTR*, ULONG*); 1291 HRESULT IStream_Read_Proxy(IStream, void*, ULONG, ULONG*); 1292 HRESULT IStream_Read_Stub(IStream, BYTE*, ULONG, ULONG*); 1293 HRESULT IStream_Write_Proxy(IStream, void*, ULONG, ULONG*); 1294 HRESULT IStream_Write_Stub(IStream, BYTE*, ULONG, ULONG*); 1295 HRESULT IStream_Seek_Proxy(IStream, LARGE_INTEGER, DWORD, ULARGE_INTEGER*); 1296 HRESULT IStream_Seek_Stub(IStream, LARGE_INTEGER, DWORD, ULARGE_INTEGER*); 1297 HRESULT IStream_CopyTo_Proxy(IStream, IStream, ULARGE_INTEGER, ULARGE_INTEGER*, ULARGE_INTEGER*); 1298 HRESULT IStream_CopyTo_Stub(IStream, IStream, ULARGE_INTEGER, ULARGE_INTEGER*, ULARGE_INTEGER*); 1299 HRESULT IEnumSTATSTG_Next_Proxy(IEnumSTATSTG, ULONG, STATSTG*, ULONG*); 1300 HRESULT IEnumSTATSTG_Next_Stub(IEnumSTATSTG, ULONG, STATSTG*, ULONG*); 1301 HRESULT IStorage_OpenStream_Proxy(IStorage, OLECHAR*, void*, DWORD, DWORD, IStream*); 1302 HRESULT IStorage_OpenStream_Stub(IStorage, OLECHAR*, uint, BYTE*, DWORD, DWORD, IStream* ); 1303 HRESULT IStorage_EnumElements_Proxy(IStorage, DWORD, void*, DWORD, IEnumSTATSTG*); 1304 HRESULT IStorage_EnumElements_Stub(IStorage, DWORD, uint, BYTE*, DWORD, IEnumSTATSTG*); 1305 HRESULT ILockBytes_ReadAt_Proxy(ILockBytes, ULARGE_INTEGER, void*, ULONG, ULONG*); 1306 HRESULT ILockBytes_ReadAt_Stub(ILockBytes, ULARGE_INTEGER, BYTE*, ULONG, ULONG*); 1307 HRESULT ILockBytes_WriteAt_Proxy(ILockBytes, ULARGE_INTEGER, const(void)*, ULONG, ULONG*); 1308 HRESULT ILockBytes_WriteAt_Stub(ILockBytes, ULARGE_INTEGER, BYTE*, ULONG, ULONG*); 1309 } 1310 +/