Mercurial > projects > ddbg_continued
comparison win32/objidl.d @ 1:4a9dcbd9e54f
-files of 0.13 beta
-fixes so that it now compiles with the current dmd version
author | marton@basel.hu |
---|---|
date | Tue, 05 Apr 2011 20:44:01 +0200 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
0:586e4a649642 | 1:4a9dcbd9e54f |
---|---|
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 +/ |