]> git.ipfire.org Git - thirdparty/gcc.git/blame - libphobos/libdruntime/core/sys/windows/objidl.d
projects / thirdparty / gcc.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge remote-tracking branch 'origin/master' into devel/c++-contracts
[thirdparty/gcc.git] / libphobos / libdruntime / core / sys / windows / objidl.d
CommitLineData
b4c522fa
IB		 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)
0fb57034 7 * Source: $(DRUNTIMESRC core/sys/windows/_objidl.d)
b4c522fa
IB		 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?
13module core.sys.windows.objidl;
14version (Windows):
15
16import core.sys.windows.unknwn;
17import core.sys.windows.objfwd;
92dd3e71
IB		 18import core.sys.windows.windef;
19import core.sys.windows.basetyps;
20import core.sys.windows.oleidl;
21import core.sys.windows.wtypes;
22import core.sys.windows.winbase; // for FILETIME
23import core.sys.windows.rpcdce;
b4c522fa
IB		 24
25struct 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
39enum STGTY {
40 STGTY_STORAGE = 1,
41 STGTY_STREAM,
42 STGTY_LOCKBYTES,
43 STGTY_PROPERTY
44}
45
46enum STREAM_SEEK {
47 STREAM_SEEK_SET,
48 STREAM_SEEK_CUR,
49 STREAM_SEEK_END
50}
51
52struct INTERFACEINFO {
53 LPUNKNOWN pUnk;
54 IID iid;
55 WORD wMethod;
56}
57alias INTERFACEINFO* LPINTERFACEINFO;
58
59enum CALLTYPE {
60 CALLTYPE_TOPLEVEL = 1,
61 CALLTYPE_NESTED,
62 CALLTYPE_ASYNC,
63 CALLTYPE_TOPLEVEL_CALLPENDING,
64 CALLTYPE_ASYNC_CALLPENDING
65}
66
67enum PENDINGTYPE {
68 PENDINGTYPE_TOPLEVEL = 1,
69 PENDINGTYPE_NESTED
70}
71
72enum PENDINGMSG {
73 PENDINGMSG_CANCELCALL = 0,
74 PENDINGMSG_WAITNOPROCESS,
75 PENDINGMSG_WAITDEFPROCESS
76}
77
78alias OLECHAR** SNB;
79
80enum DATADIR {
81 DATADIR_GET = 1,
82 DATADIR_SET
83}
84alias WORD CLIPFORMAT;
85alias CLIPFORMAT* LPCLIPFORMAT;
86
87struct DVTARGETDEVICE {
88 DWORD tdSize;
89 WORD tdDriverNameOffset;
90 WORD tdDeviceNameOffset;
91 WORD tdPortNameOffset;
92 WORD tdExtDevmodeOffset;
93 BYTE[1] tdData;
94}
95
96struct FORMATETC {
97 CLIPFORMAT cfFormat;
98 DVTARGETDEVICE* ptd;
99 DWORD dwAspect;
100 LONG lindex;
101 DWORD tymed;
102}
103alias FORMATETC* LPFORMATETC;
104
105struct RemSTGMEDIUM {
106 DWORD tymed;
107 DWORD dwHandleType;
108 ULONG pData;
109 uint pUnkForRelease;
110 uint cbData;
111 BYTE[1] data;
112}
113
114struct HLITEM {
115 ULONG uHLID;
116 LPWSTR pwzFriendlyName;
117}
118
119struct STATDATA {
120 FORMATETC formatetc;
121 DWORD grfAdvf;
122 IAdviseSink pAdvSink;
123 DWORD dwConnection;
124}
125
126struct STATPROPSETSTG {
127 FMTID fmtid;
128 CLSID clsid;
129 DWORD grfFlags;
130 FILETIME mtime;
131 FILETIME ctime;
132 FILETIME atime;
133}
134
135enum EXTCONN {
136 EXTCONN_STRONG = 1,
137 EXTCONN_WEAK = 2,
138 EXTCONN_CALLABLE = 4
139}
140
141struct MULTI_QI {
142const(IID)* pIID;
143 IUnknown pItf;
144 HRESULT hr;
145}
146
147struct 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
157struct 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
167struct COSERVERINFO {
168 DWORD dwReserved1;
169 LPWSTR pwszName;
170 COAUTHINFO* pAuthInfo;
171 DWORD dwReserved2;
172}
173
174struct BIND_OPTS {
175 DWORD cbStruct;
176 DWORD grfFlags;
177 DWORD grfMode;
178 DWORD dwTickCountDeadline;
179}
180alias BIND_OPTS* LPBIND_OPTS;
181
182struct 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}
192alias BIND_OPTS2* LPBIND_OPTS2;
193
194enum BIND_FLAGS {
195 BIND_MAYBOTHERUSER = 1,
196 BIND_JUSTTESTEXISTENCE
197}
198
199struct 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}
212alias STGMEDIUM* LPSTGMEDIUM;
213
214enum LOCKTYPE {
215 LOCK_WRITE = 1,
216 LOCK_EXCLUSIVE = 2,
217 LOCK_ONLYONCE = 4
218}
219
220alias uint RPCOLEDATAREP;
221
222struct RPCOLEMESSAGE {
223 PVOID reserved1;
224 RPCOLEDATAREP dataRepresentation;
225 PVOID Buffer;
226 ULONG cbBuffer;
227 ULONG iMethod;
228 PVOID[5] reserved2;
229 ULONG rpcFlags;
230}
231alias RPCOLEMESSAGE* PRPCOLEMESSAGE;
232
233enum MKSYS {
234 MKSYS_NONE,
235 MKSYS_GENERICCOMPOSITE,
236 MKSYS_FILEMONIKER,
237 MKSYS_ANTIMONIKER,
238 MKSYS_ITEMMONIKER,
239 MKSYS_POINTERMONIKER
240}
241
242enum MKREDUCE {
243 MKRREDUCE_ALL,
244 MKRREDUCE_ONE = 196608,
245 MKRREDUCE_TOUSER = 131072,
246 MKRREDUCE_THROUGHUSER = 65536
247}
248
249struct RemSNB {
250 uint ulCntStr;
251 uint ulCntChar;
0da83a16 252 OLECHAR[1] rgString = 0;
b4c522fa
IB		 253}
254
255enum 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
265enum 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
276enum SERVERCALL {
277 SERVERCALL_ISHANDLED,
278 SERVERCALL_REJECTED,
279 SERVERCALL_RETRYLATER
280}
281
282struct CAUB {
283 ULONG cElems;
284 ubyte* pElems;
285}
286
287struct CAI {
288 ULONG cElems;
289 short* pElems;
290}
291
292struct CAUI {
293 ULONG cElems;
294 USHORT* pElems;
295}
296
297struct CAL {
298 ULONG cElems;
299 int* pElems;
300}
301
302struct CAUL {
303 ULONG cElems;
304 ULONG* pElems;
305}
306
307struct CAFLT {
308 ULONG cElems;
309 float* pElems;
310}
311
312struct CADBL {
313 ULONG cElems;
314 double* pElems;
315}
316
317struct CACY {
318 ULONG cElems;
319 CY* pElems;
320}
321
322struct CADATE {
323 ULONG cElems;
324 DATE* pElems;
325}
326
327struct CABSTR {
328 ULONG cElems;
329 BSTR* pElems;
330}
331
332struct CABSTRBLOB {
333 ULONG cElems;
334 BSTRBLOB* pElems;
335}
336
337struct CABOOL {
338 ULONG cElems;
339 VARIANT_BOOL* pElems;
340}
341
342struct CASCODE {
343 ULONG cElems;
344 SCODE* pElems;
345}
346
347struct CAH {
348 ULONG cElems;
349 LARGE_INTEGER* pElems;
350}
351
352struct CAUH {
353 ULONG cElems;
354 ULARGE_INTEGER* pElems;
355}
356
357struct CALPSTR {
358 ULONG cElems;
359 LPSTR* pElems;
360}
361
362struct CALPWSTR {
363 ULONG cElems;
364 LPWSTR* pElems;
365}
366
367struct CAFILETIME {
368 ULONG cElems;
369 FILETIME* pElems;
370}
371
372struct CACLIPDATA {
373 ULONG cElems;
374 CLIPDATA* pElems;
375}
376
377struct CACLSID {
378 ULONG cElems;
379 CLSID* pElems;
380}
381alias PROPVARIANT* LPPROPVARIANT;
382
383struct CAPROPVARIANT {
384 ULONG cElems;
385 LPPROPVARIANT pElems;
386}
387
388struct PROPVARIANT {
389 VARTYPE vt;
390 WORD wReserved1;
391 WORD wReserved2;
392 WORD wReserved3;
393 union {
0da83a16 394 CHAR cVal = 0;
b4c522fa
IB		 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
442struct PROPSPEC {
443 ULONG ulKind;
444 union {
445 PROPID propid;
446 LPOLESTR lpwstr;
447 }
448}
449
450struct STATPROPSTG {
451 LPOLESTR lpwstrName;
452 PROPID propid;
453 VARTYPE vt;
454}
455
456enum PROPSETFLAG {
457 PROPSETFLAG_DEFAULT,
458 PROPSETFLAG_NONSIMPLE,
459 PROPSETFLAG_ANSI,
460 PROPSETFLAG_UNBUFFERED = 4
461}
462
463struct STORAGELAYOUT {
464 DWORD LayoutType;
465 OLECHAR* pwcsElementName;
466 LARGE_INTEGER cOffset;
467 LARGE_INTEGER cBytes;
468}
469
470struct SOLE_AUTHENTICATION_SERVICE {
471 DWORD dwAuthnSvc;
472 DWORD dwAuthzSvc;
473 OLECHAR* pPrincipalName;
474 HRESULT hr;
475}
476
477enum OLECHAR* COLE_DEFAULT_PRINCIPAL = cast ( OLECHAR* )(-1);
478
479enum 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
497struct SOLE_AUTHENTICATION_INFO {
498 DWORD dwAuthnSvc;
499 DWORD dwAuthzSvc;
500 void* pAuthInfo;
501}
502
503enum void* COLE_DEFAULT_AUTHINFO = cast( void* )(-1 );
504
505struct SOLE_AUTHENTICATION_LIST {
506 DWORD cAuthInfo;
507 SOLE_AUTHENTICATION_INFO* aAuthInfo;
508}
509
510interface IEnumFORMATETC : IUnknown {
511 HRESULT Next(ULONG, FORMATETC*, ULONG*);
512 HRESULT Skip(ULONG);
513 HRESULT Reset();
514 HRESULT Clone(IEnumFORMATETC*);
515}
516
517interface IEnumHLITEM : IUnknown {
518 HRESULT Next(ULONG, HLITEM*, ULONG*);
519 HRESULT Skip(ULONG);
520 HRESULT Reset();
521 HRESULT Clone(IEnumHLITEM*);
522}
523
524interface IEnumSTATDATA : IUnknown {
525 HRESULT Next(ULONG, STATDATA*, ULONG*);
526 HRESULT Skip(ULONG);
527 HRESULT Reset();
528 HRESULT Clone(IEnumSTATDATA*);
529}
530
531interface IEnumSTATPROPSETSTG : IUnknown {
532 HRESULT Next(ULONG, STATPROPSETSTG*, ULONG*);
533 HRESULT Skip(ULONG);
534 HRESULT Reset();
535 HRESULT Clone(IEnumSTATPROPSETSTG*);
536}
537
538interface IEnumSTATPROPSTG : IUnknown {
539 HRESULT Next(ULONG, STATPROPSTG*, ULONG*);
540 HRESULT Skip(ULONG);
541 HRESULT Reset();
542 HRESULT Clone(IEnumSTATPROPSTG*);
543}
544
545interface IEnumSTATSTG : IUnknown {
546 HRESULT Next(ULONG, STATSTG*, ULONG*);
547 HRESULT Skip(ULONG);
548 HRESULT Reset();
549 HRESULT Clone(IEnumSTATSTG*);
550}
551
552interface IEnumString : IUnknown {
553 HRESULT Next(ULONG, LPOLESTR*, ULONG*);
554 HRESULT Skip(ULONG);
555 HRESULT Reset();
556 HRESULT Clone(IEnumString*);
557}
558
559interface IEnumMoniker : IUnknown {
560 HRESULT Next(ULONG, IMoniker*, ULONG*);
561 HRESULT Skip(ULONG);
562 HRESULT Reset();
563 HRESULT Clone(IEnumMoniker*);
564}
565
566
567interface IEnumUnknown : IUnknown {
568 HRESULT Next(ULONG, IUnknown*, ULONG*);
569 HRESULT Skip(ULONG);
570 HRESULT Reset();
571 HRESULT Clone(IEnumUnknown*);
572}
573
574interface ISequentialStream : IUnknown {
575 HRESULT Read(void*, ULONG, ULONG*);
576 HRESULT Write(void* , ULONG, ULONG*);
577}
578
579interface 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
591interface 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
600interface IStdMarshalInfo : IUnknown {
601 HRESULT GetClassForHandler(DWORD, PVOID, CLSID*);
602}
603
604interface 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
613interface 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
628interface IMessageFilter : IUnknown {
629 DWORD HandleInComingCall(DWORD, HTASK, DWORD, LPINTERFACEINFO);
630 DWORD RetryRejectedCall(HTASK, DWORD, DWORD);
631 DWORD MessagePending(HTASK, DWORD, DWORD);
632}
633
634
635interface IPersist : IUnknown {
636 HRESULT GetClassID(CLSID*);
637}
638
639interface IPersistStream : IPersist {
640 HRESULT IsDirty();
641 HRESULT Load(IStream);
642 HRESULT Save(IStream, BOOL);
643 HRESULT GetSizeMax(PULARGE_INTEGER);
644}
645
646interface 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
656interface 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
669interface 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
687interface 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
697interface 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
706interface 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
717interface IAdviseSink2 : IAdviseSink
718{
719 void OnLinkSrcChange(IMoniker);
720}
721
722interface 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
734interface 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
741interface 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?
760interface IRootStorage : IPersist {
761 HRESULT QueryInterface(REFIID, PVOID*);
762 ULONG AddRef();
763 ULONG Release();
764 HRESULT SwitchToFile(LPOLESTR);
765}
766
767interface 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
775interface IRpcProxyBuffer : IUnknown {
776 HRESULT Connect(IRpcChannelBuffer);
777 void Disconnect();
778}
779
780interface 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
790interface IPSFactoryBuffer : IUnknown {
791 HRESULT CreateProxy(LPUNKNOWN, REFIID, LPRPCPROXYBUFFER*, PVOID*);
792 HRESULT CreateStub(REFIID, LPUNKNOWN, LPRPCSTUBBUFFER*);
793}
794alias IPSFactoryBuffer LPPSFACTORYBUFFER;
795
796interface 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
806interface IExternalConnection : IUnknown {
807 HRESULT AddConnection(DWORD, DWORD);
808 HRESULT ReleaseConnection(DWORD, DWORD, BOOL);
809}
810
811interface IRunnableObject : IUnknown {
812 HRESULT GetRunningClass(LPCLSID);
813 HRESULT Run(LPBC);
814 BOOL IsRunning();
815 HRESULT LockRunning(BOOL, BOOL);
816 HRESULT SetContainedObject(BOOL);
817}
818
819interface IROTData : IUnknown {
820 HRESULT GetComparisonData(PVOID, ULONG, PULONG);
821}
822
823interface 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
832interface 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
847interface 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
854interface 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
860interface 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
867interface IClassActivator : IUnknown {
868 HRESULT GetClassObject(REFCLSID, DWORD, LCID, REFIID, PVOID*);
869}
870
871interface 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
878interface IProgressNotify : IUnknown {
879 HRESULT OnProgress(DWORD, DWORD, BOOL, BOOL);
880}
881
882interface ILayoutStorage : IUnknown {
883 HRESULT LayoutScript(STORAGELAYOUT*, DWORD, DWORD);
884 HRESULT BeginMonitor();
885 HRESULT EndMonitor();
886 HRESULT ReLayoutDocfile(OLECHAR*);
887}
888
889interface 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.
897extern (Windows) {
898HRESULT IMarshal_GetUnmarshalClass_Proxy(IMarshal, REFIID, void*, DWORD, void*, DWORD, CLSID*);
899void IMarshal_GetUnmarshalClass_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
900HRESULT IMarshal_GetMarshalSizeMax_Proxy(IMarshal, REFIID, void*, DWORD, void*, DWORD, DWORD*);
901void IMarshal_GetMarshalSizeMax_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
902HRESULT IMarshal_MarshalInterface_Proxy(IMarshal, IStream, REFIID, void*, DWORD, void*, DWORD);
903void IMarshal_MarshalInterface_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
904HRESULT IMarshal_UnmarshalInterface_Proxy(IMarshal, IStream, REFIID, void**);
905void IMarshal_UnmarshalInterface_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
906HRESULT IMarshal_ReleaseMarshalData_Proxy(IMarshal, IStream);
907void IMarshal_ReleaseMarshalData_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
908HRESULT IMarshal_DisconnectObject_Proxy(IMarshal, DWORD);
909void IMarshal_DisconnectObject_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
910void* IMalloc_Alloc_Proxy(IMalloc, ULONG);
911void IMalloc_Alloc_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
912void* IMalloc_Realloc_Proxy(IMalloc, void*, ULONG);
913void IMalloc_Realloc_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
914void IMalloc_Free_Proxy(IMalloc, void*);
915void IMalloc_Free_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
916ULONG IMalloc_GetSize_Proxy(IMalloc, void*);
917void IMalloc_GetSize_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
918int IMalloc_DidAlloc_Proxy(IMalloc, void*);
919void IMalloc_DidAlloc_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
920void IMalloc_HeapMinimize_Proxy(IMalloc);
921void IMalloc_HeapMinimize_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
922ULONG IMallocSpy_PreAlloc_Proxy(IMallocSpy, ULONG cbRequest);
923void IMallocSpy_PreAlloc_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
924void* IMallocSpy_PostAlloc_Proxy(IMallocSpy, void*);
925void IMallocSpy_PostAlloc_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
926void* IMallocSpy_PreFree_Proxy(IMallocSpy, void*, BOOL);
927void IMallocSpy_PreFree_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
928void IMallocSpy_PostFree_Proxy(IMallocSpy, BOOL);
929void IMallocSpy_PostFree_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
930ULONG IMallocSpy_PreRealloc_Proxy(IMallocSpy, void*, ULONG, void**, BOOL);
931void IMallocSpy_PreRealloc_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
932void* IMallocSpy_PostRealloc_Proxy(IMallocSpy, void*, BOOL);
933void IMallocSpy_PostRealloc_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
934void* IMallocSpy_PreGetSize_Proxy(IMallocSpy, void*, BOOL);
935void IMallocSpy_PreGetSize_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
936ULONG IMallocSpy_PostGetSize_Proxy(IMallocSpy, ULONG, BOOL);
937void IMallocSpy_PostGetSize_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
938void* IMallocSpy_PreDidAlloc_Proxy(IMallocSpy, void*, BOOL);
939void IMallocSpy_PreDidAlloc_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
940int IMallocSpy_PostDidAlloc_Proxy(IMallocSpy, void*, BOOL, int);
941void IMallocSpy_PostDidAlloc_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
942void IMallocSpy_PreHeapMinimize_Proxy(IMallocSpy );
943void IMallocSpy_PreHeapMinimize_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
944void IMallocSpy_PostHeapMinimize_Proxy(IMallocSpy);
945void IMallocSpy_PostHeapMinimize_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
946HRESULT IStdMarshalInfo_GetClassForHandler_Proxy(IStdMarshalInfo, DWORD, void*, CLSID*);
947void IStdMarshalInfo_GetClassForHandler_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
948DWORD IExternalConnection_AddConnection_Proxy(IExternalConnection, DWORD, DWORD);
949void IExternalConnection_AddConnection_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
950DWORD IExternalConnection_ReleaseConnection_Proxy(IExternalConnection, DWORD, DWORD, BOOL);
951void IExternalConnection_ReleaseConnection_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
952HRESULT IEnumUnknown_RemoteNext_Proxy(IEnumUnknown, ULONG, IUnknown*, ULONG*);
953void IEnumUnknown_RemoteNext_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
954HRESULT IEnumUnknown_Skip_Proxy(IEnumUnknown, ULONG);
955void IEnumUnknown_Skip_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
956HRESULT IEnumUnknown_Reset_Proxy(IEnumUnknown );
957void IEnumUnknown_Reset_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
958HRESULT IEnumUnknown_Clone_Proxy(IEnumUnknown, IEnumUnknown*);
959void IEnumUnknown_Clone_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
960HRESULT IBindCtx_RegisterObjectBound_Proxy(IBindCtx, IUnknownpunk);
961void IBindCtx_RegisterObjectBound_Stub(IRpcStubBuffer, IRpcChannelBuffer_pRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
962HRESULT IBindCtx_RevokeObjectBound_Proxy(IBindCtx, IUnknownpunk);
963void IBindCtx_RevokeObjectBound_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
964HRESULT IBindCtx_ReleaseBoundObjects_Proxy(IBindCtx);
965void IBindCtx_ReleaseBoundObjects_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
966HRESULT IBindCtx_SetBindOptions_Proxy(IBindCtx, BIND_OPTS*);
967void IBindCtx_SetBindOptions_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
968HRESULT IBindCtx_GetBindOptions_Proxy(IBindCtx, BIND_OPTS*pbindopts);
969void IBindCtx_GetBindOptions_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
970HRESULT IBindCtx_GetRunningObjectTable_Proxy(IBindCtx, IRunningObjectTable*);
971void IBindCtx_GetRunningObjectTable_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
972HRESULT IBindCtx_RegisterObjectParam_Proxy(IBindCtx, LPCSTR, IUnknown);
973void IBindCtx_RegisterObjectParam_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
974HRESULT IBindCtx_GetObjectParam_Proxy(IBindCtx, LPCSTR, IUnknown*);
975void IBindCtx_GetObjectParam_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
976HRESULT IBindCtx_EnumObjectParam_Proxy(IBindCtx, IEnumString*);
977void IBindCtx_EnumObjectParam_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
978HRESULT IBindCtx_RevokeObjectParam_Proxy(IBindCtx, LPCSTR);
979void IBindCtx_RevokeObjectParam_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
980HRESULT IEnumMoniker_RemoteNext_Proxy(IEnumMoniker, ULONG, IMoniker*, ULONG*);
981void IEnumMoniker_RemoteNext_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
982HRESULT IEnumMoniker_Skip_Proxy(IEnumMoniker, ULONG);
983void IEnumMoniker_Skip_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
984HRESULT IEnumMoniker_Reset_Proxy(IEnumMoniker);
985void IEnumMoniker_Reset_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
986HRESULT IEnumMoniker_Clone_Proxy(IEnumMoniker, IEnumMoniker*);
987void IEnumMoniker_Clone_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
988HRESULT IRunnableObject_GetRunningClass_Proxy(IRunnableObject, LPCLSID);
989void IRunnableObject_GetRunningClass_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
990HRESULT IRunnableObject_Run_Proxy(IRunnableObject, LPBINDCTX);
991void IRunnableObject_Run_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
992BOOL IRunnableObject_IsRunning_Proxy(IRunnableObject);
993void IRunnableObject_IsRunning_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
994HRESULT IRunnableObject_LockRunning_Proxy(IRunnableObject, BOOL, BOOL);
995void IRunnableObject_LockRunning_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
996HRESULT IRunnableObject_SetContainedObject_Proxy(IRunnableObject, BOOL);
997void IRunnableObject_SetContainedObject_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
998HRESULT IRunningObjectTable_Register_Proxy(IRunningObjectTable, DWORD, IUnknown, IMoniker, DWORD*);
999void IRunningObjectTable_Register_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1000HRESULT IRunningObjectTable_Revoke_Proxy(IRunningObjectTable, DWORD);
1001void IRunningObjectTable_Revoke_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1002HRESULT IRunningObjectTable_IsRunning_Proxy(IRunningObjectTable, IMoniker);
1003void IRunningObjectTable_IsRunning_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1004HRESULT IRunningObjectTable_GetObject_Proxy(IRunningObjectTable, IMoniker, IUnknown*);
1005void IRunningObjectTable_GetObject_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1006HRESULT IRunningObjectTable_NoteChangeTime_Proxy(IRunningObjectTable, DWORD, FILETIME*);
1007void IRunningObjectTable_NoteChangeTime_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1008HRESULT IRunningObjectTable_GetTimeOfLastChange_Proxy(IRunningObjectTable, IMoniker, FILETIME*);
1009void IRunningObjectTable_GetTimeOfLastChange_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1010HRESULT IRunningObjectTable_EnumRunning_Proxy(IRunningObjectTable, IEnumMoniker*);
1011void IRunningObjectTable_EnumRunning_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1012HRESULT IPersist_GetClassID_Proxy(IPersist, CLSID*);
1013void IPersist_GetClassID_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1014HRESULT IPersistStream_IsDirty_Proxy(IPersistStream);
1015void IPersistStream_IsDirty_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1016HRESULT IPersistStream_Load_Proxy(IPersistStream, IStream);
1017void IPersistStream_Load_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1018HRESULT IPersistStream_Save_Proxy(IPersistStream, IStream, BOOL);
1019void IPersistStream_Save_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1020HRESULT IPersistStream_GetSizeMax_Proxy(IPersistStream, ULARGE_INTEGER*);
1021void IPersistStream_GetSizeMax_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1022HRESULT IMoniker_RemoteBindToObject_Proxy(IMoniker, IBindCtx, IMoniker, REFIID, IUnknown*);
1023void IMoniker_RemoteBindToObject_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1024HRESULT IMoniker_RemoteBindToStorage_Proxy(IMoniker, IBindCtx, IMoniker, REFIID, IUnknown*);
1025void IMoniker_RemoteBindToStorage_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1026HRESULT IMoniker_Reduce_Proxy(IMoniker, IBindCtx, DWORD, IMoniker*, IMoniker*);
1027void IMoniker_Reduce_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1028HRESULT IMoniker_ComposeWith_Proxy(IMoniker, IMoniker, BOOL, IMoniker*);
1029void IMoniker_ComposeWith_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1030HRESULT IMoniker_Enum_Proxy(IMoniker, BOOL, IEnumMoniker*);
1031void IMoniker_Enum_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1032HRESULT IMoniker_IsEqual_Proxy(IMoniker, IMoniker);
1033void IMoniker_IsEqual_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1034HRESULT IMoniker_Hash_Proxy(IMoniker, DWORD*);
1035void IMoniker_Hash_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1036HRESULT IMoniker_IsRunning_Proxy(IMoniker, IBindCtx, IMoniker, IMoniker);
1037void IMoniker_IsRunning_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1038HRESULT IMoniker_GetTimeOfLastChange_Proxy(IMoniker, IBindCtx, IMoniker, FILETIME*);
1039void IMoniker_GetTimeOfLastChange_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1040HRESULT IMoniker_Inverse_Proxy(IMoniker, IMoniker*);
1041void IMoniker_Inverse_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1042HRESULT IMoniker_CommonPrefixWith_Proxy(IMoniker, IMoniker, IMoniker*);
1043void IMoniker_CommonPrefixWith_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1044HRESULT IMoniker_RelativePathTo_Proxy(IMoniker, IMoniker, IMoniker*);
1045void IMoniker_RelativePathTo_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1046HRESULT IMoniker_GetDisplayName_Proxy(IMoniker, IBindCtx, IMoniker, LPCSTR*);
1047void IMoniker_GetDisplayName_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1048HRESULT IMoniker_ParseDisplayName_Proxy(IMoniker, IBindCtx, IMoniker, LPCSTR, ULONG*, IMoniker*);
1049void IMoniker_ParseDisplayName_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1050HRESULT IMoniker_IsSystemMoniker_Proxy(IMoniker, DWORD*);
1051void IMoniker_IsSystemMoniker_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1052HRESULT IROTData_GetComparisonData_Proxy(IROTData, BYTE*, ULONG cbMax, ULONG*);
1053void IROTData_GetComparisonData_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1054HRESULT IEnumString_RemoteNext_Proxy(IEnumString, ULONG, LPCSTR*rgelt, ULONG*);
1055void IEnumString_RemoteNext_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1056HRESULT IEnumString_Skip_Proxy(IEnumString, ULONG);
1057void IEnumString_Skip_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1058HRESULT IEnumString_Reset_Proxy(IEnumString);
1059void IEnumString_Reset_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1060HRESULT IEnumString_Clone_Proxy(IEnumString, IEnumString*);
1061void IEnumString_Clone_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1062HRESULT IStream_RemoteRead_Proxy(IStream, BYTE*, ULONG, ULONG*);
1063void IStream_RemoteRead_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1064HRESULT IStream_RemoteWrite_Proxy(IStream, BYTE*pv, ULONG, ULONG*);
1065void IStream_RemoteWrite_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1066HRESULT IStream_RemoteSeek_Proxy(IStream, LARGE_INTEGER, DWORD, ULARGE_INTEGER*);
1067void IStream_RemoteSeek_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1068HRESULT IStream_SetSize_Proxy(IStream, ULARGE_INTEGER);
1069void IStream_SetSize_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1070HRESULT IStream_RemoteCopyTo_Proxy(IStream, IStream, ULARGE_INTEGER, ULARGE_INTEGER*, ULARGE_INTEGER*);
1071void IStream_RemoteCopyTo_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1072HRESULT IStream_Commit_Proxy(IStream, DWORD);
1073void IStream_Commit_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1074HRESULT IStream_Revert_Proxy(IStream);
1075void IStream_Revert_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1076HRESULT IStream_LockRegion_Proxy(IStream, ULARGE_INTEGER, ULARGE_INTEGER, DWORD);
1077void IStream_LockRegion_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1078HRESULT IStream_UnlockRegion_Proxy(IStream, ULARGE_INTEGER, ULARGE_INTEGER, DWORD);
1079void IStream_UnlockRegion_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1080HRESULT IStream_Stat_Proxy(IStream, STATSTG*, DWORD);
1081void IStream_Stat_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1082HRESULT IStream_Clone_Proxy(IStream, IStream*);
1083void IStream_Clone_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1084HRESULT IEnumSTATSTG_RemoteNext_Proxy(IEnumSTATSTG, ULONG, STATSTG*, ULONG*);
1085void IEnumSTATSTG_RemoteNext_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1086HRESULT IEnumSTATSTG_Skip_Proxy(IEnumSTATSTG, ULONG celt);
1087void IEnumSTATSTG_Skip_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1088HRESULT IEnumSTATSTG_Reset_Proxy(IEnumSTATSTG);
1089void IEnumSTATSTG_Reset_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1090HRESULT IEnumSTATSTG_Clone_Proxy(IEnumSTATSTG, IEnumSTATSTG*);
1091void IEnumSTATSTG_Clone_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1092HRESULT IStorage_CreateStream_Proxy(IStorage, OLECHAR*, DWORD, DWORD, DWORD, IStream*);
1093void IStorage_CreateStream_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1094HRESULT IStorage_RemoteOpenStream_Proxy(IStorage, const(OLECHAR)*, uint, BYTE*, DWORD, DWORD, IStream*);
1095void IStorage_RemoteOpenStream_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1096HRESULT IStorage_CreateStorage_Proxy(IStorage, OLECHAR*, DWORD, DWORD, DWORD, IStorage*);
1097void IStorage_CreateStorage_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1098HRESULT IStorage_OpenStorage_Proxy(IStorage, OLECHAR*, IStorage, DWORD, SNB, DWORD, IStorage*);
1099void IStorage_OpenStorage_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1100HRESULT IStorage_CopyTo_Proxy(IStorage, DWORD, const(IID)*, SNB, IStorage);
1101void IStorage_CopyTo_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1102HRESULT IStorage_MoveElementTo_Proxy(IStorage, const(OLECHAR)*, IStorage, const(OLECHAR)*, DWORD);
1103void IStorage_MoveElementTo_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1104HRESULT IStorage_Commit_Proxy(IStorage, DWORD);
1105void IStorage_Commit_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1106HRESULT IStorage_Revert_Proxy(IStorage);
1107void IStorage_Revert_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1108HRESULT IStorage_RemoteEnumElements_Proxy(IStorage, DWORD, uint, BYTE*, DWORD, IEnumSTATSTG*);
1109void IStorage_RemoteEnumElements_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1110HRESULT IStorage_DestroyElement_Proxy(IStorage, OLECHAR*);
1111void IStorage_DestroyElement_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1112HRESULT IStorage_RenameElement_Proxy(IStorage, const(OLECHAR)*, const(OLECHAR)*);
1113void IStorage_RenameElement_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1114HRESULT IStorage_SetElementTimes_Proxy(IStorage, const(OLECHAR)*, const(FILETIME)*, const(FILETIME)*, const(FILETIME)*);
1115void IStorage_SetElementTimes_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1116HRESULT IStorage_SetClass_Proxy(IStorage, REFCLSID);
1117void IStorage_SetClass_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1118HRESULT IStorage_SetStateBits_Proxy(IStorage, DWORD, DWORD);
1119void IStorage_SetStateBits_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1120HRESULT IStorage_Stat_Proxy(IStorage, STATSTG*, DWORD);
1121void IStorage_Stat_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1122HRESULT IPersistFile_IsDirty_Proxy(IPersistFile);
1123void IPersistFile_IsDirty_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1124HRESULT IPersistFile_Load_Proxy(IPersistFile, LPCOLESTR, DWORD);
1125void IPersistFile_Load_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1126HRESULT IPersistFile_Save_Proxy(IPersistFile, LPCOLESTR pszFileName, BOOL);
1127void IPersistFile_Save_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1128HRESULT IPersistFile_SaveCompleted_Proxy(IPersistFile, LPCOLESTR);
1129void IPersistFile_SaveCompleted_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1130HRESULT IPersistFile_GetCurFile_Proxy(IPersistFile, LPCSTR*);
1131void IPersistFile_GetCurFile_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1132HRESULT IPersistStorage_IsDirty_Proxy(IPersistStorage);
1133void IPersistStorage_IsDirty_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1134HRESULT IPersistStorage_InitNew_Proxy(IPersistStorage, IStorage);
1135void IPersistStorage_InitNew_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1136HRESULT IPersistStorage_Load_Proxy(IPersistStorage, IStorage);
1137void IPersistStorage_Load_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1138HRESULT IPersistStorage_Save_Proxy(IPersistStorage, IStorage, BOOL);
1139void IPersistStorage_Save_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1140HRESULT IPersistStorage_SaveCompleted_Proxy(IPersistStorage, IStorage);
1141void IPersistStorage_SaveCompleted_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1142HRESULT IPersistStorage_HandsOffStorage_Proxy(IPersistStorage);
1143void IPersistStorage_HandsOffStorage_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1144HRESULT ILockBytes_RemoteReadAt_Proxy(ILockBytes, ULARGE_INTEGER, BYTE*, ULONG, ULONG*);
1145void ILockBytes_RemoteReadAt_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1146HRESULT ILockBytes_RemoteWriteAt_Proxy(ILockBytes, ULARGE_INTEGER, BYTE*pv, ULONG, ULONG*);
1147void ILockBytes_RemoteWriteAt_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1148HRESULT ILockBytes_Flush_Proxy(ILockBytes);
1149void ILockBytes_Flush_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1150HRESULT ILockBytes_SetSize_Proxy(ILockBytes, ULARGE_INTEGER);
1151void ILockBytes_SetSize_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1152HRESULT ILockBytes_LockRegion_Proxy(ILockBytes, ULARGE_INTEGER, ULARGE_INTEGER, DWORD);
1153void ILockBytes_LockRegion_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1154HRESULT ILockBytes_UnlockRegion_Proxy(ILockBytes, ULARGE_INTEGER, ULARGE_INTEGER, DWORD);
1155void ILockBytes_UnlockRegion_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1156HRESULT ILockBytes_Stat_Proxy(ILockBytes, STATSTG*, DWORD);
1157void ILockBytes_Stat_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1158HRESULT IEnumFORMATETC_RemoteNext_Proxy(IEnumFORMATETC, ULONG, FORMATETC*, ULONG*);
1159void IEnumFORMATETC_RemoteNext_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1160HRESULT IEnumFORMATETC_Skip_Proxy(IEnumFORMATETC, ULONG);
1161void IEnumFORMATETC_Skip_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1162HRESULT IEnumFORMATETC_Reset_Proxy(IEnumFORMATETC);
1163void IEnumFORMATETC_Reset_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1164HRESULT IEnumFORMATETC_Clone_Proxy(IEnumFORMATETC, IEnumFORMATETC*);
1165void IEnumFORMATETC_Clone_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1166HRESULT IEnumFORMATETC_Next_Proxy(IEnumFORMATETC, ULONG, FORMATETC*, ULONG*);
1167HRESULT IEnumFORMATETC_Next_Stub(IEnumFORMATETC, ULONG, FORMATETC*, ULONG*);
1168HRESULT IEnumSTATDATA_RemoteNext_Proxy(IEnumSTATDATA, ULONG, STATDATA*, ULONG*);
1169void IEnumSTATDATA_RemoteNext_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1170HRESULT IEnumSTATDATA_Skip_Proxy(IEnumSTATDATA, ULONG);
1171void IEnumSTATDATA_Skip_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1172HRESULT IEnumSTATDATA_Reset_Proxy(IEnumSTATDATA);
1173void IEnumSTATDATA_Reset_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1174HRESULT IEnumSTATDATA_Clone_Proxy(IEnumSTATDATA, IEnumSTATDATA*);
1175void IEnumSTATDATA_Clone_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1176HRESULT IEnumSTATDATA_Next_Proxy(IEnumSTATDATA, ULONG, STATDATA*, ULONG*);
1177HRESULT IEnumSTATDATA_Next_Stub(IEnumSTATDATA, ULONG, STATDATA*, ULONG*);
1178HRESULT IRootStorage_SwitchToFile_Proxy(IRootStorage, LPCSTR);
1179void IRootStorage_SwitchToFile_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1180void IAdviseSink_RemoteOnDataChange_Proxy(IAdviseSink, FORMATETC*, RemSTGMEDIUM*);
1181void IAdviseSink_RemoteOnDataChange_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1182void IAdviseSink_RemoteOnViewChange_Proxy(IAdviseSink, DWORD, LONG);
1183void IAdviseSink_RemoteOnViewChange_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1184void IAdviseSink_RemoteOnRename_Proxy(IAdviseSink, IMoniker);
1185void IAdviseSink_RemoteOnRename_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1186void IAdviseSink_RemoteOnSave_Proxy(IAdviseSink);
1187void IAdviseSink_RemoteOnSave_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1188HRESULT IAdviseSink_RemoteOnClose_Proxy(IAdviseSink);
1189void IAdviseSink_RemoteOnClose_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1190void IAdviseSink_OnDataChange_Proxy(IAdviseSink, FORMATETC*, STGMEDIUM*);
1191void IAdviseSink_OnDataChange_Stub(IAdviseSink, FORMATETC*, RemSTGMEDIUM*);
1192void IAdviseSink_OnViewChange_Proxy(IAdviseSink, DWORD, LONG);
1193void IAdviseSink_OnViewChange_Stub(IAdviseSink, DWORD, LONG);
1194void IAdviseSink_OnRename_Proxy(IAdviseSink, IMoniker);
1195void IAdviseSink_OnRename_Stub(IAdviseSink, IMoniker);
1196void IAdviseSink_OnSave_Proxy(IAdviseSink);
1197void IAdviseSink_OnSave_Stub(IAdviseSink);
1198void IAdviseSink_OnClose_Proxy(IAdviseSink);
1199HRESULT IAdviseSink_OnClose_Stub(IAdviseSink);
1200void IAdviseSink2_RemoteOnLinkSrcChange_Proxy(IAdviseSink2, IMoniker);
1201void IAdviseSink2_RemoteOnLinkSrcChange_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1202void IAdviseSink2_OnLinkSrcChange_Proxy(IAdviseSink2, IMoniker);
1203void IAdviseSink2_OnLinkSrcChange_Stub(IAdviseSink2, IMoniker);
1204HRESULT IDataObject_RemoteGetData_Proxy(IDataObject, FORMATETC*, RemSTGMEDIUM**);
1205void IDataObject_RemoteGetData_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1206HRESULT IDataObject_RemoteGetDataHere_Proxy(IDataObject, FORMATETC*, RemSTGMEDIUM**);
1207void IDataObject_RemoteGetDataHere_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1208HRESULT IDataObject_QueryGetData_Proxy(IDataObject, FORMATETC*);
1209void IDataObject_QueryGetData_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1210HRESULT IDataObject_GetCanonicalFormatEtc_Proxy(IDataObject, FORMATETC*, FORMATETC*);
1211void IDataObject_GetCanonicalFormatEtc_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1212HRESULT IDataObject_RemoteSetData_Proxy(IDataObject, FORMATETC*, RemSTGMEDIUM*, BOOL);
1213void IDataObject_RemoteSetData_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1214HRESULT IDataObject_EnumFormatEtc_Proxy(IDataObject, DWORD, IEnumFORMATETC*);
1215void IDataObject_EnumFormatEtc_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1216HRESULT IDataObject_DAdvise_Proxy(IDataObject, FORMATETC*, DWORD, IAdviseSink, DWORD*);
1217void IDataObject_DAdvise_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1218HRESULT IDataObject_DUnadvise_Proxy(IDataObject, DWORD);
1219void IDataObject_DUnadvise_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1220HRESULT IDataObject_EnumDAdvise_Proxy(IDataObject, IEnumSTATDATA*);
1221void IDataObject_EnumDAdvise_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1222HRESULT IDataObject_GetData_Proxy(IDataObject, FORMATETC*, STGMEDIUM*);
1223HRESULT IDataObject_GetData_Stub(IDataObject, FORMATETC*, RemSTGMEDIUM**);
1224HRESULT IDataObject_GetDataHere_Proxy(IDataObject, FORMATETC*, STGMEDIUM*);
1225HRESULT IDataObject_GetDataHere_Stub(IDataObject, FORMATETC*, RemSTGMEDIUM**);
1226HRESULT IDataObject_SetData_Proxy(IDataObject, FORMATETC*, STGMEDIUM*, BOOL);
1227HRESULT IDataObject_SetData_Stub(IDataObject, FORMATETC*, RemSTGMEDIUM*, BOOL);
1228HRESULT IDataAdviseHolder_Advise_Proxy(IDataAdviseHolder, IDataObject, FORMATETC*, DWORD, IAdviseSink, DWORD*);
1229void IDataAdviseHolder_Advise_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1230HRESULT IDataAdviseHolder_Unadvise_Proxy(IDataAdviseHolder, DWORD);
1231void IDataAdviseHolder_Unadvise_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1232HRESULT IDataAdviseHolder_EnumAdvise_Proxy(IDataAdviseHolder, IEnumSTATDATA*);
1233void IDataAdviseHolder_EnumAdvise_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1234HRESULT IDataAdviseHolder_SendOnDataChange_Proxy(IDataAdviseHolder, IDataObject, DWORD, DWORD);
1235void IDataAdviseHolder_SendOnDataChange_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1236DWORD IMessageFilter_HandleInComingCall_Proxy(IMessageFilter, DWORD, HTASK, DWORD, LPINTERFACEINFO);
1237void IMessageFilter_HandleInComingCall_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1238DWORD IMessageFilter_RetryRejectedCall_Proxy(IMessageFilter, HTASK, DWORD, DWORD);
1239void IMessageFilter_RetryRejectedCall_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1240DWORD IMessageFilter_MessagePending_Proxy(IMessageFilter, HTASK, DWORD, DWORD);
1241void IMessageFilter_MessagePending_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1242HRESULT IRpcChannelBuffer_GetBuffer_Proxy(IRpcChannelBuffer, RPCOLEMESSAGE*, REFIID);
1243void IRpcChannelBuffer_GetBuffer_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1244HRESULT IRpcChannelBuffer_SendReceive_Proxy(IRpcChannelBuffer, RPCOLEMESSAGE*, ULONG*);
1245void IRpcChannelBuffer_SendReceive_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1246HRESULT IRpcChannelBuffer_FreeBuffer_Proxy(IRpcChannelBuffer, RPCOLEMESSAGE*);
1247void IRpcChannelBuffer_FreeBuffer_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1248HRESULT IRpcChannelBuffer_GetDestCtx_Proxy(IRpcChannelBuffer, DWORD*, void**);
1249void IRpcChannelBuffer_GetDestCtx_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1250HRESULT IRpcChannelBuffer_IsConnected_Proxy(IRpcChannelBuffer);
1251void IRpcChannelBuffer_IsConnected_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1252HRESULT IRpcProxyBuffer_Connect_Proxy(IRpcProxyBuffer, IRpcChannelBufferpRpcChannelBuffer);
1253void IRpcProxyBuffer_Connect_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1254void IRpcProxyBuffer_Disconnect_Proxy(IRpcProxyBuffer);
1255void IRpcProxyBuffer_Disconnect_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1256HRESULT IRpcStubBuffer_Connect_Proxy(IRpcStubBuffer, IUnknown);
1257void IRpcStubBuffer_Connect_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1258void IRpcStubBuffer_Disconnect_Proxy(IRpcStubBuffer);
1259void IRpcStubBuffer_Disconnect_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1260HRESULT IRpcStubBuffer_Invoke_Proxy(IRpcStubBuffer, RPCOLEMESSAGE*, IRpcChannelBuffer);
1261void IRpcStubBuffer_Invoke_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1262IRpcStubBufferIRpcStubBuffer_IsIIDSupported_Proxy(IRpcStubBuffer, REFIID);
1263void IRpcStubBuffer_IsIIDSupported_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1264ULONG IRpcStubBuffer_CountRefs_Proxy(IRpcStubBuffer);
1265void IRpcStubBuffer_CountRefs_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1266HRESULT IRpcStubBuffer_DebugServerQueryInterface_Proxy(IRpcStubBuffer, void**);
1267void IRpcStubBuffer_DebugServerQueryInterface_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1268void IRpcStubBuffer_DebugServerRelease_Proxy(IRpcStubBuffer, void*);
1269void IRpcStubBuffer_DebugServerRelease_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1270HRESULT IPSFactoryBuffer_CreateProxy_Proxy(IPSFactoryBuffer, IUnknown, REFIID, IRpcProxyBuffer*, void**);
1271void IPSFactoryBuffer_CreateProxy_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1272HRESULT IPSFactoryBuffer_CreateStub_Proxy(IPSFactoryBuffer, REFIID, IUnknown, IRpcStubBuffer*);
1273void IPSFactoryBuffer_CreateStub_Stub(IRpcStubBuffer, IRpcChannelBuffer, PRPC_MESSAGE, PDWORD);
1274void SNB_to_xmit(SNB*, RemSNB**);
1275void SNB_from_xmit(RemSNB*, SNB*);
1276void SNB_free_inst(SNB*);
1277void SNB_free_xmit(RemSNB*);
1278HRESULT IEnumUnknown_Next_Proxy(IEnumUnknown, ULONG, IUnknown*, ULONG*);
1279HRESULT IEnumUnknown_Next_Stub(IEnumUnknown, ULONG, IUnknown*, ULONG*);
1280HRESULT IEnumMoniker_Next_Proxy(IEnumMoniker, ULONG, IMoniker*, ULONG*);
1281HRESULT IEnumMoniker_Next_Stub(IEnumMoniker, ULONG, IMoniker*, ULONG*);
1282HRESULT IMoniker_BindToObject_Proxy(IMoniker, IBindCtx, IMoniker, REFIID, void**);
1283HRESULT IMoniker_BindToObject_Stub(IMoniker, IBindCtx, IMoniker, REFIID, IUnknown*);
1284HRESULT IMoniker_BindToStorage_Proxy(IMoniker, IBindCtx, IMoniker, REFIID, void**);
1285HRESULT IMoniker_BindToStorage_Stub(IMoniker, IBindCtx, IMoniker, REFIID, IUnknown*);
1286HRESULT IEnumString_Next_Proxy(IEnumString, ULONG, LPCSTR*, ULONG*);
1287HRESULT IEnumString_Next_Stub(IEnumString, ULONG, LPCSTR*, ULONG*);
1288HRESULT IStream_Read_Proxy(IStream, void*, ULONG, ULONG*);
1289HRESULT IStream_Read_Stub(IStream, BYTE*, ULONG, ULONG*);
1290HRESULT IStream_Write_Proxy(IStream, void*, ULONG, ULONG*);
1291HRESULT IStream_Write_Stub(IStream, BYTE*, ULONG, ULONG*);
1292HRESULT IStream_Seek_Proxy(IStream, LARGE_INTEGER, DWORD, ULARGE_INTEGER*);
1293HRESULT IStream_Seek_Stub(IStream, LARGE_INTEGER, DWORD, ULARGE_INTEGER*);
1294HRESULT IStream_CopyTo_Proxy(IStream, IStream, ULARGE_INTEGER, ULARGE_INTEGER*, ULARGE_INTEGER*);
1295HRESULT IStream_CopyTo_Stub(IStream, IStream, ULARGE_INTEGER, ULARGE_INTEGER*, ULARGE_INTEGER*);
1296HRESULT IEnumSTATSTG_Next_Proxy(IEnumSTATSTG, ULONG, STATSTG*, ULONG*);
1297HRESULT IEnumSTATSTG_Next_Stub(IEnumSTATSTG, ULONG, STATSTG*, ULONG*);
1298HRESULT IStorage_OpenStream_Proxy(IStorage, OLECHAR*, void*, DWORD, DWORD, IStream*);
1299HRESULT IStorage_OpenStream_Stub(IStorage, OLECHAR*, uint, BYTE*, DWORD, DWORD, IStream* );
1300HRESULT IStorage_EnumElements_Proxy(IStorage, DWORD, void*, DWORD, IEnumSTATSTG*);
1301HRESULT IStorage_EnumElements_Stub(IStorage, DWORD, uint, BYTE*, DWORD, IEnumSTATSTG*);
1302HRESULT ILockBytes_ReadAt_Proxy(ILockBytes, ULARGE_INTEGER, void*, ULONG, ULONG*);
1303HRESULT ILockBytes_ReadAt_Stub(ILockBytes, ULARGE_INTEGER, BYTE*, ULONG, ULONG*);
1304HRESULT ILockBytes_WriteAt_Proxy(ILockBytes, ULARGE_INTEGER, const(void)*, ULONG, ULONG*);
1305HRESULT ILockBytes_WriteAt_Stub(ILockBytes, ULARGE_INTEGER, BYTE*, ULONG, ULONG*);
1306}
1307+/
Mirror of https://gcc.gnu.org/git/gcc.git