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