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