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