wined3d: Update the swapchain's present parameters when changing the backbuffer.
[wine] / dlls / ole32 / usrmarshal.c
1 /*
2  * Miscellaneous Marshaling Routines
3  *
4  * Copyright 2005 Robert Shearman
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19  */
20
21 #include <stdio.h>
22 #include <stdarg.h>
23 #include <string.h>
24
25 #define COBJMACROS
26 #define NONAMELESSUNION
27 #define NONAMELESSSTRUCT
28
29 #include "windef.h"
30 #include "winbase.h"
31 #include "wingdi.h"
32 #include "winuser.h"
33 #include "winerror.h"
34
35 #include "ole2.h"
36 #include "oleauto.h"
37 #include "rpcproxy.h"
38
39 #include "wine/unicode.h"
40 #include "wine/debug.h"
41
42 WINE_DEFAULT_DEBUG_CHANNEL(ole);
43
44 #define ALIGNED_LENGTH(_Len, _Align) (((_Len)+(_Align))&~(_Align))
45 #define ALIGNED_POINTER(_Ptr, _Align) ((LPVOID)ALIGNED_LENGTH((ULONG_PTR)(_Ptr), _Align))
46 #define ALIGN_LENGTH(_Len, _Align) _Len = ALIGNED_LENGTH(_Len, _Align)
47 #define ALIGN_POINTER(_Ptr, _Align) _Ptr = ALIGNED_POINTER(_Ptr, _Align)
48
49 #define USER_MARSHAL_PTR_PREFIX \
50   ( (DWORD)'U'         | ( (DWORD)'s' << 8 ) | \
51   ( (DWORD)'e' << 16 ) | ( (DWORD)'r' << 24 ) )
52
53 static const char* debugstr_user_flags(ULONG *pFlags)
54 {
55     char buf[12];
56     const char* loword;
57     switch (LOWORD(*pFlags))
58     {
59     case MSHCTX_LOCAL:
60         loword="MSHCTX_LOCAL";
61         break;
62     case MSHCTX_NOSHAREDMEM:
63         loword="MSHCTX_NOSHAREDMEM";
64         break;
65     case MSHCTX_DIFFERENTMACHINE:
66         loword="MSHCTX_DIFFERENTMACHINE";
67         break;
68     case MSHCTX_INPROC:
69         loword="MSHCTX_INPROC";
70         break;
71     default:
72         sprintf(buf, "%d", LOWORD(*pFlags));
73         loword=buf;
74     }
75
76     if (HIWORD(*pFlags) == NDR_LOCAL_DATA_REPRESENTATION)
77         return wine_dbg_sprintf("MAKELONG(NDR_LOCAL_REPRESENTATION, %s)", loword);
78     else
79         return wine_dbg_sprintf("MAKELONG(0x%04x, %s)", HIWORD(*pFlags), loword);
80 }
81
82 /******************************************************************************
83  *           CLIPFORMAT_UserSize [OLE32.@]
84  *
85  * Calculates the buffer size required to marshal a clip format.
86  *
87  * PARAMS
88  *  pFlags       [I] Flags. See notes.
89  *  StartingSize [I] Starting size of the buffer. This value is added on to
90  *                   the buffer size required for the clip format.
91  *  pCF          [I] Clip format to size.
92  *
93  * RETURNS
94  *  The buffer size required to marshal a clip format plus the starting size.
95  *
96  * NOTES
97  *  Even though the function is documented to take a pointer to an unsigned
98  *  long in pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
99  *  the first parameter is an unsigned long.
100  *  This function is only intended to be called by the RPC runtime.
101  */
102 ULONG __RPC_USER CLIPFORMAT_UserSize(ULONG *pFlags, ULONG StartingSize, CLIPFORMAT *pCF)
103 {
104     ULONG size = StartingSize;
105
106     TRACE("(%s, %d, %p\n", debugstr_user_flags(pFlags), StartingSize, pCF);
107
108     size += 8;
109
110     /* only need to marshal the name if it is not a pre-defined type and
111      * we are going remote */
112     if ((*pCF >= 0xc000) && (LOWORD(*pFlags) == MSHCTX_DIFFERENTMACHINE))
113     {
114         WCHAR format[255];
115         INT ret;
116         size += 3 * sizeof(UINT);
117         /* urg! this function is badly designed because it won't tell us how
118          * much space is needed without doing a dummy run of storing the
119          * name into a buffer */
120         ret = GetClipboardFormatNameW(*pCF, format, sizeof(format)/sizeof(format[0])-1);
121         if (!ret)
122             RaiseException(DV_E_CLIPFORMAT, 0, 0, NULL);
123         size += (ret + 1) * sizeof(WCHAR);
124     }
125     return size;
126 }
127
128 /******************************************************************************
129  *           CLIPFORMAT_UserMarshal [OLE32.@]
130  *
131  * Marshals a clip format into a buffer.
132  *
133  * PARAMS
134  *  pFlags  [I] Flags. See notes.
135  *  pBuffer [I] Buffer to marshal the clip format into.
136  *  pCF     [I] Clip format to marshal.
137  *
138  * RETURNS
139  *  The end of the marshaled data in the buffer.
140  *
141  * NOTES
142  *  Even though the function is documented to take a pointer to an unsigned
143  *  long in pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
144  *  the first parameter is an unsigned long.
145  *  This function is only intended to be called by the RPC runtime.
146  */
147 unsigned char * __RPC_USER CLIPFORMAT_UserMarshal(ULONG *pFlags, unsigned char *pBuffer, CLIPFORMAT *pCF)
148 {
149     TRACE("(%s, %p, &0x%04x\n", debugstr_user_flags(pFlags), pBuffer, *pCF);
150
151     /* only need to marshal the name if it is not a pre-defined type and
152      * we are going remote */
153     if ((*pCF >= 0xc000) && (LOWORD(*pFlags) == MSHCTX_DIFFERENTMACHINE))
154     {
155         WCHAR format[255];
156         UINT len;
157
158         *(DWORD *)pBuffer = WDT_REMOTE_CALL;
159         pBuffer += 4;
160         *(DWORD *)pBuffer = *pCF;
161         pBuffer += 4;
162
163         len = GetClipboardFormatNameW(*pCF, format, sizeof(format)/sizeof(format[0])-1);
164         if (!len)
165             RaiseException(DV_E_CLIPFORMAT, 0, 0, NULL);
166         len += 1;
167         *(UINT *)pBuffer = len;
168         pBuffer += sizeof(UINT);
169         *(UINT *)pBuffer = 0;
170         pBuffer += sizeof(UINT);
171         *(UINT *)pBuffer = len;
172         pBuffer += sizeof(UINT);
173         TRACE("marshaling format name %s\n", debugstr_w(format));
174         memcpy(pBuffer, format, len * sizeof(WCHAR));
175         pBuffer += len * sizeof(WCHAR);
176     }
177     else
178     {
179         *(DWORD *)pBuffer = WDT_INPROC_CALL;
180         pBuffer += 4;
181         *(DWORD *)pBuffer = *pCF;
182         pBuffer += 4;
183     }
184
185     return pBuffer;
186 }
187
188 /******************************************************************************
189  *           CLIPFORMAT_UserUnmarshal [OLE32.@]
190  *
191  * Unmarshals a clip format from a buffer.
192  *
193  * PARAMS
194  *  pFlags  [I] Flags. See notes.
195  *  pBuffer [I] Buffer to marshal the clip format from.
196  *  pCF     [O] Address that receive the unmarshaled clip format.
197  *
198  * RETURNS
199  *  The end of the marshaled data in the buffer.
200  *
201  * NOTES
202  *  Even though the function is documented to take a pointer to an unsigned
203  *  long in pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
204  *  the first parameter is an unsigned long.
205  *  This function is only intended to be called by the RPC runtime.
206  */
207 unsigned char * __RPC_USER CLIPFORMAT_UserUnmarshal(ULONG *pFlags, unsigned char *pBuffer, CLIPFORMAT *pCF)
208 {
209     LONG fContext;
210
211     TRACE("(%s, %p, %p\n", debugstr_user_flags(pFlags), pBuffer, pCF);
212
213     fContext = *(DWORD *)pBuffer;
214     pBuffer += 4;
215
216     if (fContext == WDT_INPROC_CALL)
217     {
218         *pCF = *(CLIPFORMAT *)pBuffer;
219         pBuffer += 4;
220     }
221     else if (fContext == WDT_REMOTE_CALL)
222     {
223         CLIPFORMAT cf;
224         UINT len;
225
226         /* pointer ID for registered clip format string */
227         if (*(DWORD *)pBuffer == 0)
228             RaiseException(RPC_S_INVALID_BOUND, 0, 0, NULL);
229         pBuffer += 4;
230
231         len = *(UINT *)pBuffer;
232         pBuffer += sizeof(UINT);
233         if (*(UINT *)pBuffer != 0)
234             RaiseException(RPC_S_INVALID_BOUND, 0, 0, NULL);
235         pBuffer += sizeof(UINT);
236         if (*(UINT *)pBuffer != len)
237             RaiseException(RPC_S_INVALID_BOUND, 0, 0, NULL);
238         pBuffer += sizeof(UINT);
239         if (((WCHAR *)pBuffer)[len - 1] != '\0')
240             RaiseException(RPC_S_INVALID_BOUND, 0, 0, NULL);
241         TRACE("unmarshaling clip format %s\n", debugstr_w((LPCWSTR)pBuffer));
242         cf = RegisterClipboardFormatW((LPCWSTR)pBuffer);
243         pBuffer += len * sizeof(WCHAR);
244         if (!cf)
245             RaiseException(DV_E_CLIPFORMAT, 0, 0, NULL);
246         *pCF = cf;
247     }
248     else
249         /* code not really appropriate, but nearest I can find */
250         RaiseException(RPC_S_INVALID_TAG, 0, 0, NULL);
251     return pBuffer;
252 }
253
254 /******************************************************************************
255  *           CLIPFORMAT_UserFree [OLE32.@]
256  *
257  * Frees an unmarshaled clip format.
258  *
259  * PARAMS
260  *  pFlags  [I] Flags. See notes.
261  *  pCF     [I] Clip format to free.
262  *
263  * RETURNS
264  *  The end of the marshaled data in the buffer.
265  *
266  * NOTES
267  *  Even though the function is documented to take a pointer to an unsigned
268  *  long in pFlags, it actually takes a pointer to a USER_MARSHAL_CB
269  *  structure, of which the first parameter is an unsigned long.
270  *  This function is only intended to be called by the RPC runtime.
271  */
272 void __RPC_USER CLIPFORMAT_UserFree(ULONG *pFlags, CLIPFORMAT *pCF)
273 {
274     /* there is no inverse of the RegisterClipboardFormat function,
275      * so nothing to do */
276 }
277
278 static ULONG handle_UserSize(ULONG *pFlags, ULONG StartingSize, HANDLE *handle)
279 {
280     if (LOWORD(*pFlags) == MSHCTX_DIFFERENTMACHINE)
281     {
282         ERR("can't remote a local handle\n");
283         RaiseException(RPC_S_INVALID_TAG, 0, 0, NULL);
284         return StartingSize;
285     }
286     return StartingSize + sizeof(RemotableHandle);
287 }
288
289 static unsigned char * handle_UserMarshal(ULONG *pFlags, unsigned char *pBuffer, HANDLE *handle)
290 {
291     RemotableHandle *remhandle = (RemotableHandle *)pBuffer;
292     if (LOWORD(*pFlags) == MSHCTX_DIFFERENTMACHINE)
293     {
294         ERR("can't remote a local handle\n");
295         RaiseException(RPC_S_INVALID_TAG, 0, 0, NULL);
296         return pBuffer;
297     }
298     remhandle->fContext = WDT_INPROC_CALL;
299     remhandle->u.hInproc = (LONG_PTR)*handle;
300     return pBuffer + sizeof(RemotableHandle);
301 }
302
303 static unsigned char * handle_UserUnmarshal(ULONG *pFlags, unsigned char *pBuffer, HANDLE *handle)
304 {
305     RemotableHandle *remhandle = (RemotableHandle *)pBuffer;
306     if (remhandle->fContext != WDT_INPROC_CALL)
307         RaiseException(RPC_X_BAD_STUB_DATA, 0, 0, NULL);
308     *handle = (HANDLE)(LONG_PTR)remhandle->u.hInproc;
309     return pBuffer + sizeof(RemotableHandle);
310 }
311
312 static void handle_UserFree(ULONG *pFlags, HANDLE *phMenu)
313 {
314     /* nothing to do */
315 }
316
317 #define IMPL_WIREM_HANDLE(type) \
318     ULONG __RPC_USER type##_UserSize(ULONG *pFlags, ULONG StartingSize, type *handle) \
319     { \
320         TRACE("(%s, %d, %p\n", debugstr_user_flags(pFlags), StartingSize, handle); \
321         return handle_UserSize(pFlags, StartingSize, (HANDLE *)handle); \
322     } \
323     \
324     unsigned char * __RPC_USER type##_UserMarshal(ULONG *pFlags, unsigned char *pBuffer, type *handle) \
325     { \
326         TRACE("(%s, %p, &%p\n", debugstr_user_flags(pFlags), pBuffer, *handle); \
327         return handle_UserMarshal(pFlags, pBuffer, (HANDLE *)handle); \
328     } \
329     \
330     unsigned char * __RPC_USER type##_UserUnmarshal(ULONG *pFlags, unsigned char *pBuffer, type *handle) \
331     { \
332         TRACE("(%s, %p, %p\n", debugstr_user_flags(pFlags), pBuffer, handle); \
333         return handle_UserUnmarshal(pFlags, pBuffer, (HANDLE *)handle); \
334     } \
335     \
336     void __RPC_USER type##_UserFree(ULONG *pFlags, type *handle) \
337     { \
338         TRACE("(%s, &%p\n", debugstr_user_flags(pFlags), *handle); \
339         handle_UserFree(pFlags, (HANDLE *)handle); \
340     }
341
342 IMPL_WIREM_HANDLE(HACCEL)
343 IMPL_WIREM_HANDLE(HMENU)
344 IMPL_WIREM_HANDLE(HWND)
345
346 /******************************************************************************
347  *           HGLOBAL_UserSize [OLE32.@]
348  *
349  * Calculates the buffer size required to marshal an HGLOBAL.
350  *
351  * PARAMS
352  *  pFlags       [I] Flags. See notes.
353  *  StartingSize [I] Starting size of the buffer. This value is added on to
354  *                   the buffer size required for the clip format.
355  *  phGlobal     [I] HGLOBAL to size.
356  *
357  * RETURNS
358  *  The buffer size required to marshal an HGLOBAL plus the starting size.
359  *
360  * NOTES
361  *  Even though the function is documented to take a pointer to a ULONG in
362  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
363  *  the first parameter is a ULONG.
364  *  This function is only intended to be called by the RPC runtime.
365  */
366 ULONG __RPC_USER HGLOBAL_UserSize(ULONG *pFlags, ULONG StartingSize, HGLOBAL *phGlobal)
367 {
368     ULONG size = StartingSize;
369
370     TRACE("(%s, %d, %p\n", debugstr_user_flags(pFlags), StartingSize, phGlobal);
371
372     ALIGN_LENGTH(size, 3);
373
374     size += sizeof(ULONG);
375
376     if (LOWORD(*pFlags == MSHCTX_INPROC))
377         size += sizeof(HGLOBAL);
378     else
379     {
380         size += sizeof(ULONG);
381         if (*phGlobal)
382         {
383             SIZE_T ret;
384             size += 3 * sizeof(ULONG);
385             ret = GlobalSize(*phGlobal);
386             size += (ULONG)ret;
387         }
388     }
389     
390     return size;
391 }
392
393 /******************************************************************************
394  *           HGLOBAL_UserMarshal [OLE32.@]
395  *
396  * Marshals an HGLOBAL into a buffer.
397  *
398  * PARAMS
399  *  pFlags   [I] Flags. See notes.
400  *  pBuffer  [I] Buffer to marshal the clip format into.
401  *  phGlobal [I] HGLOBAL to marshal.
402  *
403  * RETURNS
404  *  The end of the marshaled data in the buffer.
405  *
406  * NOTES
407  *  Even though the function is documented to take a pointer to a ULONG in
408  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
409  *  the first parameter is a ULONG.
410  *  This function is only intended to be called by the RPC runtime.
411  */
412 unsigned char * __RPC_USER HGLOBAL_UserMarshal(ULONG *pFlags, unsigned char *pBuffer, HGLOBAL *phGlobal)
413 {
414     TRACE("(%s, %p, &%p\n", debugstr_user_flags(pFlags), pBuffer, *phGlobal);
415
416     ALIGN_POINTER(pBuffer, 3);
417
418     if (LOWORD(*pFlags == MSHCTX_INPROC))
419     {
420         if (sizeof(*phGlobal) == 8)
421             *(ULONG *)pBuffer = WDT_INPROC64_CALL;
422         else
423             *(ULONG *)pBuffer = WDT_INPROC_CALL;
424         pBuffer += sizeof(ULONG);
425         *(HGLOBAL *)pBuffer = *phGlobal;
426         pBuffer += sizeof(HGLOBAL);
427     }
428     else
429     {
430         *(ULONG *)pBuffer = WDT_REMOTE_CALL;
431         pBuffer += sizeof(ULONG);
432         *(ULONG *)pBuffer = (ULONG)*phGlobal;
433         pBuffer += sizeof(ULONG);
434         if (*phGlobal)
435         {
436             const unsigned char *memory;
437             SIZE_T size = GlobalSize(*phGlobal);
438             *(ULONG *)pBuffer = (ULONG)size;
439             pBuffer += sizeof(ULONG);
440             *(ULONG *)pBuffer = (ULONG)*phGlobal;
441             pBuffer += sizeof(ULONG);
442             *(ULONG *)pBuffer = (ULONG)size;
443             pBuffer += sizeof(ULONG);
444
445             memory = GlobalLock(*phGlobal);
446             memcpy(pBuffer, memory, size);
447             pBuffer += size;
448             GlobalUnlock(*phGlobal);
449         }
450     }
451
452     return pBuffer;
453 }
454
455 /******************************************************************************
456  *           HGLOBAL_UserUnmarshal [OLE32.@]
457  *
458  * Unmarshals an HGLOBAL from a buffer.
459  *
460  * PARAMS
461  *  pFlags   [I] Flags. See notes.
462  *  pBuffer  [I] Buffer to marshal the clip format from.
463  *  phGlobal [O] Address that receive the unmarshaled HGLOBAL.
464  *
465  * RETURNS
466  *  The end of the marshaled data in the buffer.
467  *
468  * NOTES
469  *  Even though the function is documented to take a pointer to an ULONG in
470  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
471  *  the first parameter is an ULONG.
472  *  This function is only intended to be called by the RPC runtime.
473  */
474 unsigned char * __RPC_USER HGLOBAL_UserUnmarshal(ULONG *pFlags, unsigned char *pBuffer, HGLOBAL *phGlobal)
475 {
476     ULONG fContext;
477
478     TRACE("(%s, %p, &%p\n", debugstr_user_flags(pFlags), pBuffer, *phGlobal);
479
480     ALIGN_POINTER(pBuffer, 3);
481
482     fContext = *(ULONG *)pBuffer;
483     pBuffer += sizeof(ULONG);
484
485     if (((fContext == WDT_INPROC_CALL) && (sizeof(*phGlobal) < 8)) ||
486         ((fContext == WDT_INPROC64_CALL) && (sizeof(*phGlobal) == 8)))
487     {
488         *phGlobal = *(HGLOBAL *)pBuffer;
489         pBuffer += sizeof(*phGlobal);
490     }
491     else if (fContext == WDT_REMOTE_CALL)
492     {
493         ULONG handle;
494
495         handle = *(ULONG *)pBuffer;
496         pBuffer += sizeof(ULONG);
497
498         if (handle)
499         {
500             ULONG size;
501             void *memory;
502
503             size = *(ULONG *)pBuffer;
504             pBuffer += sizeof(ULONG);
505             /* redundancy is bad - it means you have to check consistency like
506              * this: */
507             if (*(ULONG *)pBuffer != handle)
508             {
509                 RaiseException(RPC_X_BAD_STUB_DATA, 0, 0, NULL);
510                 return pBuffer;
511             }
512             pBuffer += sizeof(ULONG);
513             /* redundancy is bad - it means you have to check consistency like
514              * this: */
515             if (*(ULONG *)pBuffer != size)
516             {
517                 RaiseException(RPC_X_BAD_STUB_DATA, 0, 0, NULL);
518                 return pBuffer;
519             }
520             pBuffer += sizeof(ULONG);
521
522             /* FIXME: check size is not too big */
523
524             *phGlobal = GlobalAlloc(GMEM_MOVEABLE, size);
525             memory = GlobalLock(*phGlobal);
526             memcpy(memory, pBuffer, size);
527             pBuffer += size;
528             GlobalUnlock(*phGlobal);
529         }
530         else
531             *phGlobal = NULL;
532     }
533     else
534         RaiseException(RPC_S_INVALID_TAG, 0, 0, NULL);
535
536     return pBuffer;
537 }
538
539 /******************************************************************************
540  *           HGLOBAL_UserFree [OLE32.@]
541  *
542  * Frees an unmarshaled HGLOBAL.
543  *
544  * PARAMS
545  *  pFlags   [I] Flags. See notes.
546  *  phGlobal [I] HGLOBAL to free.
547  *
548  * RETURNS
549  *  The end of the marshaled data in the buffer.
550  *
551  * NOTES
552  *  Even though the function is documented to take a pointer to a ULONG in
553  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of
554  *  which the first parameter is a ULONG.
555  *  This function is only intended to be called by the RPC runtime.
556  */
557 void __RPC_USER HGLOBAL_UserFree(ULONG *pFlags, HGLOBAL *phGlobal)
558 {
559     TRACE("(%s, &%p\n", debugstr_user_flags(pFlags), *phGlobal);
560
561     if (LOWORD(*pFlags != MSHCTX_INPROC) && *phGlobal)
562         GlobalFree(*phGlobal);
563 }
564
565 /******************************************************************************
566  *           HBITMAP_UserSize [OLE32.@]
567  *
568  * Calculates the buffer size required to marshal a bitmap.
569  *
570  * PARAMS
571  *  pFlags       [I] Flags. See notes.
572  *  StartingSize [I] Starting size of the buffer. This value is added on to
573  *                   the buffer size required for the clip format.
574  *  phBmp        [I] Bitmap to size.
575  *
576  * RETURNS
577  *  The buffer size required to marshal an bitmap plus the starting size.
578  *
579  * NOTES
580  *  Even though the function is documented to take a pointer to a ULONG in
581  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
582  *  the first parameter is a ULONG.
583  *  This function is only intended to be called by the RPC runtime.
584  */
585 ULONG __RPC_USER HBITMAP_UserSize(ULONG *pFlags, ULONG StartingSize, HBITMAP *phBmp)
586 {
587     FIXME(":stub\n");
588     return StartingSize;
589 }
590
591 /******************************************************************************
592 *           HBITMAP_UserMarshal [OLE32.@]
593 *
594 * Marshals a bitmap into a buffer.
595 *
596 * PARAMS
597 *  pFlags  [I] Flags. See notes.
598 *  pBuffer [I] Buffer to marshal the clip format into.
599 *  phBmp   [I] Bitmap to marshal.
600 *
601 * RETURNS
602 *  The end of the marshaled data in the buffer.
603 *
604 * NOTES
605 *  Even though the function is documented to take a pointer to a ULONG in
606 *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
607 *  the first parameter is a ULONG.
608 *  This function is only intended to be called by the RPC runtime.
609 */
610 unsigned char * __RPC_USER HBITMAP_UserMarshal(ULONG *pFlags, unsigned char *pBuffer, HBITMAP *phBmp)
611 {
612     FIXME(":stub\n");
613     return pBuffer;
614 }
615
616 /******************************************************************************
617  *           HBITMAP_UserUnmarshal [OLE32.@]
618  *
619  * Unmarshals a bitmap from a buffer.
620  *
621  * PARAMS
622  *  pFlags   [I] Flags. See notes.
623  *  pBuffer  [I] Buffer to marshal the clip format from.
624  *  phBmp    [O] Address that receive the unmarshaled bitmap.
625  *
626  * RETURNS
627  *  The end of the marshaled data in the buffer.
628  *
629  * NOTES
630  *  Even though the function is documented to take a pointer to an ULONG in
631  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
632  *  the first parameter is an ULONG.
633  *  This function is only intended to be called by the RPC runtime.
634  */
635 unsigned char * __RPC_USER HBITMAP_UserUnmarshal(ULONG *pFlags, unsigned char *pBuffer, HBITMAP *phBmp)
636 {
637     FIXME(":stub\n");
638     return pBuffer;
639 }
640
641 /******************************************************************************
642  *           HBITMAP_UserFree [OLE32.@]
643  *
644  * Frees an unmarshaled bitmap.
645  *
646  * PARAMS
647  *  pFlags   [I] Flags. See notes.
648  *  phBmp    [I] Bitmap to free.
649  *
650  * RETURNS
651  *  The end of the marshaled data in the buffer.
652  *
653  * NOTES
654  *  Even though the function is documented to take a pointer to a ULONG in
655  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of
656  *  which the first parameter is a ULONG.
657  *  This function is only intended to be called by the RPC runtime.
658  */
659 void __RPC_USER HBITMAP_UserFree(ULONG *pFlags, HBITMAP *phBmp)
660 {
661     FIXME(":stub\n");
662 }
663
664 /******************************************************************************
665  *           HICON_UserSize [OLE32.@]
666  *
667  * Calculates the buffer size required to marshal an icon.
668  *
669  * PARAMS
670  *  pFlags       [I] Flags. See notes.
671  *  StartingSize [I] Starting size of the buffer. This value is added on to
672  *                   the buffer size required for the icon.
673  *  phIcon       [I] Icon to size.
674  *
675  * RETURNS
676  *  The buffer size required to marshal an icon plus the starting size.
677  *
678  * NOTES
679  *  Even though the function is documented to take a pointer to a ULONG in
680  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
681  *  the first parameter is a ULONG.
682  *  This function is only intended to be called by the RPC runtime.
683  */
684 ULONG __RPC_USER HICON_UserSize(ULONG *pFlags, ULONG StartingSize, HICON *phIcon)
685 {
686     FIXME(":stub\n");
687     return StartingSize;
688 }
689
690 /******************************************************************************
691 *           HICON_UserMarshal [OLE32.@]
692 *
693 * Marshals an icon into a buffer.
694 *
695 * PARAMS
696 *  pFlags  [I] Flags. See notes.
697 *  pBuffer [I] Buffer to marshal the icon into.
698 *  phIcon  [I] Icon to marshal.
699 *
700 * RETURNS
701 *  The end of the marshaled data in the buffer.
702 *
703 * NOTES
704 *  Even though the function is documented to take a pointer to a ULONG in
705 *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
706 *  the first parameter is a ULONG.
707 *  This function is only intended to be called by the RPC runtime.
708 */
709 unsigned char * __RPC_USER HICON_UserMarshal(ULONG *pFlags, unsigned char *pBuffer, HICON *phIcon)
710 {
711     FIXME(":stub\n");
712     return pBuffer;
713 }
714
715 /******************************************************************************
716  *           HICON_UserUnmarshal [OLE32.@]
717  *
718  * Unmarshals an icon from a buffer.
719  *
720  * PARAMS
721  *  pFlags   [I] Flags. See notes.
722  *  pBuffer  [I] Buffer to marshal the icon from.
723  *  phIcon   [O] Address that receive the unmarshaled icon.
724  *
725  * RETURNS
726  *  The end of the marshaled data in the buffer.
727  *
728  * NOTES
729  *  Even though the function is documented to take a pointer to an ULONG in
730  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
731  *  the first parameter is an ULONG.
732  *  This function is only intended to be called by the RPC runtime.
733  */
734 unsigned char * __RPC_USER HICON_UserUnmarshal(ULONG *pFlags, unsigned char *pBuffer, HICON *phIcon)
735 {
736     FIXME(":stub\n");
737     return pBuffer;
738 }
739
740 /******************************************************************************
741  *           HICON_UserFree [OLE32.@]
742  *
743  * Frees an unmarshaled icon.
744  *
745  * PARAMS
746  *  pFlags   [I] Flags. See notes.
747  *  phIcon   [I] Icon to free.
748  *
749  * RETURNS
750  *  The end of the marshaled data in the buffer.
751  *
752  * NOTES
753  *  Even though the function is documented to take a pointer to a ULONG in
754  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of
755  *  which the first parameter is a ULONG.
756  *  This function is only intended to be called by the RPC runtime.
757  */
758 void __RPC_USER HICON_UserFree(ULONG *pFlags, HICON *phIcon)
759 {
760     FIXME(":stub\n");
761 }
762
763 /******************************************************************************
764  *           HDC_UserSize [OLE32.@]
765  *
766  * Calculates the buffer size required to marshal an HDC.
767  *
768  * PARAMS
769  *  pFlags       [I] Flags. See notes.
770  *  StartingSize [I] Starting size of the buffer. This value is added on to
771  *                   the buffer size required for the clip format.
772  *  phGlobal     [I] HDC to size.
773  *
774  * RETURNS
775  *  The buffer size required to marshal an HDC plus the starting size.
776  *
777  * NOTES
778  *  Even though the function is documented to take a pointer to a ULONG in
779  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
780  *  the first parameter is a ULONG.
781  *  This function is only intended to be called by the RPC runtime.
782  */
783 ULONG __RPC_USER HDC_UserSize(ULONG *pFlags, ULONG StartingSize, HDC *phdc)
784 {
785     FIXME(":stub\n");
786     return StartingSize;
787 }
788
789 /******************************************************************************
790  *           HDC_UserMarshal [OLE32.@]
791  *
792  * Marshals an HDC into a buffer.
793  *
794  * PARAMS
795  *  pFlags  [I] Flags. See notes.
796  *  pBuffer [I] Buffer to marshal the clip format into.
797  *  phdc    [I] HDC to marshal.
798  *
799  * RETURNS
800  *  The end of the marshaled data in the buffer.
801  *
802  * NOTES
803  *  Even though the function is documented to take a pointer to a ULONG in
804  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
805  *  the first parameter is a ULONG.
806  *  This function is only intended to be called by the RPC runtime.
807  */
808 unsigned char * __RPC_USER HDC_UserMarshal(ULONG *pFlags, unsigned char *pBuffer, HDC *phdc)
809 {
810     FIXME(":stub\n");
811     return pBuffer;
812 }
813
814 /******************************************************************************
815  *           HDC_UserUnmarshal [OLE32.@]
816  *
817  * Unmarshals an HDC from a buffer.
818  *
819  * PARAMS
820  *  pFlags   [I] Flags. See notes.
821  *  pBuffer  [I] Buffer to marshal the clip format from.
822  *  phdc     [O] Address that receive the unmarshaled HDC.
823  *
824  * RETURNS
825  *  The end of the marshaled data in the buffer.
826  *
827  * NOTES
828  *  Even though the function is documented to take a pointer to an ULONG in
829  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
830  *  the first parameter is an ULONG.
831  *  This function is only intended to be called by the RPC runtime.
832  */
833 unsigned char * __RPC_USER HDC_UserUnmarshal(ULONG *pFlags, unsigned char *pBuffer, HDC *phdc)
834 {
835     FIXME(":stub\n");
836     return pBuffer;
837 }
838
839 /******************************************************************************
840  *           HDC_UserFree [OLE32.@]
841  *
842  * Frees an unmarshaled HDC.
843  *
844  * PARAMS
845  *  pFlags   [I] Flags. See notes.
846  *  phdc     [I] HDC to free.
847  *
848  * RETURNS
849  *  The end of the marshaled data in the buffer.
850  *
851  * NOTES
852  *  Even though the function is documented to take a pointer to a ULONG in
853  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of
854  *  which the first parameter is a ULONG.
855  *  This function is only intended to be called by the RPC runtime.
856  */
857 void __RPC_USER HDC_UserFree(ULONG *pFlags, HDC *phdc)
858 {
859     FIXME(":stub\n");
860 }
861
862 /******************************************************************************
863  *           HPALETTE_UserSize [OLE32.@]
864  *
865  * Calculates the buffer size required to marshal a palette.
866  *
867  * PARAMS
868  *  pFlags       [I] Flags. See notes.
869  *  StartingSize [I] Starting size of the buffer. This value is added on to
870  *                   the buffer size required for the clip format.
871  *  phPal        [I] Palette to size.
872  *
873  * RETURNS
874  *  The buffer size required to marshal a palette plus the starting size.
875  *
876  * NOTES
877  *  Even though the function is documented to take a pointer to a ULONG in
878  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
879  *  the first parameter is a ULONG.
880  *  This function is only intended to be called by the RPC runtime.
881  */
882 ULONG __RPC_USER HPALETTE_UserSize(ULONG *pFlags, ULONG StartingSize, HPALETTE *phPal)
883 {
884     FIXME(":stub\n");
885     return StartingSize;
886 }
887
888 /******************************************************************************
889  *           HPALETTE_UserMarshal [OLE32.@]
890  *
891  * Marshals a palette into a buffer.
892  *
893  * PARAMS
894  *  pFlags  [I] Flags. See notes.
895  *  pBuffer [I] Buffer to marshal the clip format into.
896  *  phPal   [I] Palette to marshal.
897  *
898  * RETURNS
899  *  The end of the marshaled data in the buffer.
900  *
901  * NOTES
902  *  Even though the function is documented to take a pointer to a ULONG in
903  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
904  *  the first parameter is a ULONG.
905  *  This function is only intended to be called by the RPC runtime.
906  */
907 unsigned char * __RPC_USER HPALETTE_UserMarshal(ULONG *pFlags, unsigned char *pBuffer, HPALETTE *phPal)
908 {
909     FIXME(":stub\n");
910     return pBuffer;
911 }
912
913 /******************************************************************************
914  *           HPALETTE_UserUnmarshal [OLE32.@]
915  *
916  * Unmarshals a palette from a buffer.
917  *
918  * PARAMS
919  *  pFlags   [I] Flags. See notes.
920  *  pBuffer  [I] Buffer to marshal the clip format from.
921  *  phPal    [O] Address that receive the unmarshaled palette.
922  *
923  * RETURNS
924  *  The end of the marshaled data in the buffer.
925  *
926  * NOTES
927  *  Even though the function is documented to take a pointer to an ULONG in
928  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
929  *  the first parameter is an ULONG.
930  *  This function is only intended to be called by the RPC runtime.
931  */
932 unsigned char * __RPC_USER HPALETTE_UserUnmarshal(ULONG *pFlags, unsigned char *pBuffer, HPALETTE *phPal)
933 {
934     FIXME(":stub\n");
935     return pBuffer;
936 }
937
938 /******************************************************************************
939  *           HPALETTE_UserFree [OLE32.@]
940  *
941  * Frees an unmarshaled palette.
942  *
943  * PARAMS
944  *  pFlags   [I] Flags. See notes.
945  *  phPal    [I] Palette to free.
946  *
947  * RETURNS
948  *  The end of the marshaled data in the buffer.
949  *
950  * NOTES
951  *  Even though the function is documented to take a pointer to a ULONG in
952  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of
953  *  which the first parameter is a ULONG.
954  *  This function is only intended to be called by the RPC runtime.
955  */
956 void __RPC_USER HPALETTE_UserFree(ULONG *pFlags, HPALETTE *phPal)
957 {
958     FIXME(":stub\n");
959 }
960
961
962 /******************************************************************************
963  *           HMETAFILE_UserSize [OLE32.@]
964  *
965  * Calculates the buffer size required to marshal a metafile.
966  *
967  * PARAMS
968  *  pFlags       [I] Flags. See notes.
969  *  StartingSize [I] Starting size of the buffer. This value is added on to
970  *                   the buffer size required for the clip format.
971  *  phmf         [I] Metafile to size.
972  *
973  * RETURNS
974  *  The buffer size required to marshal a metafile plus the starting size.
975  *
976  * NOTES
977  *  Even though the function is documented to take a pointer to a ULONG in
978  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
979  *  the first parameter is a ULONG.
980  *  This function is only intended to be called by the RPC runtime.
981  */
982 ULONG __RPC_USER HMETAFILE_UserSize(ULONG *pFlags, ULONG StartingSize, HMETAFILE *phmf)
983 {
984     ULONG size = StartingSize;
985
986     TRACE("(%s, %d, &%p\n", debugstr_user_flags(pFlags), StartingSize, *phmf);
987
988     ALIGN_LENGTH(size, 3);
989
990     size += sizeof(ULONG);
991     if (LOWORD(*pFlags) == MSHCTX_INPROC)
992         size += sizeof(ULONG_PTR);
993     else
994     {
995         size += sizeof(ULONG);
996
997         if (*phmf)
998         {
999             UINT mfsize;
1000
1001             size += 2 * sizeof(ULONG);
1002             mfsize = GetMetaFileBitsEx(*phmf, 0, NULL);
1003             size += mfsize;
1004         }
1005     }
1006
1007     return size;
1008 }
1009
1010 /******************************************************************************
1011  *           HMETAFILE_UserMarshal [OLE32.@]
1012  *
1013  * Marshals a metafile into a buffer.
1014  *
1015  * PARAMS
1016  *  pFlags  [I] Flags. See notes.
1017  *  pBuffer [I] Buffer to marshal the clip format into.
1018  *  phEmf   [I] Metafile to marshal.
1019  *
1020  * RETURNS
1021  *  The end of the marshaled data in the buffer.
1022  *
1023  * NOTES
1024  *  Even though the function is documented to take a pointer to a ULONG in
1025  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
1026  *  the first parameter is a ULONG.
1027  *  This function is only intended to be called by the RPC runtime.
1028  */
1029 unsigned char * __RPC_USER HMETAFILE_UserMarshal(ULONG *pFlags, unsigned char *pBuffer, HMETAFILE *phmf)
1030 {
1031     TRACE("(%s, %p, &%p\n", debugstr_user_flags(pFlags), pBuffer, *phmf);
1032
1033     ALIGN_POINTER(pBuffer, 3);
1034
1035     if (LOWORD(*pFlags) == MSHCTX_INPROC)
1036     {
1037         if (sizeof(*phmf) == 8)
1038             *(ULONG *)pBuffer = WDT_INPROC64_CALL;
1039         else
1040             *(ULONG *)pBuffer = WDT_INPROC_CALL;
1041         pBuffer += sizeof(ULONG);
1042         *(HMETAFILE *)pBuffer = *phmf;
1043         pBuffer += sizeof(HMETAFILE);
1044     }
1045     else
1046     {
1047         *(ULONG *)pBuffer = WDT_REMOTE_CALL;
1048         pBuffer += sizeof(ULONG);
1049         *(ULONG *)pBuffer = (ULONG)(ULONG_PTR)*phmf;
1050         pBuffer += sizeof(ULONG);
1051
1052         if (*phmf)
1053         {
1054             UINT mfsize = GetMetaFileBitsEx(*phmf, 0, NULL);
1055
1056             *(ULONG *)pBuffer = mfsize;
1057             pBuffer += sizeof(ULONG);
1058             *(ULONG *)pBuffer = mfsize;
1059             pBuffer += sizeof(ULONG);
1060             GetMetaFileBitsEx(*phmf, mfsize, pBuffer);
1061             pBuffer += mfsize;
1062         }
1063     }
1064
1065     return pBuffer;
1066 }
1067
1068 /******************************************************************************
1069  *           HMETAFILE_UserUnmarshal [OLE32.@]
1070  *
1071  * Unmarshals a metafile from a buffer.
1072  *
1073  * PARAMS
1074  *  pFlags   [I] Flags. See notes.
1075  *  pBuffer  [I] Buffer to marshal the clip format from.
1076  *  phmf     [O] Address that receive the unmarshaled metafile.
1077  *
1078  * RETURNS
1079  *  The end of the marshaled data in the buffer.
1080  *
1081  * NOTES
1082  *  Even though the function is documented to take a pointer to an ULONG in
1083  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
1084  *  the first parameter is an ULONG.
1085  *  This function is only intended to be called by the RPC runtime.
1086  */
1087 unsigned char * __RPC_USER HMETAFILE_UserUnmarshal(ULONG *pFlags, unsigned char *pBuffer, HMETAFILE *phmf)
1088 {
1089     ULONG fContext;
1090
1091     TRACE("(%s, %p, %p\n", debugstr_user_flags(pFlags), pBuffer, phmf);
1092
1093     ALIGN_POINTER(pBuffer, 3);
1094
1095     fContext = *(ULONG *)pBuffer;
1096     pBuffer += sizeof(ULONG);
1097
1098     if (((fContext == WDT_INPROC_CALL) && (sizeof(*phmf) < 8)) ||
1099         ((fContext == WDT_INPROC64_CALL) && (sizeof(*phmf) == 8)))
1100     {
1101         *phmf = *(HMETAFILE *)pBuffer;
1102         pBuffer += sizeof(*phmf);
1103     }
1104     else if (fContext == WDT_REMOTE_CALL)
1105     {
1106         ULONG handle;
1107
1108         handle = *(ULONG *)pBuffer;
1109         pBuffer += sizeof(ULONG);
1110
1111         if (handle)
1112         {
1113             ULONG size;
1114             size = *(ULONG *)pBuffer;
1115             pBuffer += sizeof(ULONG);
1116             if (size != *(ULONG *)pBuffer)
1117             {
1118                 RaiseException(RPC_X_BAD_STUB_DATA, 0, 0, NULL);
1119                 return pBuffer;
1120             }
1121             pBuffer += sizeof(ULONG);
1122             *phmf = SetMetaFileBitsEx(size, pBuffer);
1123             pBuffer += size;
1124         }
1125         else
1126             *phmf = NULL;
1127     }
1128     else
1129         RaiseException(RPC_S_INVALID_TAG, 0, 0, NULL);
1130
1131     return pBuffer;
1132 }
1133
1134 /******************************************************************************
1135  *           HMETAFILE_UserFree [OLE32.@]
1136  *
1137  * Frees an unmarshaled metafile.
1138  *
1139  * PARAMS
1140  *  pFlags   [I] Flags. See notes.
1141  *  phmf     [I] Metafile to free.
1142  *
1143  * RETURNS
1144  *  The end of the marshaled data in the buffer.
1145  *
1146  * NOTES
1147  *  Even though the function is documented to take a pointer to a ULONG in
1148  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of
1149  *  which the first parameter is a ULONG.
1150  *  This function is only intended to be called by the RPC runtime.
1151  */
1152 void __RPC_USER HMETAFILE_UserFree(ULONG *pFlags, HMETAFILE *phmf)
1153 {
1154     TRACE("(%s, &%p\n", debugstr_user_flags(pFlags), *phmf);
1155
1156     if (LOWORD(*pFlags) != MSHCTX_INPROC)
1157         DeleteMetaFile(*phmf);
1158 }
1159
1160 /******************************************************************************
1161 *           HENHMETAFILE_UserSize [OLE32.@]
1162 *
1163 * Calculates the buffer size required to marshal an enhanced metafile.
1164 *
1165 * PARAMS
1166 *  pFlags       [I] Flags. See notes.
1167 *  StartingSize [I] Starting size of the buffer. This value is added on to
1168 *                   the buffer size required for the clip format.
1169 *  phEmf        [I] Enhanced metafile to size.
1170 *
1171 * RETURNS
1172 *  The buffer size required to marshal an enhanced metafile plus the starting size.
1173 *
1174 * NOTES
1175 *  Even though the function is documented to take a pointer to a ULONG in
1176 *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
1177 *  the first parameter is a ULONG.
1178 *  This function is only intended to be called by the RPC runtime.
1179 */
1180 ULONG __RPC_USER HENHMETAFILE_UserSize(ULONG *pFlags, ULONG StartingSize, HENHMETAFILE *phEmf)
1181 {
1182     ULONG size = StartingSize;
1183
1184     TRACE("(%s, %d, %p\n", debugstr_user_flags(pFlags), StartingSize, *phEmf);
1185
1186     size += sizeof(ULONG);
1187     if (LOWORD(*pFlags) == MSHCTX_INPROC)
1188         size += sizeof(ULONG_PTR);
1189     else
1190     {
1191         size += sizeof(ULONG);
1192
1193         if (*phEmf)
1194         {
1195             UINT emfsize;
1196     
1197             size += 2 * sizeof(ULONG);
1198             emfsize = GetEnhMetaFileBits(*phEmf, 0, NULL);
1199             size += emfsize;
1200         }
1201     }
1202
1203     return size;
1204 }
1205
1206 /******************************************************************************
1207  *           HENHMETAFILE_UserMarshal [OLE32.@]
1208  *
1209  * Marshals an enhance metafile into a buffer.
1210  *
1211  * PARAMS
1212  *  pFlags  [I] Flags. See notes.
1213  *  pBuffer [I] Buffer to marshal the clip format into.
1214  *  phEmf   [I] Enhanced metafile to marshal.
1215  *
1216  * RETURNS
1217  *  The end of the marshaled data in the buffer.
1218  *
1219  * NOTES
1220  *  Even though the function is documented to take a pointer to a ULONG in
1221  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
1222  *  the first parameter is a ULONG.
1223  *  This function is only intended to be called by the RPC runtime.
1224  */
1225 unsigned char * __RPC_USER HENHMETAFILE_UserMarshal(ULONG *pFlags, unsigned char *pBuffer, HENHMETAFILE *phEmf)
1226 {
1227     TRACE("(%s, %p, &%p\n", debugstr_user_flags(pFlags), pBuffer, *phEmf);
1228
1229     if (LOWORD(*pFlags) == MSHCTX_INPROC)
1230     {
1231         if (sizeof(*phEmf) == 8)
1232             *(ULONG *)pBuffer = WDT_INPROC64_CALL;
1233         else
1234             *(ULONG *)pBuffer = WDT_INPROC_CALL;
1235         pBuffer += sizeof(ULONG);
1236         *(HENHMETAFILE *)pBuffer = *phEmf;
1237         pBuffer += sizeof(HENHMETAFILE);
1238     }
1239     else
1240     {
1241         *(ULONG *)pBuffer = WDT_REMOTE_CALL;
1242         pBuffer += sizeof(ULONG);
1243         *(ULONG *)pBuffer = (ULONG)(ULONG_PTR)*phEmf;
1244         pBuffer += sizeof(ULONG);
1245     
1246         if (*phEmf)
1247         {
1248             UINT emfsize = GetEnhMetaFileBits(*phEmf, 0, NULL);
1249     
1250             *(ULONG *)pBuffer = emfsize;
1251             pBuffer += sizeof(ULONG);
1252             *(ULONG *)pBuffer = emfsize;
1253             pBuffer += sizeof(ULONG);
1254             GetEnhMetaFileBits(*phEmf, emfsize, pBuffer);
1255             pBuffer += emfsize;
1256         }
1257     }
1258
1259     return pBuffer;
1260 }
1261
1262 /******************************************************************************
1263  *           HENHMETAFILE_UserUnmarshal [OLE32.@]
1264  *
1265  * Unmarshals an enhanced metafile from a buffer.
1266  *
1267  * PARAMS
1268  *  pFlags   [I] Flags. See notes.
1269  *  pBuffer  [I] Buffer to marshal the clip format from.
1270  *  phEmf    [O] Address that receive the unmarshaled enhanced metafile.
1271  *
1272  * RETURNS
1273  *  The end of the marshaled data in the buffer.
1274  *
1275  * NOTES
1276  *  Even though the function is documented to take a pointer to an ULONG in
1277  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
1278  *  the first parameter is an ULONG.
1279  *  This function is only intended to be called by the RPC runtime.
1280  */
1281 unsigned char * __RPC_USER HENHMETAFILE_UserUnmarshal(ULONG *pFlags, unsigned char *pBuffer, HENHMETAFILE *phEmf)
1282 {
1283     ULONG fContext;
1284
1285     TRACE("(%s, %p, %p\n", debugstr_user_flags(pFlags), pBuffer, phEmf);
1286
1287     fContext = *(ULONG *)pBuffer;
1288     pBuffer += sizeof(ULONG);
1289
1290     if (((fContext == WDT_INPROC_CALL) && (sizeof(*phEmf) < 8)) ||
1291         ((fContext == WDT_INPROC64_CALL) && (sizeof(*phEmf) == 8)))
1292     {
1293         *phEmf = *(HENHMETAFILE *)pBuffer;
1294         pBuffer += sizeof(*phEmf);
1295     }
1296     else if (fContext == WDT_REMOTE_CALL)
1297     {
1298         ULONG handle;
1299
1300         handle = *(ULONG *)pBuffer;
1301         pBuffer += sizeof(ULONG);
1302
1303         if (handle)
1304         {
1305             ULONG size;
1306             size = *(ULONG *)pBuffer;
1307             pBuffer += sizeof(ULONG);
1308             if (size != *(ULONG *)pBuffer)
1309             {
1310                 RaiseException(RPC_X_BAD_STUB_DATA, 0, 0, NULL);
1311                 return pBuffer;
1312             }
1313             pBuffer += sizeof(ULONG);
1314             *phEmf = SetEnhMetaFileBits(size, pBuffer);
1315             pBuffer += size;
1316         }
1317         else 
1318             *phEmf = NULL;
1319     }
1320     else
1321         RaiseException(RPC_S_INVALID_TAG, 0, 0, NULL);
1322
1323     return pBuffer;
1324 }
1325
1326 /******************************************************************************
1327  *           HENHMETAFILE_UserFree [OLE32.@]
1328  *
1329  * Frees an unmarshaled enhanced metafile.
1330  *
1331  * PARAMS
1332  *  pFlags   [I] Flags. See notes.
1333  *  phEmf    [I] Enhanced metafile to free.
1334  *
1335  * RETURNS
1336  *  The end of the marshaled data in the buffer.
1337  *
1338  * NOTES
1339  *  Even though the function is documented to take a pointer to a ULONG in
1340  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of
1341  *  which the first parameter is a ULONG.
1342  *  This function is only intended to be called by the RPC runtime.
1343  */
1344 void __RPC_USER HENHMETAFILE_UserFree(ULONG *pFlags, HENHMETAFILE *phEmf)
1345 {
1346     TRACE("(%s, &%p\n", debugstr_user_flags(pFlags), *phEmf);
1347
1348     if (LOWORD(*pFlags) != MSHCTX_INPROC)
1349         DeleteEnhMetaFile(*phEmf);
1350 }
1351
1352 /******************************************************************************
1353  *           HMETAFILEPICT_UserSize [OLE32.@]
1354  *
1355  * Calculates the buffer size required to marshal an metafile pict.
1356  *
1357  * PARAMS
1358  *  pFlags       [I] Flags. See notes.
1359  *  StartingSize [I] Starting size of the buffer. This value is added on to
1360  *                   the buffer size required for the clip format.
1361  *  phMfp        [I] Metafile pict to size.
1362  *
1363  * RETURNS
1364  *  The buffer size required to marshal a metafile pict plus the starting size.
1365  *
1366  * NOTES
1367  *  Even though the function is documented to take a pointer to a ULONG in
1368  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
1369  *  the first parameter is a ULONG.
1370  *  This function is only intended to be called by the RPC runtime.
1371  */
1372 ULONG __RPC_USER HMETAFILEPICT_UserSize(ULONG *pFlags, ULONG StartingSize, HMETAFILEPICT *phMfp)
1373 {
1374     ULONG size = StartingSize;
1375
1376     TRACE("(%s, %d, &%p)\n", debugstr_user_flags(pFlags), StartingSize, *phMfp);
1377
1378     size += sizeof(ULONG);
1379
1380     if(LOWORD(*pFlags) == MSHCTX_INPROC)
1381         size += sizeof(HMETAFILEPICT);
1382     else
1383     {
1384         size += sizeof(ULONG);
1385
1386         if (*phMfp)
1387         {
1388             METAFILEPICT *mfpict = GlobalLock(*phMfp);
1389
1390             /* FIXME: raise an exception if mfpict is NULL? */
1391             size += 3 * sizeof(ULONG);
1392             size += sizeof(ULONG);
1393
1394             size = HMETAFILE_UserSize(pFlags, size, &mfpict->hMF);
1395
1396             GlobalUnlock(*phMfp);
1397         }
1398     }
1399
1400     return size;
1401 }
1402
1403 /******************************************************************************
1404  *           HMETAFILEPICT_UserMarshal [OLE32.@]
1405  *
1406  * Marshals a metafile pict into a buffer.
1407  *
1408  * PARAMS
1409  *  pFlags  [I] Flags. See notes.
1410  *  pBuffer [I] Buffer to marshal the clip format into.
1411  *  phMfp   [I] Metafile pict to marshal.
1412  *
1413  * RETURNS
1414  *  The end of the marshaled data in the buffer.
1415  *
1416  * NOTES
1417  *  Even though the function is documented to take a pointer to a ULONG in
1418  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
1419  *  the first parameter is a ULONG.
1420  *  This function is only intended to be called by the RPC runtime.
1421  */
1422 unsigned char * __RPC_USER HMETAFILEPICT_UserMarshal(ULONG *pFlags, unsigned char *pBuffer, HMETAFILEPICT *phMfp)
1423 {
1424     TRACE("(%s, %p, &%p)\n", debugstr_user_flags(pFlags), pBuffer, *phMfp);
1425
1426     if (LOWORD(*pFlags) == MSHCTX_INPROC)
1427     {
1428         if (sizeof(HMETAFILEPICT) == 8)
1429             *(ULONG *)pBuffer = WDT_INPROC64_CALL;
1430         else
1431             *(ULONG *)pBuffer = WDT_INPROC_CALL;
1432         pBuffer += sizeof(ULONG);
1433         *(HMETAFILEPICT *)pBuffer = *phMfp;
1434         pBuffer += sizeof(HMETAFILEPICT);
1435     }
1436     else
1437     {
1438         *(ULONG *)pBuffer = WDT_REMOTE_CALL;
1439         pBuffer += sizeof(ULONG);
1440         *(ULONG *)pBuffer = (ULONG)(ULONG_PTR)*phMfp;
1441         pBuffer += sizeof(ULONG);
1442
1443         if (*phMfp)
1444         {
1445             METAFILEPICT *mfpict = GlobalLock(*phMfp);
1446             remoteMETAFILEPICT * remmfpict = (remoteMETAFILEPICT *)pBuffer;
1447
1448             /* FIXME: raise an exception if mfpict is NULL? */
1449             remmfpict->mm = mfpict->mm;
1450             remmfpict->xExt = mfpict->xExt;
1451             remmfpict->yExt = mfpict->yExt;
1452             pBuffer += 3 * sizeof(ULONG);
1453             *(ULONG *)pBuffer = USER_MARSHAL_PTR_PREFIX;
1454             pBuffer += sizeof(ULONG);
1455
1456             pBuffer = HMETAFILE_UserMarshal(pFlags, pBuffer, &mfpict->hMF);
1457
1458             GlobalUnlock(*phMfp);
1459         }
1460     }
1461     return pBuffer;
1462 }
1463
1464 /******************************************************************************
1465  *           HMETAFILEPICT_UserUnmarshal [OLE32.@]
1466  *
1467  * Unmarshals an metafile pict from a buffer.
1468  *
1469  * PARAMS
1470  *  pFlags   [I] Flags. See notes.
1471  *  pBuffer  [I] Buffer to marshal the clip format from.
1472  *  phMfp    [O] Address that receive the unmarshaled metafile pict.
1473  *
1474  * RETURNS
1475  *  The end of the marshaled data in the buffer.
1476  *
1477  * NOTES
1478  *  Even though the function is documented to take a pointer to an ULONG in
1479  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
1480  *  the first parameter is an ULONG.
1481  *  This function is only intended to be called by the RPC runtime.
1482  */
1483 unsigned char * __RPC_USER HMETAFILEPICT_UserUnmarshal(ULONG *pFlags, unsigned char *pBuffer, HMETAFILEPICT *phMfp)
1484 {
1485     ULONG fContext;
1486
1487     TRACE("(%s, %p, %p)\n", debugstr_user_flags(pFlags), pBuffer, phMfp);
1488
1489     fContext = *(ULONG *)pBuffer;
1490     pBuffer += sizeof(ULONG);
1491
1492     if ((fContext == WDT_INPROC_CALL) || fContext == WDT_INPROC64_CALL)
1493     {
1494         *phMfp = *(HMETAFILEPICT *)pBuffer;
1495         pBuffer += sizeof(HMETAFILEPICT);
1496     }
1497     else
1498     {
1499         ULONG handle = *(ULONG *)pBuffer;
1500         pBuffer += sizeof(ULONG);
1501         *phMfp = NULL;
1502
1503         if(handle)
1504         {
1505             METAFILEPICT *mfpict;
1506             const remoteMETAFILEPICT *remmfpict;
1507             ULONG user_marshal_prefix;
1508
1509             remmfpict = (const remoteMETAFILEPICT *)pBuffer;
1510
1511             *phMfp = GlobalAlloc(GMEM_MOVEABLE, sizeof(METAFILEPICT));
1512             if (!*phMfp)
1513                 RpcRaiseException(E_OUTOFMEMORY);
1514
1515             mfpict = GlobalLock(*phMfp);
1516             mfpict->mm = remmfpict->mm;
1517             mfpict->xExt = remmfpict->xExt;
1518             mfpict->yExt = remmfpict->yExt;
1519             pBuffer += 3 * sizeof(ULONG);
1520             user_marshal_prefix = *(ULONG *)pBuffer;
1521             pBuffer += sizeof(ULONG);
1522
1523             if (user_marshal_prefix != USER_MARSHAL_PTR_PREFIX)
1524                 RpcRaiseException(RPC_X_INVALID_TAG);
1525
1526             pBuffer = HMETAFILE_UserUnmarshal(pFlags, pBuffer, &mfpict->hMF);
1527
1528             GlobalUnlock(*phMfp);
1529         }
1530     }
1531     return pBuffer;
1532 }
1533
1534 /******************************************************************************
1535  *           HMETAFILEPICT_UserFree [OLE32.@]
1536  *
1537  * Frees an unmarshaled metafile pict.
1538  *
1539  * PARAMS
1540  *  pFlags   [I] Flags. See notes.
1541  *  phMfp    [I] Metafile pict to free.
1542  *
1543  * RETURNS
1544  *  The end of the marshaled data in the buffer.
1545  *
1546  * NOTES
1547  *  Even though the function is documented to take a pointer to a ULONG in
1548  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of
1549  *  which the first parameter is a ULONG.
1550  *  This function is only intended to be called by the RPC runtime.
1551  */
1552 void __RPC_USER HMETAFILEPICT_UserFree(ULONG *pFlags, HMETAFILEPICT *phMfp)
1553 {
1554     TRACE("(%s, &%p)\n", debugstr_user_flags(pFlags), *phMfp);
1555
1556     if ((LOWORD(*pFlags) != MSHCTX_INPROC) && *phMfp)
1557     {
1558         METAFILEPICT *mfpict;
1559
1560         mfpict = GlobalLock(*phMfp);
1561         /* FIXME: raise an exception if mfpict is NULL? */
1562         HMETAFILE_UserFree(pFlags, &mfpict->hMF);
1563         GlobalUnlock(*phMfp);
1564
1565         GlobalFree(*phMfp);
1566     }
1567 }
1568
1569 /******************************************************************************
1570  *           WdtpInterfacePointer_UserSize [OLE32.@]
1571  *
1572  * Calculates the buffer size required to marshal an interface pointer.
1573  *
1574  * PARAMS
1575  *  pFlags       [I] Flags. See notes.
1576  *  RealFlags    [I] The MSHCTX to use when marshaling the interface.
1577  *  punk         [I] Interface pointer to size.
1578  *  StartingSize [I] Starting size of the buffer. This value is added on to
1579  *                   the buffer size required for the clip format.
1580  *  riid         [I] ID of interface to size.
1581  *
1582  * RETURNS
1583  *  The buffer size required to marshal an interface pointer plus the starting size.
1584  *
1585  * NOTES
1586  *  Even though the function is documented to take a pointer to a ULONG in
1587  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
1588  *  the first parameter is a ULONG.
1589  */
1590 ULONG __RPC_USER WdtpInterfacePointer_UserSize(ULONG *pFlags, ULONG RealFlags, ULONG StartingSize, IUnknown *punk, REFIID riid)
1591 {
1592     DWORD marshal_size = 0;
1593     HRESULT hr;
1594
1595     TRACE("(%s, 0%x, %d, %p, %s)\n", debugstr_user_flags(pFlags), RealFlags, StartingSize, punk, debugstr_guid(riid));
1596
1597     hr = CoGetMarshalSizeMax(&marshal_size, riid, punk, LOWORD(RealFlags), NULL, MSHLFLAGS_NORMAL);
1598     if(FAILED(hr)) return StartingSize;
1599
1600     ALIGN_LENGTH(StartingSize, 3);
1601     StartingSize += 2 * sizeof(DWORD);
1602     return StartingSize + marshal_size;
1603 }
1604
1605 /******************************************************************************
1606  *           WdtpInterfacePointer_UserMarshal [OLE32.@]
1607  *
1608  * Marshals an interface pointer into a buffer.
1609  *
1610  * PARAMS
1611  *  pFlags    [I] Flags. See notes.
1612  *  RealFlags [I] The MSHCTX to use when marshaling the interface.
1613  *  pBuffer   [I] Buffer to marshal the clip format into.
1614  *  punk      [I] Interface pointer to marshal.
1615  *  riid      [I] ID of interface to marshal.
1616  *
1617  * RETURNS
1618  *  The end of the marshaled data in the buffer.
1619  *
1620  * NOTES
1621  *  Even though the function is documented to take a pointer to a ULONG in
1622  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
1623  *  the first parameter is a ULONG.
1624  */
1625 unsigned char * WINAPI WdtpInterfacePointer_UserMarshal(ULONG *pFlags, ULONG RealFlags, unsigned char *pBuffer, IUnknown *punk, REFIID riid)
1626 {
1627     HGLOBAL h = GlobalAlloc(GMEM_MOVEABLE, 0);
1628     IStream *stm;
1629     DWORD size;
1630     void *ptr;
1631
1632     TRACE("(%s, 0x%x, %p, &%p, %s)\n", debugstr_user_flags(pFlags), RealFlags, pBuffer, punk, debugstr_guid(riid));
1633
1634     if(!h) return NULL;
1635     if(CreateStreamOnHGlobal(h, TRUE, &stm) != S_OK)
1636     {
1637         GlobalFree(h);
1638         return NULL;
1639     }
1640
1641     if(CoMarshalInterface(stm, riid, punk, LOWORD(RealFlags), NULL, MSHLFLAGS_NORMAL) != S_OK)
1642     {
1643         IStream_Release(stm);
1644         return NULL;
1645     }
1646
1647     ALIGN_POINTER(pBuffer, 3);
1648     size = GlobalSize(h);
1649
1650     *(DWORD *)pBuffer = size;
1651     pBuffer += sizeof(DWORD);
1652     *(DWORD *)pBuffer = size;
1653     pBuffer += sizeof(DWORD);
1654
1655     ptr = GlobalLock(h);
1656     memcpy(pBuffer, ptr, size);
1657     GlobalUnlock(h);
1658
1659     IStream_Release(stm);
1660     return pBuffer + size;
1661 }
1662
1663 /******************************************************************************
1664  *           WdtpInterfacePointer_UserUnmarshal [OLE32.@]
1665  *
1666  * Unmarshals an interface pointer from a buffer.
1667  *
1668  * PARAMS
1669  *  pFlags   [I] Flags. See notes.
1670  *  pBuffer  [I] Buffer to marshal the clip format from.
1671  *  ppunk    [I/O] Address that receives the unmarshaled interface pointer.
1672  *  riid     [I] ID of interface to unmarshal.
1673  *
1674  * RETURNS
1675  *  The end of the marshaled data in the buffer.
1676  *
1677  * NOTES
1678  *  Even though the function is documented to take a pointer to an ULONG in
1679  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
1680  *  the first parameter is an ULONG.
1681  */
1682 unsigned char * WINAPI WdtpInterfacePointer_UserUnmarshal(ULONG *pFlags, unsigned char *pBuffer, IUnknown **ppunk, REFIID riid)
1683 {
1684     HRESULT hr;
1685     HGLOBAL h;
1686     IStream *stm;
1687     DWORD size;
1688     void *ptr;
1689
1690     TRACE("(%s, %p, %p, %s)\n", debugstr_user_flags(pFlags), pBuffer, ppunk, debugstr_guid(riid));
1691
1692     ALIGN_POINTER(pBuffer, 3);
1693
1694     size = *(DWORD *)pBuffer;
1695     pBuffer += sizeof(DWORD);
1696     if(size != *(DWORD *)pBuffer)
1697         RaiseException(RPC_X_BAD_STUB_DATA, 0, 0, NULL);
1698
1699     pBuffer += sizeof(DWORD);
1700
1701     /* FIXME: sanity check on size */
1702
1703     h = GlobalAlloc(GMEM_MOVEABLE, size);
1704     if(!h) RaiseException(RPC_X_NO_MEMORY, 0, 0, NULL);
1705
1706     if(CreateStreamOnHGlobal(h, TRUE, &stm) != S_OK)
1707     {
1708         GlobalFree(h);
1709         RaiseException(RPC_X_NO_MEMORY, 0, 0, NULL);
1710     }
1711
1712     ptr = GlobalLock(h);
1713     memcpy(ptr, pBuffer, size);
1714     GlobalUnlock(h);
1715
1716     hr = CoUnmarshalInterface(stm, riid, (void**)ppunk);
1717     IStream_Release(stm);
1718
1719     if(hr != S_OK) RaiseException(hr, 0, 0, NULL);
1720
1721     return pBuffer + size;
1722 }
1723
1724 /******************************************************************************
1725  *           WdtpInterfacePointer_UserFree [OLE32.@]
1726  *
1727  * Releases an unmarshaled interface pointer.
1728  *
1729  * PARAMS
1730  *  punk    [I] Interface pointer to release.
1731  *
1732  * RETURNS
1733  *  Nothing.
1734  */
1735 void WINAPI WdtpInterfacePointer_UserFree(IUnknown *punk)
1736 {
1737     TRACE("(%p)\n", punk);
1738     if(punk) IUnknown_Release(punk);
1739 }
1740
1741 /******************************************************************************
1742 *           STGMEDIUM_UserSize [OLE32.@]
1743 *
1744 * Calculates the buffer size required to marshal an STGMEDIUM.
1745 *
1746 * PARAMS
1747 *  pFlags       [I] Flags. See notes.
1748 *  StartingSize [I] Starting size of the buffer. This value is added on to
1749 *                   the buffer size required for the clip format.
1750 *  pStgMedium   [I] STGMEDIUM to size.
1751 *
1752 * RETURNS
1753 *  The buffer size required to marshal an STGMEDIUM plus the starting size.
1754 *
1755 * NOTES
1756 *  Even though the function is documented to take a pointer to a ULONG in
1757 *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
1758 *  the first parameter is a ULONG.
1759 *  This function is only intended to be called by the RPC runtime.
1760 */
1761 ULONG __RPC_USER STGMEDIUM_UserSize(ULONG *pFlags, ULONG StartingSize, STGMEDIUM *pStgMedium)
1762 {
1763     ULONG size = StartingSize;
1764
1765     TRACE("(%s, %d, %p\n", debugstr_user_flags(pFlags), StartingSize, pStgMedium);
1766
1767     ALIGN_LENGTH(size, 3);
1768
1769     size += 2 * sizeof(DWORD);
1770     if (pStgMedium->tymed != TYMED_NULL)
1771         size += sizeof(DWORD);
1772
1773     switch (pStgMedium->tymed)
1774     {
1775     case TYMED_NULL:
1776         TRACE("TYMED_NULL\n");
1777         break;
1778     case TYMED_HGLOBAL:
1779         TRACE("TYMED_HGLOBAL\n");
1780         if (pStgMedium->u.hGlobal)
1781             size = HGLOBAL_UserSize(pFlags, size, &pStgMedium->u.hGlobal);
1782         break;
1783     case TYMED_FILE:
1784         TRACE("TYMED_FILE\n");
1785         if (pStgMedium->u.lpszFileName)
1786         {
1787             TRACE("file name is %s\n", debugstr_w(pStgMedium->u.lpszFileName));
1788             size += 3 * sizeof(DWORD) +
1789                 (strlenW(pStgMedium->u.lpszFileName) + 1) * sizeof(WCHAR);
1790         }
1791         break;
1792     case TYMED_ISTREAM:
1793         TRACE("TYMED_ISTREAM\n");
1794         if (pStgMedium->u.pstm)
1795         {
1796             IUnknown *unk;
1797             IStream_QueryInterface(pStgMedium->u.pstm, &IID_IUnknown, (void**)&unk);
1798             size = WdtpInterfacePointer_UserSize(pFlags, LOWORD(*pFlags), size, unk, &IID_IStream);
1799             IUnknown_Release(unk);
1800         }
1801         break;
1802     case TYMED_ISTORAGE:
1803         TRACE("TYMED_ISTORAGE\n");
1804         if (pStgMedium->u.pstg)
1805         {
1806             IUnknown *unk;
1807             IStorage_QueryInterface(pStgMedium->u.pstg, &IID_IUnknown, (void**)&unk);
1808             size = WdtpInterfacePointer_UserSize(pFlags, LOWORD(*pFlags), size, unk, &IID_IStorage);
1809             IUnknown_Release(unk);
1810         }
1811         break;
1812     case TYMED_GDI:
1813         TRACE("TYMED_GDI\n");
1814         if (pStgMedium->u.hBitmap)
1815         {
1816             FIXME("not implemented for GDI object %p\n", pStgMedium->u.hBitmap);
1817         }
1818         break;
1819     case TYMED_MFPICT:
1820         TRACE("TYMED_MFPICT\n");
1821         if (pStgMedium->u.hMetaFilePict)
1822             size = HMETAFILEPICT_UserSize(pFlags, size, &pStgMedium->u.hMetaFilePict);
1823         break;
1824     case TYMED_ENHMF:
1825         TRACE("TYMED_ENHMF\n");
1826         if (pStgMedium->u.hEnhMetaFile)
1827             size = HENHMETAFILE_UserSize(pFlags, size, &pStgMedium->u.hEnhMetaFile);
1828         break;
1829     default:
1830         RaiseException(DV_E_TYMED, 0, 0, NULL);
1831     }
1832
1833     if (pStgMedium->pUnkForRelease)
1834         size = WdtpInterfacePointer_UserSize(pFlags, LOWORD(*pFlags), size, pStgMedium->pUnkForRelease, &IID_IUnknown);
1835
1836     return size;
1837 }
1838
1839 /******************************************************************************
1840  *           STGMEDIUM_UserMarshal [OLE32.@]
1841  *
1842  * Marshals a STGMEDIUM into a buffer.
1843  *
1844  * PARAMS
1845  *  pFlags  [I] Flags. See notes.
1846  *  pBuffer [I] Buffer to marshal the clip format into.
1847  *  pCF     [I] STGMEDIUM to marshal.
1848  *
1849  * RETURNS
1850  *  The end of the marshaled data in the buffer.
1851  *
1852  * NOTES
1853  *  Even though the function is documented to take a pointer to a ULONG in
1854  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
1855  *  the first parameter is a ULONG.
1856  *  This function is only intended to be called by the RPC runtime.
1857  */
1858 unsigned char * __RPC_USER STGMEDIUM_UserMarshal(ULONG *pFlags, unsigned char *pBuffer, STGMEDIUM *pStgMedium)
1859 {
1860     TRACE("(%s, %p, %p\n", debugstr_user_flags(pFlags), pBuffer, pStgMedium);
1861
1862     ALIGN_POINTER(pBuffer, 3);
1863
1864     *(DWORD *)pBuffer = pStgMedium->tymed;
1865     pBuffer += sizeof(DWORD);
1866     if (pStgMedium->tymed != TYMED_NULL)
1867     {
1868         *(DWORD *)pBuffer = (DWORD)(DWORD_PTR)pStgMedium->u.pstg;
1869         pBuffer += sizeof(DWORD);
1870     }
1871     *(DWORD *)pBuffer = (DWORD)(DWORD_PTR)pStgMedium->pUnkForRelease;
1872     pBuffer += sizeof(DWORD);
1873
1874     switch (pStgMedium->tymed)
1875     {
1876     case TYMED_NULL:
1877         TRACE("TYMED_NULL\n");
1878         break;
1879     case TYMED_HGLOBAL:
1880         TRACE("TYMED_HGLOBAL\n");
1881         if (pStgMedium->u.hGlobal)
1882             pBuffer = HGLOBAL_UserMarshal(pFlags, pBuffer, &pStgMedium->u.hGlobal);
1883         break;
1884     case TYMED_FILE:
1885         TRACE("TYMED_FILE\n");
1886         if (pStgMedium->u.lpszFileName)
1887         {
1888             DWORD len;
1889             len = strlenW(pStgMedium->u.lpszFileName);
1890             /* conformance */
1891             *(DWORD *)pBuffer = len + 1;
1892             pBuffer += sizeof(DWORD);
1893             /* offset */
1894             *(DWORD *)pBuffer = 0;
1895             pBuffer += sizeof(DWORD);
1896             /* variance */
1897             *(DWORD *)pBuffer = len + 1;
1898             pBuffer += sizeof(DWORD);
1899
1900             TRACE("file name is %s\n", debugstr_w(pStgMedium->u.lpszFileName));
1901             memcpy(pBuffer, pStgMedium->u.lpszFileName, (len + 1) * sizeof(WCHAR));
1902         }
1903         break;
1904     case TYMED_ISTREAM:
1905         TRACE("TYMED_ISTREAM\n");
1906         if (pStgMedium->u.pstm)
1907         {
1908             IUnknown *unk;
1909             IStream_QueryInterface(pStgMedium->u.pstm, &IID_IUnknown, (void**)&unk);
1910             pBuffer = WdtpInterfacePointer_UserMarshal(pFlags, LOWORD(*pFlags), pBuffer, unk, &IID_IStream);
1911             IUnknown_Release(unk);
1912         }
1913         break;
1914     case TYMED_ISTORAGE:
1915         TRACE("TYMED_ISTORAGE\n");
1916         if (pStgMedium->u.pstg)
1917         {
1918             IUnknown *unk;
1919             IStorage_QueryInterface(pStgMedium->u.pstg, &IID_IUnknown, (void**)&unk);
1920             pBuffer = WdtpInterfacePointer_UserMarshal(pFlags, LOWORD(*pFlags), pBuffer, unk, &IID_IStorage);
1921             IUnknown_Release(unk);
1922         }
1923         break;
1924     case TYMED_GDI:
1925         TRACE("TYMED_GDI\n");
1926         if (pStgMedium->u.hBitmap)
1927         {
1928             FIXME("not implemented for GDI object %p\n", pStgMedium->u.hBitmap);
1929         }
1930         break;
1931     case TYMED_MFPICT:
1932         TRACE("TYMED_MFPICT\n");
1933         if (pStgMedium->u.hMetaFilePict)
1934             pBuffer = HMETAFILEPICT_UserMarshal(pFlags, pBuffer, &pStgMedium->u.hMetaFilePict);
1935         break;
1936     case TYMED_ENHMF:
1937         TRACE("TYMED_ENHMF\n");
1938         if (pStgMedium->u.hEnhMetaFile)
1939             pBuffer = HENHMETAFILE_UserMarshal(pFlags, pBuffer, &pStgMedium->u.hEnhMetaFile);
1940         break;
1941     default:
1942         RaiseException(DV_E_TYMED, 0, 0, NULL);
1943     }
1944
1945     if (pStgMedium->pUnkForRelease)
1946         pBuffer = WdtpInterfacePointer_UserMarshal(pFlags, LOWORD(*pFlags), pBuffer, pStgMedium->pUnkForRelease, &IID_IUnknown);
1947
1948     return pBuffer;
1949 }
1950
1951 /******************************************************************************
1952  *           STGMEDIUM_UserUnmarshal [OLE32.@]
1953  *
1954  * Unmarshals a STGMEDIUM from a buffer.
1955  *
1956  * PARAMS
1957  *  pFlags     [I] Flags. See notes.
1958  *  pBuffer    [I] Buffer to marshal the clip format from.
1959  *  pStgMedium [O] Address that receive the unmarshaled STGMEDIUM.
1960  *
1961  * RETURNS
1962  *  The end of the marshaled data in the buffer.
1963  *
1964  * NOTES
1965  *  Even though the function is documented to take a pointer to an ULONG in
1966  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of which
1967  *  the first parameter is an ULONG.
1968  *  This function is only intended to be called by the RPC runtime.
1969  */
1970 unsigned char * __RPC_USER STGMEDIUM_UserUnmarshal(ULONG *pFlags, unsigned char *pBuffer, STGMEDIUM *pStgMedium)
1971 {
1972     DWORD content = 0;
1973     DWORD releaseunk;
1974
1975     ALIGN_POINTER(pBuffer, 3);
1976
1977     TRACE("(%s, %p, %p\n", debugstr_user_flags(pFlags), pBuffer, pStgMedium);
1978
1979     pStgMedium->tymed = *(DWORD *)pBuffer;
1980     pBuffer += sizeof(DWORD);
1981     if (pStgMedium->tymed != TYMED_NULL)
1982     {
1983         content = *(DWORD *)pBuffer;
1984         pBuffer += sizeof(DWORD);
1985     }
1986     releaseunk = *(DWORD *)pBuffer;
1987     pBuffer += sizeof(DWORD);
1988
1989     switch (pStgMedium->tymed)
1990     {
1991     case TYMED_NULL:
1992         TRACE("TYMED_NULL\n");
1993         break;
1994     case TYMED_HGLOBAL:
1995         TRACE("TYMED_HGLOBAL\n");
1996         if (content)
1997             pBuffer = HGLOBAL_UserUnmarshal(pFlags, pBuffer, &pStgMedium->u.hGlobal);
1998         break;
1999     case TYMED_FILE:
2000         TRACE("TYMED_FILE\n");
2001         if (content)
2002         {
2003             DWORD conformance;
2004             DWORD variance;
2005             conformance = *(DWORD *)pBuffer;
2006             pBuffer += sizeof(DWORD);
2007             if (*(DWORD *)pBuffer != 0)
2008             {
2009                 ERR("invalid offset %d\n", *(DWORD *)pBuffer);
2010                 RpcRaiseException(RPC_S_INVALID_BOUND);
2011                 return NULL;
2012             }
2013             pBuffer += sizeof(DWORD);
2014             variance = *(DWORD *)pBuffer;
2015             pBuffer += sizeof(DWORD);
2016             if (conformance != variance)
2017             {
2018                 ERR("conformance (%d) and variance (%d) should be equal\n",
2019                     conformance, variance);
2020                 RpcRaiseException(RPC_S_INVALID_BOUND);
2021                 return NULL;
2022             }
2023             if (conformance > 0x7fffffff)
2024             {
2025                 ERR("conformance 0x%x too large\n", conformance);
2026                 RpcRaiseException(RPC_S_INVALID_BOUND);
2027                 return NULL;
2028             }
2029             pStgMedium->u.lpszFileName = CoTaskMemAlloc(conformance * sizeof(WCHAR));
2030             if (!pStgMedium->u.lpszFileName) RpcRaiseException(ERROR_OUTOFMEMORY);
2031             TRACE("unmarshalled file name is %s\n", debugstr_wn((const WCHAR *)pBuffer, variance));
2032             memcpy(pStgMedium->u.lpszFileName, pBuffer, variance * sizeof(WCHAR));
2033             pBuffer += variance * sizeof(WCHAR);
2034         }
2035         else
2036             pStgMedium->u.lpszFileName = NULL;
2037         break;
2038     case TYMED_ISTREAM:
2039         TRACE("TYMED_ISTREAM\n");
2040         if (content)
2041         {
2042             pBuffer = WdtpInterfacePointer_UserUnmarshal(pFlags, pBuffer, (IUnknown**)&pStgMedium->u.pstm, &IID_IStream);
2043         }
2044         else
2045             pStgMedium->u.pstm = NULL;
2046         break;
2047     case TYMED_ISTORAGE:
2048         TRACE("TYMED_ISTORAGE\n");
2049         if (content)
2050         {
2051             pBuffer = WdtpInterfacePointer_UserUnmarshal(pFlags, pBuffer, (IUnknown**)&pStgMedium->u.pstg, &IID_IStorage);
2052         }
2053         else
2054             pStgMedium->u.pstg = NULL;
2055         break;
2056     case TYMED_GDI:
2057         TRACE("TYMED_GDI\n");
2058         if (content)
2059         {
2060             FIXME("not implemented for GDI object\n");
2061         }
2062         else
2063             pStgMedium->u.hBitmap = NULL;
2064         break;
2065     case TYMED_MFPICT:
2066         TRACE("TYMED_MFPICT\n");
2067         if (content)
2068             pBuffer = HMETAFILEPICT_UserUnmarshal(pFlags, pBuffer, &pStgMedium->u.hMetaFilePict);
2069         else
2070             pStgMedium->u.hMetaFilePict = NULL;
2071         break;
2072     case TYMED_ENHMF:
2073         TRACE("TYMED_ENHMF\n");
2074         if (content)
2075             pBuffer = HENHMETAFILE_UserUnmarshal(pFlags, pBuffer, &pStgMedium->u.hEnhMetaFile);
2076         else
2077             pStgMedium->u.hEnhMetaFile = NULL;
2078         break;
2079     default:
2080         RaiseException(DV_E_TYMED, 0, 0, NULL);
2081     }
2082
2083     pStgMedium->pUnkForRelease = NULL;
2084     if (releaseunk)
2085         pBuffer = WdtpInterfacePointer_UserUnmarshal(pFlags, pBuffer, &pStgMedium->pUnkForRelease, &IID_IUnknown);
2086
2087     return pBuffer;
2088 }
2089
2090 /******************************************************************************
2091  *           STGMEDIUM_UserFree [OLE32.@]
2092  *
2093  * Frees an unmarshaled STGMEDIUM.
2094  *
2095  * PARAMS
2096  *  pFlags     [I] Flags. See notes.
2097  *  pStgmedium [I] STGMEDIUM to free.
2098  *
2099  * RETURNS
2100  *  The end of the marshaled data in the buffer.
2101  *
2102  * NOTES
2103  *  Even though the function is documented to take a pointer to a ULONG in
2104  *  pFlags, it actually takes a pointer to a USER_MARSHAL_CB structure, of
2105  *  which the first parameter is a ULONG.
2106  *  This function is only intended to be called by the RPC runtime.
2107  */
2108 void __RPC_USER STGMEDIUM_UserFree(ULONG *pFlags, STGMEDIUM *pStgMedium)
2109 {
2110     TRACE("(%s, %p\n", debugstr_user_flags(pFlags), pStgMedium);
2111
2112     ReleaseStgMedium(pStgMedium);
2113 }
2114
2115 ULONG __RPC_USER ASYNC_STGMEDIUM_UserSize(ULONG *pFlags, ULONG StartingSize, ASYNC_STGMEDIUM *pStgMedium)
2116 {
2117     TRACE("\n");
2118     return STGMEDIUM_UserSize(pFlags, StartingSize, pStgMedium);
2119 }
2120
2121 unsigned char * __RPC_USER ASYNC_STGMEDIUM_UserMarshal(  ULONG *pFlags, unsigned char *pBuffer, ASYNC_STGMEDIUM *pStgMedium)
2122 {
2123     TRACE("\n");
2124     return STGMEDIUM_UserMarshal(pFlags, pBuffer, pStgMedium);
2125 }
2126
2127 unsigned char * __RPC_USER ASYNC_STGMEDIUM_UserUnmarshal(ULONG *pFlags, unsigned char *pBuffer, ASYNC_STGMEDIUM *pStgMedium)
2128 {
2129     TRACE("\n");
2130     return STGMEDIUM_UserUnmarshal(pFlags, pBuffer, pStgMedium);
2131 }
2132
2133 void __RPC_USER ASYNC_STGMEDIUM_UserFree(ULONG *pFlags, ASYNC_STGMEDIUM *pStgMedium)
2134 {
2135     TRACE("\n");
2136     STGMEDIUM_UserFree(pFlags, pStgMedium);
2137 }
2138
2139 ULONG __RPC_USER FLAG_STGMEDIUM_UserSize(ULONG *pFlags, ULONG StartingSize, FLAG_STGMEDIUM *pStgMedium)
2140 {
2141     FIXME(":stub\n");
2142     return StartingSize;
2143 }
2144
2145 unsigned char * __RPC_USER FLAG_STGMEDIUM_UserMarshal(  ULONG *pFlags, unsigned char *pBuffer, FLAG_STGMEDIUM *pStgMedium)
2146 {
2147     FIXME(":stub\n");
2148     return pBuffer;
2149 }
2150
2151 unsigned char * __RPC_USER FLAG_STGMEDIUM_UserUnmarshal(ULONG *pFlags, unsigned char *pBuffer, FLAG_STGMEDIUM *pStgMedium)
2152 {
2153     FIXME(":stub\n");
2154     return pBuffer;
2155 }
2156
2157 void __RPC_USER FLAG_STGMEDIUM_UserFree(ULONG *pFlags, FLAG_STGMEDIUM *pStgMedium)
2158 {
2159     FIXME(":stub\n");
2160 }
2161
2162 ULONG __RPC_USER SNB_UserSize(ULONG *pFlags, ULONG StartingSize, SNB *pSnb)
2163 {
2164     FIXME(":stub\n");
2165     return StartingSize;
2166 }
2167
2168 unsigned char * __RPC_USER SNB_UserMarshal(  ULONG *pFlags, unsigned char *pBuffer, SNB *pSnb)
2169 {
2170     FIXME(":stub\n");
2171     return pBuffer;
2172 }
2173
2174 unsigned char * __RPC_USER SNB_UserUnmarshal(ULONG *pFlags, unsigned char *pBuffer, SNB *pSnb)
2175 {
2176     FIXME(":stub\n");
2177     return pBuffer;
2178 }
2179
2180 void __RPC_USER SNB_UserFree(ULONG *pFlags, SNB *pSnb)
2181 {
2182     FIXME(":stub\n");
2183 }
2184
2185 /* call_as/local stubs for unknwn.idl */
2186
2187 HRESULT CALLBACK IClassFactory_CreateInstance_Proxy(
2188     IClassFactory* This,
2189     IUnknown *pUnkOuter,
2190     REFIID riid,
2191     void **ppvObject)
2192 {
2193     TRACE("(%p, %s, %p)\n", pUnkOuter, debugstr_guid(riid), ppvObject);
2194     *ppvObject = NULL;
2195     if (pUnkOuter)
2196     {
2197         ERR("aggregation is not allowed on remote objects\n");
2198         return CLASS_E_NOAGGREGATION;
2199     }
2200     return IClassFactory_RemoteCreateInstance_Proxy(This, riid,
2201                                                     (IUnknown **) ppvObject);
2202 }
2203
2204 HRESULT __RPC_STUB IClassFactory_CreateInstance_Stub(
2205     IClassFactory* This,
2206     REFIID riid,
2207     IUnknown **ppvObject)
2208 {
2209     TRACE("(%s, %p)\n", debugstr_guid(riid), ppvObject);
2210     return IClassFactory_CreateInstance(This, NULL, riid, (void **) ppvObject);
2211 }
2212
2213 HRESULT CALLBACK IClassFactory_LockServer_Proxy(
2214     IClassFactory* This,
2215     BOOL fLock)
2216 {
2217     FIXME(":stub\n");
2218     return E_NOTIMPL;
2219 }
2220
2221 HRESULT __RPC_STUB IClassFactory_LockServer_Stub(
2222     IClassFactory* This,
2223     BOOL fLock)
2224 {
2225     FIXME(":stub\n");
2226     return E_NOTIMPL;
2227 }
2228
2229 /* call_as/local stubs for objidl.idl */
2230
2231 HRESULT CALLBACK IEnumUnknown_Next_Proxy(
2232     IEnumUnknown* This,
2233     ULONG celt,
2234     IUnknown **rgelt,
2235     ULONG *pceltFetched)
2236 {
2237     ULONG fetched;
2238     TRACE("(%p)->(%d, %p, %p)\n", This, celt, rgelt, pceltFetched);
2239     if (!pceltFetched) pceltFetched = &fetched;
2240     return IEnumUnknown_RemoteNext_Proxy(This, celt, rgelt, pceltFetched);
2241 }
2242
2243 HRESULT __RPC_STUB IEnumUnknown_Next_Stub(
2244     IEnumUnknown* This,
2245     ULONG celt,
2246     IUnknown **rgelt,
2247     ULONG *pceltFetched)
2248 {
2249     HRESULT hr;
2250     TRACE("(%p)->(%d, %p, %p)\n", This, celt, rgelt, pceltFetched);
2251     *pceltFetched = 0;
2252     hr = IEnumUnknown_Next(This, celt, rgelt, pceltFetched);
2253     if (hr == S_OK) *pceltFetched = celt;
2254     return hr;
2255 }
2256
2257 HRESULT CALLBACK IBindCtx_SetBindOptions_Proxy(
2258     IBindCtx* This,
2259     BIND_OPTS *pbindopts)
2260 {
2261     FIXME(":stub\n");
2262     return E_NOTIMPL;
2263 }
2264
2265 HRESULT __RPC_STUB IBindCtx_SetBindOptions_Stub(
2266     IBindCtx* This,
2267     BIND_OPTS2 *pbindopts)
2268 {
2269     FIXME(":stub\n");
2270     return E_NOTIMPL;
2271 }
2272
2273 HRESULT CALLBACK IBindCtx_GetBindOptions_Proxy(
2274     IBindCtx* This,
2275     BIND_OPTS *pbindopts)
2276 {
2277     FIXME(":stub\n");
2278     return E_NOTIMPL;
2279 }
2280
2281 HRESULT __RPC_STUB IBindCtx_GetBindOptions_Stub(
2282     IBindCtx* This,
2283     BIND_OPTS2 *pbindopts)
2284 {
2285     FIXME(":stub\n");
2286     return E_NOTIMPL;
2287 }
2288
2289 HRESULT CALLBACK IEnumMoniker_Next_Proxy(
2290     IEnumMoniker* This,
2291     ULONG celt,
2292     IMoniker **rgelt,
2293     ULONG *pceltFetched)
2294 {
2295     ULONG fetched;
2296     TRACE("(%p)->(%d, %p, %p)\n", This, celt, rgelt, pceltFetched);
2297     if (!pceltFetched) pceltFetched = &fetched;
2298     return IEnumMoniker_RemoteNext_Proxy(This, celt, rgelt, pceltFetched);
2299 }
2300
2301 HRESULT __RPC_STUB IEnumMoniker_Next_Stub(
2302     IEnumMoniker* This,
2303     ULONG celt,
2304     IMoniker **rgelt,
2305     ULONG *pceltFetched)
2306 {
2307     HRESULT hr;
2308     TRACE("(%p)->(%d, %p, %p)\n", This, celt, rgelt, pceltFetched);
2309     *pceltFetched = 0;
2310     hr = IEnumMoniker_Next(This, celt, rgelt, pceltFetched);
2311     if (hr == S_OK) *pceltFetched = celt;
2312     return hr;
2313 }
2314
2315 BOOL CALLBACK IRunnableObject_IsRunning_Proxy(
2316     IRunnableObject* This)
2317 {
2318     BOOL rv;
2319     FIXME(":stub\n");
2320     memset(&rv, 0, sizeof rv);
2321     return rv;
2322 }
2323
2324 HRESULT __RPC_STUB IRunnableObject_IsRunning_Stub(
2325     IRunnableObject* This)
2326 {
2327     FIXME(":stub\n");
2328     return E_NOTIMPL;
2329 }
2330
2331 HRESULT CALLBACK IMoniker_BindToObject_Proxy(
2332     IMoniker* This,
2333     IBindCtx *pbc,
2334     IMoniker *pmkToLeft,
2335     REFIID riidResult,
2336     void **ppvResult)
2337 {
2338     FIXME(":stub\n");
2339     return E_NOTIMPL;
2340 }
2341
2342 HRESULT __RPC_STUB IMoniker_BindToObject_Stub(
2343     IMoniker* This,
2344     IBindCtx *pbc,
2345     IMoniker *pmkToLeft,
2346     REFIID riidResult,
2347     IUnknown **ppvResult)
2348 {
2349     FIXME(":stub\n");
2350     return E_NOTIMPL;
2351 }
2352
2353 HRESULT CALLBACK IMoniker_BindToStorage_Proxy(
2354     IMoniker* This,
2355     IBindCtx *pbc,
2356     IMoniker *pmkToLeft,
2357     REFIID riid,
2358     void **ppvObj)
2359 {
2360     FIXME(":stub\n");
2361     return E_NOTIMPL;
2362 }
2363
2364 HRESULT __RPC_STUB IMoniker_BindToStorage_Stub(
2365     IMoniker* This,
2366     IBindCtx *pbc,
2367     IMoniker *pmkToLeft,
2368     REFIID riid,
2369     IUnknown **ppvObj)
2370 {
2371     FIXME(":stub\n");
2372     return E_NOTIMPL;
2373 }
2374
2375 HRESULT CALLBACK IEnumString_Next_Proxy(
2376     IEnumString* This,
2377     ULONG celt,
2378     LPOLESTR *rgelt,
2379     ULONG *pceltFetched)
2380 {
2381     ULONG fetched;
2382     TRACE("(%p)->(%d, %p, %p)\n", This, celt, rgelt, pceltFetched);
2383     if (!pceltFetched) pceltFetched = &fetched;
2384     return IEnumString_RemoteNext_Proxy(This, celt, rgelt, pceltFetched);
2385 }
2386
2387 HRESULT __RPC_STUB IEnumString_Next_Stub(
2388     IEnumString* This,
2389     ULONG celt,
2390     LPOLESTR *rgelt,
2391     ULONG *pceltFetched)
2392 {
2393     HRESULT hr;
2394     TRACE("(%p)->(%d, %p, %p)\n", This, celt, rgelt, pceltFetched);
2395     *pceltFetched = 0;
2396     hr = IEnumString_Next(This, celt, rgelt, pceltFetched);
2397     if (hr == S_OK) *pceltFetched = celt;
2398     return hr;
2399 }
2400
2401 HRESULT CALLBACK ISequentialStream_Read_Proxy(
2402     ISequentialStream* This,
2403     void *pv,
2404     ULONG cb,
2405     ULONG *pcbRead)
2406 {
2407     ULONG read;
2408     HRESULT hr;
2409
2410     TRACE("(%p)->(%p, %d, %p)\n", This, pv, cb, pcbRead);
2411
2412     hr = ISequentialStream_RemoteRead_Proxy(This, pv, cb, &read);
2413     if(pcbRead) *pcbRead = read;
2414
2415     return hr;
2416 }
2417
2418 HRESULT __RPC_STUB ISequentialStream_Read_Stub(
2419     ISequentialStream* This,
2420     byte *pv,
2421     ULONG cb,
2422     ULONG *pcbRead)
2423 {
2424     TRACE("(%p)->(%p, %d, %p)\n", This, pv, cb, pcbRead);
2425     return ISequentialStream_Read(This, pv, cb, pcbRead);
2426 }
2427
2428 HRESULT CALLBACK ISequentialStream_Write_Proxy(
2429     ISequentialStream* This,
2430     const void *pv,
2431     ULONG cb,
2432     ULONG *pcbWritten)
2433 {
2434     ULONG written;
2435     HRESULT hr;
2436
2437     TRACE("(%p)->(%p, %d, %p)\n", This, pv, cb, pcbWritten);
2438
2439     hr = ISequentialStream_RemoteWrite_Proxy(This, pv, cb, &written);
2440     if(pcbWritten) *pcbWritten = written;
2441
2442     return hr;
2443 }
2444
2445 HRESULT __RPC_STUB ISequentialStream_Write_Stub(
2446     ISequentialStream* This,
2447     const byte *pv,
2448     ULONG cb,
2449     ULONG *pcbWritten)
2450 {
2451     TRACE("(%p)->(%p, %d, %p)\n", This, pv, cb, pcbWritten);
2452     return ISequentialStream_Write(This, pv, cb, pcbWritten);
2453 }
2454
2455 HRESULT CALLBACK IStream_Seek_Proxy(
2456     IStream* This,
2457     LARGE_INTEGER dlibMove,
2458     DWORD dwOrigin,
2459     ULARGE_INTEGER *plibNewPosition)
2460 {
2461     ULARGE_INTEGER newpos;
2462     HRESULT hr;
2463
2464     TRACE("(%p)->(%s, %d, %p)\n", This, wine_dbgstr_longlong(dlibMove.QuadPart), dwOrigin, plibNewPosition);
2465
2466     hr = IStream_RemoteSeek_Proxy(This, dlibMove, dwOrigin, &newpos);
2467     if(plibNewPosition) *plibNewPosition = newpos;
2468
2469     return hr;
2470 }
2471
2472 HRESULT __RPC_STUB IStream_Seek_Stub(
2473     IStream* This,
2474     LARGE_INTEGER dlibMove,
2475     DWORD dwOrigin,
2476     ULARGE_INTEGER *plibNewPosition)
2477 {
2478     TRACE("(%p)->(%s, %d, %p)\n", This, wine_dbgstr_longlong(dlibMove.QuadPart), dwOrigin, plibNewPosition);
2479     return IStream_Seek(This, dlibMove, dwOrigin, plibNewPosition);
2480 }
2481
2482 HRESULT CALLBACK IStream_CopyTo_Proxy(
2483     IStream* This,
2484     IStream *pstm,
2485     ULARGE_INTEGER cb,
2486     ULARGE_INTEGER *pcbRead,
2487     ULARGE_INTEGER *pcbWritten)
2488 {
2489     ULARGE_INTEGER read, written;
2490     HRESULT hr;
2491
2492     TRACE("(%p)->(%p, %s, %p, %p)\n", This, pstm, wine_dbgstr_longlong(cb.QuadPart), pcbRead, pcbWritten);
2493
2494     hr = IStream_RemoteCopyTo_Proxy(This, pstm, cb, &read, &written);
2495     if(pcbRead) *pcbRead = read;
2496     if(pcbWritten) *pcbWritten = written;
2497
2498     return hr;
2499 }
2500
2501 HRESULT __RPC_STUB IStream_CopyTo_Stub(
2502     IStream* This,
2503     IStream *pstm,
2504     ULARGE_INTEGER cb,
2505     ULARGE_INTEGER *pcbRead,
2506     ULARGE_INTEGER *pcbWritten)
2507 {
2508     TRACE("(%p)->(%p, %s, %p, %p)\n", This, pstm, wine_dbgstr_longlong(cb.QuadPart), pcbRead, pcbWritten);
2509
2510     return IStream_CopyTo(This, pstm, cb, pcbRead, pcbWritten);
2511 }
2512
2513 HRESULT CALLBACK IEnumSTATSTG_Next_Proxy(
2514     IEnumSTATSTG* This,
2515     ULONG celt,
2516     STATSTG *rgelt,
2517     ULONG *pceltFetched)
2518 {
2519     ULONG fetched;
2520     TRACE("(%p)->(%d, %p, %p)\n", This, celt, rgelt, pceltFetched);
2521     if (!pceltFetched) pceltFetched = &fetched;
2522     return IEnumSTATSTG_RemoteNext_Proxy(This, celt, rgelt, pceltFetched);
2523 }
2524
2525 HRESULT __RPC_STUB IEnumSTATSTG_Next_Stub(
2526     IEnumSTATSTG* This,
2527     ULONG celt,
2528     STATSTG *rgelt,
2529     ULONG *pceltFetched)
2530 {
2531     HRESULT hr;
2532     TRACE("(%p)->(%d, %p, %p)\n", This, celt, rgelt, pceltFetched);
2533     *pceltFetched = 0;
2534     hr = IEnumSTATSTG_Next(This, celt, rgelt, pceltFetched);
2535     if (hr == S_OK) *pceltFetched = celt;
2536     return hr;
2537 }
2538
2539 HRESULT CALLBACK IStorage_OpenStream_Proxy(
2540     IStorage* This,
2541     LPCOLESTR pwcsName,
2542     void *reserved1,
2543     DWORD grfMode,
2544     DWORD reserved2,
2545     IStream **ppstm)
2546 {
2547     TRACE("(%p)->(%s, %p, %08x, %d %p)\n", This, debugstr_w(pwcsName), reserved1, grfMode, reserved2, ppstm);
2548     if(reserved1) WARN("reserved1 %p\n", reserved1);
2549
2550     return IStorage_RemoteOpenStream_Proxy(This, pwcsName, 0, NULL, grfMode, reserved2, ppstm);
2551 }
2552
2553 HRESULT __RPC_STUB IStorage_OpenStream_Stub(
2554     IStorage* This,
2555     LPCOLESTR pwcsName,
2556     ULONG cbReserved1,
2557     byte *reserved1,
2558     DWORD grfMode,
2559     DWORD reserved2,
2560     IStream **ppstm)
2561 {
2562     TRACE("(%p)->(%s, %d, %p, %08x, %d %p)\n", This, debugstr_w(pwcsName), cbReserved1, reserved1, grfMode, reserved2, ppstm);
2563     if(cbReserved1 || reserved1) WARN("cbReserved1 %d reserved1 %p\n", cbReserved1, reserved1);
2564
2565     return IStorage_OpenStream(This, pwcsName, NULL, grfMode, reserved2, ppstm);
2566 }
2567
2568 HRESULT CALLBACK IStorage_EnumElements_Proxy(
2569     IStorage* This,
2570     DWORD reserved1,
2571     void *reserved2,
2572     DWORD reserved3,
2573     IEnumSTATSTG **ppenum)
2574 {
2575     TRACE("(%p)->(%d, %p, %d, %p)\n", This, reserved1, reserved2, reserved3, ppenum);
2576     if(reserved2) WARN("reserved2 %p\n", reserved2);
2577
2578     return IStorage_RemoteEnumElements_Proxy(This, reserved1, 0, NULL, reserved3, ppenum);
2579 }
2580
2581 HRESULT __RPC_STUB IStorage_EnumElements_Stub(
2582     IStorage* This,
2583     DWORD reserved1,
2584     ULONG cbReserved2,
2585     byte *reserved2,
2586     DWORD reserved3,
2587     IEnumSTATSTG **ppenum)
2588 {
2589     TRACE("(%p)->(%d, %d, %p, %d, %p)\n", This, reserved1, cbReserved2, reserved2, reserved3, ppenum);
2590     if(cbReserved2 || reserved2) WARN("cbReserved2 %d reserved2 %p\n", cbReserved2, reserved2);
2591
2592     return IStorage_EnumElements(This, reserved1, NULL, reserved3, ppenum);
2593 }
2594
2595 HRESULT CALLBACK ILockBytes_ReadAt_Proxy(
2596     ILockBytes* This,
2597     ULARGE_INTEGER ulOffset,
2598     void *pv,
2599     ULONG cb,
2600     ULONG *pcbRead)
2601 {
2602     ULONG read;
2603     HRESULT hr;
2604
2605     TRACE("(%p)->(%s, %p, %d, %p)\n", This, wine_dbgstr_longlong(ulOffset.QuadPart), pv, cb, pcbRead);
2606
2607     hr = ILockBytes_RemoteReadAt_Proxy(This, ulOffset, pv, cb, &read);
2608     if(pcbRead) *pcbRead = read;
2609
2610     return hr;
2611 }
2612
2613 HRESULT __RPC_STUB ILockBytes_ReadAt_Stub(
2614     ILockBytes* This,
2615     ULARGE_INTEGER ulOffset,
2616     byte *pv,
2617     ULONG cb,
2618     ULONG *pcbRead)
2619 {
2620     TRACE("(%p)->(%s, %p, %d, %p)\n", This, wine_dbgstr_longlong(ulOffset.QuadPart), pv, cb, pcbRead);
2621     return ILockBytes_ReadAt(This, ulOffset, pv, cb, pcbRead);
2622 }
2623
2624 HRESULT CALLBACK ILockBytes_WriteAt_Proxy(
2625     ILockBytes* This,
2626     ULARGE_INTEGER ulOffset,
2627     const void *pv,
2628     ULONG cb,
2629     ULONG *pcbWritten)
2630 {
2631     ULONG written;
2632     HRESULT hr;
2633
2634     TRACE("(%p)->(%s, %p, %d, %p)\n", This, wine_dbgstr_longlong(ulOffset.QuadPart), pv, cb, pcbWritten);
2635
2636     hr = ILockBytes_RemoteWriteAt_Proxy(This, ulOffset, pv, cb, &written);
2637     if(pcbWritten) *pcbWritten = written;
2638
2639     return hr;
2640 }
2641
2642 HRESULT __RPC_STUB ILockBytes_WriteAt_Stub(
2643     ILockBytes* This,
2644     ULARGE_INTEGER ulOffset,
2645     const byte *pv,
2646     ULONG cb,
2647     ULONG *pcbWritten)
2648 {
2649     TRACE("(%p)->(%s, %p, %d, %p)\n", This, wine_dbgstr_longlong(ulOffset.QuadPart), pv, cb, pcbWritten);
2650     return ILockBytes_WriteAt(This, ulOffset, pv, cb, pcbWritten);
2651 }
2652
2653 HRESULT CALLBACK IFillLockBytes_FillAppend_Proxy(
2654     IFillLockBytes* This,
2655     const void *pv,
2656     ULONG cb,
2657     ULONG *pcbWritten)
2658 {
2659     ULONG written;
2660     HRESULT hr;
2661
2662     TRACE("(%p)->(%p, %d, %p)\n", This, pv, cb, pcbWritten);
2663
2664     hr = IFillLockBytes_RemoteFillAppend_Proxy(This, pv, cb, &written);
2665     if(pcbWritten) *pcbWritten = written;
2666
2667     return hr;
2668 }
2669
2670 HRESULT __RPC_STUB IFillLockBytes_FillAppend_Stub(
2671     IFillLockBytes* This,
2672     const byte *pv,
2673     ULONG cb,
2674     ULONG *pcbWritten)
2675 {
2676     TRACE("(%p)->(%p, %d, %p)\n", This, pv, cb, pcbWritten);
2677     return IFillLockBytes_FillAppend(This, pv, cb, pcbWritten);
2678 }
2679
2680 HRESULT CALLBACK IFillLockBytes_FillAt_Proxy(
2681     IFillLockBytes* This,
2682     ULARGE_INTEGER ulOffset,
2683     const void *pv,
2684     ULONG cb,
2685     ULONG *pcbWritten)
2686 {
2687     ULONG written;
2688     HRESULT hr;
2689
2690     TRACE("(%p)->(%s, %p, %d, %p)\n", This, wine_dbgstr_longlong(ulOffset.QuadPart), pv, cb, pcbWritten);
2691
2692     hr = IFillLockBytes_RemoteFillAt_Proxy(This, ulOffset, pv, cb, &written);
2693     if(pcbWritten) *pcbWritten = written;
2694
2695     return hr;
2696 }
2697
2698 HRESULT __RPC_STUB IFillLockBytes_FillAt_Stub(
2699     IFillLockBytes* This,
2700     ULARGE_INTEGER ulOffset,
2701     const byte *pv,
2702     ULONG cb,
2703     ULONG *pcbWritten)
2704 {
2705     TRACE("(%p)->(%s, %p, %d, %p)\n", This, wine_dbgstr_longlong(ulOffset.QuadPart), pv, cb, pcbWritten);
2706     return IFillLockBytes_FillAt(This, ulOffset, pv, cb, pcbWritten);
2707 }
2708
2709 HRESULT CALLBACK IEnumFORMATETC_Next_Proxy(
2710     IEnumFORMATETC* This,
2711     ULONG celt,
2712     FORMATETC *rgelt,
2713     ULONG *pceltFetched)
2714 {
2715     ULONG fetched;
2716     if (!pceltFetched) pceltFetched = &fetched;
2717     return IEnumFORMATETC_RemoteNext_Proxy(This, celt, rgelt, pceltFetched);
2718 }
2719
2720 HRESULT __RPC_STUB IEnumFORMATETC_Next_Stub(
2721     IEnumFORMATETC* This,
2722     ULONG celt,
2723     FORMATETC *rgelt,
2724     ULONG *pceltFetched)
2725 {
2726     HRESULT hr;
2727     *pceltFetched = 0;
2728     hr = IEnumFORMATETC_Next(This, celt, rgelt, pceltFetched);
2729     if (hr == S_OK) *pceltFetched = celt;
2730     return hr;
2731 }
2732
2733 HRESULT CALLBACK IEnumSTATDATA_Next_Proxy(
2734     IEnumSTATDATA* This,
2735     ULONG celt,
2736     STATDATA *rgelt,
2737     ULONG *pceltFetched)
2738 {
2739     ULONG fetched;
2740     TRACE("(%p)->(%d, %p, %p)\n", This, celt, rgelt, pceltFetched);
2741     if (!pceltFetched) pceltFetched = &fetched;
2742     return IEnumSTATDATA_RemoteNext_Proxy(This, celt, rgelt, pceltFetched);
2743 }
2744
2745 HRESULT __RPC_STUB IEnumSTATDATA_Next_Stub(
2746     IEnumSTATDATA* This,
2747     ULONG celt,
2748     STATDATA *rgelt,
2749     ULONG *pceltFetched)
2750 {
2751     HRESULT hr;
2752     TRACE("(%p)->(%d, %p, %p)\n", This, celt, rgelt, pceltFetched);
2753     *pceltFetched = 0;
2754     hr = IEnumSTATDATA_Next(This, celt, rgelt, pceltFetched);
2755     if (hr == S_OK) *pceltFetched = celt;
2756     return hr;
2757 }
2758
2759 void CALLBACK IAdviseSink_OnDataChange_Proxy(
2760     IAdviseSink* This,
2761     FORMATETC *pFormatetc,
2762     STGMEDIUM *pStgmed)
2763 {
2764     FIXME(":stub\n");
2765 }
2766
2767 HRESULT __RPC_STUB IAdviseSink_OnDataChange_Stub(
2768     IAdviseSink* This,
2769     FORMATETC *pFormatetc,
2770     ASYNC_STGMEDIUM *pStgmed)
2771 {
2772     FIXME(":stub\n");
2773     return E_NOTIMPL;
2774 }
2775
2776 void CALLBACK IAdviseSink_OnViewChange_Proxy(
2777     IAdviseSink* This,
2778     DWORD dwAspect,
2779     LONG lindex)
2780 {
2781     FIXME(":stub\n");
2782 }
2783
2784 HRESULT __RPC_STUB IAdviseSink_OnViewChange_Stub(
2785     IAdviseSink* This,
2786     DWORD dwAspect,
2787     LONG lindex)
2788 {
2789     FIXME(":stub\n");
2790     return E_NOTIMPL;
2791 }
2792
2793 void CALLBACK IAdviseSink_OnRename_Proxy(
2794     IAdviseSink* This,
2795     IMoniker *pmk)
2796 {
2797     FIXME(":stub\n");
2798 }
2799
2800 HRESULT __RPC_STUB IAdviseSink_OnRename_Stub(
2801     IAdviseSink* This,
2802     IMoniker *pmk)
2803 {
2804     FIXME(":stub\n");
2805     return E_NOTIMPL;
2806 }
2807
2808 void CALLBACK IAdviseSink_OnSave_Proxy(
2809     IAdviseSink* This)
2810 {
2811     FIXME(":stub\n");
2812 }
2813
2814 HRESULT __RPC_STUB IAdviseSink_OnSave_Stub(
2815     IAdviseSink* This)
2816 {
2817     FIXME(":stub\n");
2818     return E_NOTIMPL;
2819 }
2820
2821 void CALLBACK IAdviseSink_OnClose_Proxy(
2822     IAdviseSink* This)
2823 {
2824     FIXME(":stub\n");
2825 }
2826
2827 HRESULT __RPC_STUB IAdviseSink_OnClose_Stub(
2828     IAdviseSink* This)
2829 {
2830     FIXME(":stub\n");
2831     return E_NOTIMPL;
2832 }
2833
2834 void CALLBACK IAdviseSink2_OnLinkSrcChange_Proxy(
2835     IAdviseSink2* This,
2836     IMoniker *pmk)
2837 {
2838     FIXME(":stub\n");
2839 }
2840
2841 HRESULT __RPC_STUB IAdviseSink2_OnLinkSrcChange_Stub(
2842     IAdviseSink2* This,
2843     IMoniker *pmk)
2844 {
2845     FIXME(":stub\n");
2846     return E_NOTIMPL;
2847 }
2848
2849 HRESULT CALLBACK IDataObject_GetData_Proxy(
2850     IDataObject* This,
2851     FORMATETC *pformatetcIn,
2852     STGMEDIUM *pmedium)
2853 {
2854     TRACE("(%p)->(%p, %p)\n", This, pformatetcIn, pmedium);
2855     return IDataObject_RemoteGetData_Proxy(This, pformatetcIn, pmedium);
2856 }
2857
2858 HRESULT __RPC_STUB IDataObject_GetData_Stub(
2859     IDataObject* This,
2860     FORMATETC *pformatetcIn,
2861     STGMEDIUM *pRemoteMedium)
2862 {
2863     TRACE("(%p)->(%p, %p)\n", This, pformatetcIn, pRemoteMedium);
2864     return IDataObject_GetData(This, pformatetcIn, pRemoteMedium);
2865 }
2866
2867 HRESULT CALLBACK IDataObject_GetDataHere_Proxy(
2868     IDataObject* This,
2869     FORMATETC *pformatetc,
2870     STGMEDIUM *pmedium)
2871 {
2872     TRACE("(%p)->(%p, %p)\n", This, pformatetc, pmedium);
2873     return IDataObject_RemoteGetDataHere_Proxy(This, pformatetc, pmedium);
2874 }
2875
2876 HRESULT __RPC_STUB IDataObject_GetDataHere_Stub(
2877     IDataObject* This,
2878     FORMATETC *pformatetc,
2879     STGMEDIUM *pRemoteMedium)
2880 {
2881     TRACE("(%p)->(%p, %p)\n", This, pformatetc, pRemoteMedium);
2882     return IDataObject_GetDataHere(This, pformatetc, pRemoteMedium);
2883 }
2884
2885 HRESULT CALLBACK IDataObject_SetData_Proxy(
2886     IDataObject* This,
2887     FORMATETC *pformatetc,
2888     STGMEDIUM *pmedium,
2889     BOOL fRelease)
2890 {
2891     FIXME(":stub\n");
2892     return E_NOTIMPL;
2893 }
2894
2895 HRESULT __RPC_STUB IDataObject_SetData_Stub(
2896     IDataObject* This,
2897     FORMATETC *pformatetc,
2898     FLAG_STGMEDIUM *pmedium,
2899     BOOL fRelease)
2900 {
2901     FIXME(":stub\n");
2902     return E_NOTIMPL;
2903 }
2904
2905 /* call_as/local stubs for oleidl.idl */
2906
2907 HRESULT CALLBACK IOleInPlaceActiveObject_TranslateAccelerator_Proxy(
2908     IOleInPlaceActiveObject* This,
2909     LPMSG lpmsg)
2910 {
2911     FIXME(":stub\n");
2912     return E_NOTIMPL;
2913 }
2914
2915 HRESULT __RPC_STUB IOleInPlaceActiveObject_TranslateAccelerator_Stub(
2916     IOleInPlaceActiveObject* This)
2917 {
2918     FIXME(":stub\n");
2919     return E_NOTIMPL;
2920 }
2921
2922 HRESULT CALLBACK IOleInPlaceActiveObject_ResizeBorder_Proxy(
2923     IOleInPlaceActiveObject* This,
2924     LPCRECT prcBorder,
2925     IOleInPlaceUIWindow *pUIWindow,
2926     BOOL fFrameWindow)
2927 {
2928     FIXME(":stub\n");
2929     return E_NOTIMPL;
2930 }
2931
2932 HRESULT __RPC_STUB IOleInPlaceActiveObject_ResizeBorder_Stub(
2933     IOleInPlaceActiveObject* This,
2934     LPCRECT prcBorder,
2935     REFIID riid,
2936     IOleInPlaceUIWindow *pUIWindow,
2937     BOOL fFrameWindow)
2938 {
2939     FIXME(":stub\n");
2940     return E_NOTIMPL;
2941 }
2942
2943 HRESULT CALLBACK IOleCache2_UpdateCache_Proxy(
2944     IOleCache2* This,
2945     LPDATAOBJECT pDataObject,
2946     DWORD grfUpdf,
2947     LPVOID pReserved)
2948 {
2949     FIXME(":stub\n");
2950     return E_NOTIMPL;
2951 }
2952
2953 HRESULT __RPC_STUB IOleCache2_UpdateCache_Stub(
2954     IOleCache2* This,
2955     LPDATAOBJECT pDataObject,
2956     DWORD grfUpdf,
2957     LONG_PTR pReserved)
2958 {
2959     FIXME(":stub\n");
2960     return E_NOTIMPL;
2961 }
2962
2963 HRESULT CALLBACK IEnumOLEVERB_Next_Proxy(
2964     IEnumOLEVERB* This,
2965     ULONG celt,
2966     LPOLEVERB rgelt,
2967     ULONG *pceltFetched)
2968 {
2969     ULONG fetched;
2970     TRACE("(%p)->(%d, %p, %p)\n", This, celt, rgelt, pceltFetched);
2971     if (!pceltFetched) pceltFetched = &fetched;
2972     return IEnumOLEVERB_RemoteNext_Proxy(This, celt, rgelt, pceltFetched);
2973 }
2974
2975 HRESULT __RPC_STUB IEnumOLEVERB_Next_Stub(
2976     IEnumOLEVERB* This,
2977     ULONG celt,
2978     LPOLEVERB rgelt,
2979     ULONG *pceltFetched)
2980 {
2981     HRESULT hr;
2982     TRACE("(%p)->(%d, %p, %p)\n", This, celt, rgelt, pceltFetched);
2983     *pceltFetched = 0;
2984     hr = IEnumOLEVERB_Next(This, celt, rgelt, pceltFetched);
2985     if (hr == S_OK) *pceltFetched = celt;
2986     return hr;
2987 }
2988
2989 HRESULT CALLBACK IViewObject_Draw_Proxy(
2990     IViewObject* This,
2991     DWORD dwDrawAspect,
2992     LONG lindex,
2993     void *pvAspect,
2994     DVTARGETDEVICE *ptd,
2995     HDC hdcTargetDev,
2996     HDC hdcDraw,
2997     LPCRECTL lprcBounds,
2998     LPCRECTL lprcWBounds,
2999     BOOL (STDMETHODCALLTYPE *pfnContinue)(ULONG_PTR dwContinue),
3000     ULONG_PTR dwContinue)
3001 {
3002     FIXME(":stub\n");
3003     return E_NOTIMPL;
3004 }
3005
3006 HRESULT __RPC_STUB IViewObject_Draw_Stub(
3007     IViewObject* This,
3008     DWORD dwDrawAspect,
3009     LONG lindex,
3010     ULONG_PTR pvAspect,
3011     DVTARGETDEVICE *ptd,
3012     ULONG_PTR hdcTargetDev,
3013     ULONG_PTR hdcDraw,
3014     LPCRECTL lprcBounds,
3015     LPCRECTL lprcWBounds,
3016     IContinue *pContinue)
3017 {
3018     FIXME(":stub\n");
3019     return E_NOTIMPL;
3020 }
3021
3022 HRESULT CALLBACK IViewObject_GetColorSet_Proxy(
3023     IViewObject* This,
3024     DWORD dwDrawAspect,
3025     LONG lindex,
3026     void *pvAspect,
3027     DVTARGETDEVICE *ptd,
3028     HDC hicTargetDev,
3029     LOGPALETTE **ppColorSet)
3030 {
3031     FIXME(":stub\n");
3032     return E_NOTIMPL;
3033 }
3034
3035 HRESULT __RPC_STUB IViewObject_GetColorSet_Stub(
3036     IViewObject* This,
3037     DWORD dwDrawAspect,
3038     LONG lindex,
3039     ULONG_PTR pvAspect,
3040     DVTARGETDEVICE *ptd,
3041     ULONG_PTR hicTargetDev,
3042     LOGPALETTE **ppColorSet)
3043 {
3044     FIXME(":stub\n");
3045     return E_NOTIMPL;
3046 }
3047
3048 HRESULT CALLBACK IViewObject_Freeze_Proxy(
3049     IViewObject* This,
3050     DWORD dwDrawAspect,
3051     LONG lindex,
3052     void *pvAspect,
3053     DWORD *pdwFreeze)
3054 {
3055     FIXME(":stub\n");
3056     return E_NOTIMPL;
3057 }
3058
3059 HRESULT __RPC_STUB IViewObject_Freeze_Stub(
3060     IViewObject* This,
3061     DWORD dwDrawAspect,
3062     LONG lindex,
3063     ULONG_PTR pvAspect,
3064     DWORD *pdwFreeze)
3065 {
3066     FIXME(":stub\n");
3067     return E_NOTIMPL;
3068 }
3069
3070 HRESULT CALLBACK IViewObject_GetAdvise_Proxy(
3071     IViewObject* This,
3072     DWORD *pAspects,
3073     DWORD *pAdvf,
3074     IAdviseSink **ppAdvSink)
3075 {
3076     FIXME(":stub\n");
3077     return E_NOTIMPL;
3078 }
3079
3080 HRESULT __RPC_STUB IViewObject_GetAdvise_Stub(
3081     IViewObject* This,
3082     DWORD *pAspects,
3083     DWORD *pAdvf,
3084     IAdviseSink **ppAdvSink)
3085 {
3086     FIXME(":stub\n");
3087     return E_NOTIMPL;
3088 }