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 
16 import core.sys.windows.unknwn;
17 import core.sys.windows.objfwd;
18 import core.sys.windows.windef;
19 import core.sys.windows.basetyps;
20 import core.sys.windows.oleidl;
21 import core.sys.windows.wtypes;
22 import core.sys.windows.winbase; // for FILETIME
23 import core.sys.windows.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[1] tdData;
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[1] data;
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 const(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[5] reserved2;
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[1] rgString = 0;
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 = 0;
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 enum 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 enum 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, DWORD, 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(SIZE_T);
606     void* Realloc(void*, SIZE_T);
607     void Free(void*);
608     SIZE_T GetSize(void*);
609     int DidAlloc(void*);
610     void HeapMinimize();
611 }
612 
613 interface IMallocSpy : IUnknown {
614     SIZE_T PreAlloc(SIZE_T);
615     void* PostAlloc(void*);
616     void* PreFree(void*, BOOL);
617     void PostFree(BOOL);
618     SIZE_T PreRealloc(void*, SIZE_T, void**, BOOL);
619     void* PostRealloc(void*, BOOL);
620     void* PreGetSize(void*, BOOL);
621     SIZE_T PostGetSize(SIZE_T, 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, IUnknownpunk);
961 void IBindCtx_RegisterObjectBound_Stub(IRpcStubBuffer, IRpcChannelBuffer_pRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
962 HRESULT IBindCtx_RevokeObjectBound_Proxy(IBindCtx, IUnknownpunk);
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, const(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, const(IID)*, SNB, IStorage);
1101 void IStorage_CopyTo_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1102 HRESULT IStorage_MoveElementTo_Proxy(IStorage, const(OLECHAR)*, IStorage, const(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, const(OLECHAR)*, const(OLECHAR)*);
1113 void IStorage_RenameElement_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1114 HRESULT IStorage_SetElementTimes_Proxy(IStorage, const(OLECHAR)*, const(FILETIME)*, const(FILETIME)*, const(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, IRpcChannelBufferpRpcChannelBuffer);
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 IRpcStubBufferIRpcStubBuffer_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, const(void)*, ULONG, ULONG*);
1305 HRESULT ILockBytes_WriteAt_Stub(ILockBytes, ULARGE_INTEGER, BYTE*, ULONG, ULONG*);
1306 }
1307 +/