75 memset(stub_msg, 0,
sizeof(*stub_msg));
81 memset(umcb, 0,
sizeof(*umcb));
88#define RELEASEMARSHALDATA WM_USER
112 if (prev_filter) IMessageFilter_Release(prev_filter);
199 "CLIPFORMAT: Wrong size %d\n",
size);
206 ok(*(
LONG *)(
buffer + 4) == WDT_REMOTE_CALL,
"CLIPFORMAT: Context should be WDT_REMOTE_CALL instead of 0x%08x\n", *(
LONG *)(
buffer + 0));
216 ok(
cf == cf2,
"CLIPFORMAT: Didn't unmarshal properly\n");
236 ok(
size == 4 +
sizeof(*wirehwnd),
"Wrong size %d\n",
size);
242 wirehwnd = (wireHWND)(
buffer + 4);
243 ok(wirehwnd->fContext == WDT_INPROC_CALL,
"Context should be WDT_INPROC_CALL instead of 0x%08x\n", wirehwnd->fContext);
244 ok(wirehwnd->u.hInproc == (
LONG_PTR)
hwnd,
"Marshaled value should be %p instead of %x\n",
hwnd, wirehwnd->u.hRemote);
249 ok(
hwnd == hwnd2,
"Didn't unmarshal properly\n");
253 HWND_UserFree(&umcb.
Flags, &hwnd2);
265 unsigned char *wirehglobal;
278 ok(*(
ULONG *)wirehglobal == WDT_REMOTE_CALL,
"Context should be WDT_REMOTE_CALL instead of 0x%08x\n", *(
ULONG *)wirehglobal);
279 wirehglobal +=
sizeof(
ULONG);
280 ok(*(
ULONG *)wirehglobal == 0,
"buffer+4 should be HGLOBAL\n");
284 ok(hglobal2 == hglobal,
"Didn't unmarshal properly\n");
292 ULONG actual_size, expected_size;
300 expected_size = actual_size + 5 *
sizeof(
DWORD);
305 ok(
size == expected_size ||
313 ok(*(
ULONG *)wirehglobal == WDT_REMOTE_CALL,
"Context should be WDT_REMOTE_CALL instead of 0x%08x\n", *(
ULONG *)wirehglobal);
314 wirehglobal +=
sizeof(
ULONG);
316 wirehglobal +=
sizeof(
ULONG);
318 wirehglobal +=
sizeof(
ULONG);
320 wirehglobal +=
sizeof(
ULONG);
322 wirehglobal +=
sizeof(
ULONG);
324 ok(wirehglobal[
i] ==
i,
"buffer+0x%x should be %d\n", 0x10 +
i,
i);
329 ok(hglobal2 !=
NULL,
"Didn't unmarshal properly\n");
353 HENHMETAFILE hemf2 =
NULL;
354 unsigned char *wirehemf;
360 ok(
size > 24,
"size should be at least 24 bytes, not %d\n",
size);
366 ok(*(
DWORD *)wirehemf == WDT_REMOTE_CALL,
"wirestgm + 0x0 should be WDT_REMOTE_CALL instead of 0x%08x\n", *(
DWORD *)wirehemf);
367 wirehemf +=
sizeof(
DWORD);
369 wirehemf +=
sizeof(
DWORD);
370 ok(*(
DWORD *)wirehemf == (
size - 0x14),
"wirestgm + 0x8 should be size - 0x14 instead of 0x%08x\n", *(
DWORD *)wirehemf);
371 wirehemf +=
sizeof(
DWORD);
372 ok(*(
DWORD *)wirehemf == (
size - 0x14),
"wirestgm + 0xc should be size - 0x14 instead of 0x%08x\n", *(
DWORD *)wirehemf);
373 wirehemf +=
sizeof(
DWORD);
374 ok(*(
DWORD *)wirehemf ==
EMR_HEADER,
"wirestgm + 0x10 should be EMR_HEADER instead of %d\n", *(
DWORD *)wirehemf);
381 ok(hemf2 !=
NULL,
"HENHMETAFILE didn't unmarshal\n");
392 ok(
size == 12,
"size should be 12 bytes, not %d\n",
size);
398 ok(*(
DWORD *)wirehemf == WDT_REMOTE_CALL,
"wirestgm + 0x0 should be WDT_REMOTE_CALL instead of 0x%08x\n", *(
DWORD *)wirehemf);
399 wirehemf +=
sizeof(
DWORD);
405 ok(hemf2 ==
NULL,
"NULL HENHMETAFILE didn't unmarshal\n");
427 HMETAFILE hmf2 =
NULL;
428 unsigned char *wirehmf;
434 ok(
size > 20,
"size should be at least 20 bytes, not %d\n",
size);
439 ok(*(
DWORD *)wirehmf == WDT_REMOTE_CALL,
"wirestgm + 0x0 should be WDT_REMOTE_CALL instead of 0x%08x\n", *(
DWORD *)wirehmf);
440 wirehmf +=
sizeof(
DWORD);
442 wirehmf +=
sizeof(
DWORD);
443 ok(*(
DWORD *)wirehmf == (
size - 0x10),
"wirestgm + 0x8 should be size - 0x10 instead of 0x%08x\n", *(
DWORD *)wirehmf);
444 wirehmf +=
sizeof(
DWORD);
445 ok(*(
DWORD *)wirehmf == (
size - 0x10),
"wirestgm + 0xc should be size - 0x10 instead of 0x%08x\n", *(
DWORD *)wirehmf);
446 wirehmf +=
sizeof(
DWORD);
447 ok(*(
WORD *)wirehmf == 1,
"wirestgm + 0x10 should be 1 instead of 0x%08x\n", *(
DWORD *)wirehmf);
448 wirehmf +=
sizeof(
DWORD);
454 ok(hmf2 !=
NULL,
"HMETAFILE didn't unmarshal\n");
463 ok(
size == 8,
"size should be 8 bytes, not %d\n",
size);
468 ok(*(
DWORD *)wirehmf == WDT_REMOTE_CALL,
"wirestgm + 0x0 should be WDT_REMOTE_CALL instead of 0x%08x\n", *(
DWORD *)wirehmf);
469 wirehmf +=
sizeof(
DWORD);
471 wirehmf +=
sizeof(
DWORD);
475 ok(hmf2 ==
NULL,
"NULL HMETAFILE didn't unmarshal\n");
480#define USER_MARSHAL_PTR_PREFIX \
481 ( (DWORD)'U' | ( (DWORD)'s' << 8 ) | \
482 ( (DWORD)'e' << 16 ) | ( (DWORD)'r' << 24 ) )
492 HMETAFILEPICT hmfp2 =
NULL;
494 unsigned char *wirehmfp;
506 ok(
size > 24,
"size should be at least 24 bytes, not %d\n",
size);
511 ok(*(
DWORD *)wirehmfp == WDT_REMOTE_CALL,
"wirestgm + 0x0 should be WDT_REMOTE_CALL instead of 0x%08x\n", *(
DWORD *)wirehmfp);
512 wirehmfp +=
sizeof(
DWORD);
514 wirehmfp +=
sizeof(
DWORD);
515 ok(*(
DWORD *)wirehmfp ==
MM_ISOTROPIC,
"wirestgm + 0x8 should be MM_ISOTROPIC instead of 0x%08x\n", *(
DWORD *)wirehmfp);
516 wirehmfp +=
sizeof(
DWORD);
517 ok(*(
DWORD *)wirehmfp == 1,
"wirestgm + 0xc should be 1 instead of 0x%08x\n", *(
DWORD *)wirehmfp);
518 wirehmfp +=
sizeof(
DWORD);
519 ok(*(
DWORD *)wirehmfp == 2,
"wirestgm + 0x10 should be 2 instead of 0x%08x\n", *(
DWORD *)wirehmfp);
520 wirehmfp +=
sizeof(
DWORD);
522 wirehmfp +=
sizeof(
DWORD);
523 ok(*(
DWORD *)wirehmfp == WDT_REMOTE_CALL,
"wirestgm + 0x18 should be WDT_REMOTE_CALL instead of 0x%08x\n", *(
DWORD *)wirehmfp);
524 wirehmfp +=
sizeof(
DWORD);
528 wirehmfp +=
sizeof(
DWORD);
531 ok(*(
DWORD *)wirehmfp == (
buffer_end -
buffer - 0x2c),
"wirestgm + 0x20 should be size - 0x34 instead of 0x%08x\n", *(
DWORD *)wirehmfp);
532 wirehmfp +=
sizeof(
DWORD);
533 ok(*(
DWORD *)wirehmfp == (
buffer_end -
buffer - 0x2c),
"wirestgm + 0x24 should be size - 0x34 instead of 0x%08x\n", *(
DWORD *)wirehmfp);
534 wirehmfp +=
sizeof(
DWORD);
535 ok(*(
WORD *)wirehmfp == 1,
"wirehmfp + 0x28 should be 1 instead of 0x%08x\n", *(
DWORD *)wirehmfp);
541 ok(hmfp2 !=
NULL,
"HMETAFILEPICT didn't unmarshal\n");
555 ok(
size == 12,
"size should be 12 bytes, not %d\n",
size);
561 ok(*(
DWORD *)wirehmfp == WDT_REMOTE_CALL,
"wirestgm + 0x0 should be WDT_REMOTE_CALL instead of 0x%08x\n", *(
DWORD *)wirehmfp);
562 wirehmfp +=
sizeof(
DWORD);
564 wirehmfp +=
sizeof(
DWORD);
570 ok(hmfp2 ==
NULL,
"NULL HMETAFILE didn't unmarshal\n");
597 IUnknown_AddRef(iface);
644 IStream_AddRef(iface);
690 unsigned char *wireip;
705 ok(
size == 0,
"size should be 0 bytes, not %d\n",
size);
720 IStream_Seek(stm,
zero, STREAM_SEEK_CUR, &
pos);
721 marshal_size =
pos.u.LowPart;
728 ok(
size >= marshal_size + 2 *
sizeof(
DWORD),
"marshal size %x got %x\n", marshal_size,
size);
738 ok(*(
DWORD *)wireip == marshal_size,
"wireip + 0x0 should be %x instead of %x\n", marshal_size, *(
DWORD *)wireip);
739 wireip +=
sizeof(
DWORD);
740 ok(*(
DWORD *)wireip == marshal_size,
"wireip + 0x4 should be %x instead of %x\n", marshal_size, *(
DWORD *)wireip);
741 wireip +=
sizeof(
DWORD);
743 ok(!
memcmp(marshal_data, wireip, marshal_size),
"buffer mismatch\n");
746 IStream_Seek(stm,
zero, STREAM_SEEK_SET,
NULL);
748 IStream_Release(stm);
758 ok(unk2 !=
NULL,
"IUnknown object didn't unmarshal properly\n");
763 IUnknown_Release(unk2);
812 *(
DWORD*)expect_buffer = TYMED_NULL;
813 *((
DWORD*)expect_buffer + 1) = 0xdeadbeef;
817 med.tymed = TYMED_NULL;
819 med.pUnkForRelease = unk;
823 ok(
size == expect_size,
"size %d should be %d bytes\n",
size, expect_size);
828 ok(
buffer_end -
buffer == expect_buffer_end - expect_buffer,
"buffer size mismatch\n");
831 ok(!
memcmp(
buffer+8, expect_buffer + 8, expect_buffer_end - expect_buffer - 8),
"buffer mismatch\n");
839 med2.tymed = TYMED_NULL;
845 ok(med2.tymed == TYMED_NULL,
"got tymed %x\n", med2.tymed);
846 ok(med2.pUnkForRelease !=
NULL,
"Incorrectly unmarshalled\n");
854 med2.tymed = TYMED_NULL;
856 med2.pUnkForRelease =
NULL;
876 memset(expect_buffer, 0xcc, expect_size);
877 *(
DWORD*)expect_buffer = TYMED_ISTREAM;
878 *((
DWORD*)expect_buffer + 1) = 0xdeadbeef;
879 *((
DWORD*)expect_buffer + 2) = 0xcafe;
884 med.tymed = TYMED_ISTREAM;
886 med.pUnkForRelease = unk;
890 ok(
size == expect_size,
"size %d should be %d bytes\n",
size, expect_size);
896 ok(
buffer_end -
buffer == expect_buffer_end - expect_buffer,
"buffer size mismatch\n");
909 med2.tymed = TYMED_ISTREAM;
915 ok(med2.tymed == TYMED_ISTREAM,
"got tymed %x\n", med2.tymed);
916 ok(
U(med2).pstm !=
NULL,
"Incorrectly unmarshalled\n");
917 ok(med2.pUnkForRelease !=
NULL,
"Incorrectly unmarshalled\n");
926 med2.tymed = TYMED_NULL;
928 med2.pUnkForRelease =
NULL;
941 expect_size = 3 *
sizeof(
DWORD);
943 med.tymed = TYMED_ISTREAM;
945 med.pUnkForRelease =
NULL;
949 ok(
size == expect_size,
"size %d should be %d bytes\n",
size, expect_size);
967 med2.tymed = TYMED_ISTREAM;
973 ok(med2.tymed == TYMED_ISTREAM,
"got tymed %x\n", med2.tymed);
974 ok(
U(med2).pstm ==
NULL,
"Incorrectly unmarshalled\n");
999 static const WCHAR str1W[] = {
's',
't',
'r',
'i',
'n',
'g',
'1',0};
1000 static const WCHAR str2W[] = {
's',
't',
'r',
'2',0};
1003 WCHAR **ptrW, *dataW;
1014 ok(
size == 16,
"Size should be 16, instead of %d\n",
size);
1019 ok(
size == 12,
"Size should be 12, instead of %d\n",
size);
1026 wiresnb = (RemSNB*)
buffer;
1027 ok(wiresnb->ulCntStr == 0,
"got %u\n", wiresnb->ulCntStr);
1028 ok(wiresnb->ulCntChar == 0,
"got %u\n", wiresnb->ulCntChar);
1029 ok(*(
ULONG*)wiresnb->rgString == 0,
"got %u\n", *(
ULONG*)wiresnb->rgString);
1034 ok(snb2 ==
NULL,
"got %p\n", snb2);
1057 ok(
size == 38,
"Size should be 38, instead of %d\n",
size);
1063 wiresnb = (RemSNB*)
buffer;
1064 ok(wiresnb->ulCntStr == 13,
"got %u\n", wiresnb->ulCntStr);
1065 ok(wiresnb->ulCntChar == 2,
"got %u\n", wiresnb->ulCntChar);
1067 ok(*(
ULONG*)wiresnb->rgString == wiresnb->ulCntStr,
"got %u\n", *(
ULONG*)wiresnb->rgString);
1068 dataW = &wiresnb->rgString[2];
1085 ok(*ptrW ==
NULL,
"expected terminating NULL ptr, got %p, start %p\n", *ptrW, snb2);
1109 ok(
size == 4 +
sizeof(*wirehdc),
"Wrong size %d\n",
size);
1115 wirehdc = (wireHDC)(
buffer + 4);
1116 ok(wirehdc->fContext == WDT_INPROC_CALL,
"Context should be WDT_INPROC_CALL instead of 0x%08x\n", wirehdc->fContext);
1117 ok(wirehdc->u.hInproc == (
LONG_PTR)
hdc,
"Marshaled value should be %p instead of %x\n",
hdc, wirehdc->u.hRemote);
1122 ok(
hdc ==
hdc2,
"Didn't unmarshal properly\n");
1132 static const BYTE bmp_bits[1024];
1138 wireHICON wirehicon;
1142 ok(
hIcon != 0,
"CreateIcon failed\n");
1146 ok(
size == 4 +
sizeof(*wirehicon),
"Wrong size %d\n",
size);
1152 wirehicon = (wireHICON)(
buffer + 4);
1153 ok(wirehicon->fContext == WDT_INPROC_CALL,
"Context should be WDT_INPROC_CALL instead of 0x%08x\n", wirehicon->fContext);
1154 ok(wirehicon->u.hInproc == (
LONG_PTR)
hIcon,
"Marshaled value should be %p instead of %x\n",
hIcon, wirehicon->u.hRemote);
1170 HBRUSH hBrush, hBrush2;
1175 wireHBRUSH wirehbrush;
1183 ok(hBrush != 0,
"CreateBrushIndirect failed\n");
1187 ok(
size == 4 +
sizeof(*wirehbrush),
"Wrong size %d\n",
size);
1193 wirehbrush = (wireHBRUSH)(
buffer + 4);
1194 ok(wirehbrush->fContext == WDT_INPROC_CALL,
"Context should be WDT_INPROC_CALL instead of 0x%08x\n", wirehbrush->fContext);
1195 ok(wirehbrush->u.hInproc == (
LONG_PTR)hBrush,
"Marshaled value should be %p instead of %x\n", hBrush, wirehbrush->u.hRemote);
1200 ok(hBrush == hBrush2,
"Didn't unmarshal properly\n");
1211 static BYTE bmp_bits[1024];
1217 unsigned char bitmap[1024];
1221 ok(
hBitmap != 0,
"CreateBitmap failed\n");
1223 ok(
size != 0,
"GetObject failed\n");
1225 ok(bitmap_size != 0,
"GetBitmapBits failed\n");
1234 ok(*(
ULONG *)(
buffer + 0x4) == WDT_INPROC_CALL,
"Context should be WDT_INPROC_CALL instead of 0x%08x\n", *(
ULONG *)(
buffer + 0x4));
1239 ok(hBitmap2 !=
NULL,
"Didn't unmarshal properly\n");
1247 ok(
size == 0x10 + header_size + bitmap_size ||
1248 broken(
size == 0x14 + header_size + bitmap_size),
1249 "Wrong size %d\n",
size);
1255 ok(*(
ULONG *)(
buffer + 0x4) == WDT_REMOTE_CALL,
"Context should be WDT_REMOTE_CALL instead of 0x%08x\n", *(
ULONG *)
buffer);
1259 ok(!
memcmp(
buffer + 0x10 + header_size, bmp_bits, bitmap_size),
"buffer mismatch\n");
1263 ok(hBitmap2 !=
NULL,
"Didn't unmarshal properly\n");
1286 IDataObject_AddRef(iface);
1306 ok( med->pUnkForRelease ==
NULL,
"got %p\n", med->pUnkForRelease );
1308 if (
fmt->cfFormat == 2)
1310 IStream_Release(
U(med)->pstm);
1353 IStream_Seek( stm,
zero, STREAM_SEEK_SET,
NULL );
1356 IStream_Release( stm );
1364 fmt.dwAspect = DVASPECT_CONTENT;
1369 fmt.tymed = med.tymed = TYMED_NULL;
1370 hr = IDataObject_GetDataHere(
data, &
fmt, &med );
1373 for (
fmt.tymed = TYMED_HGLOBAL;
fmt.tymed <= TYMED_ENHMF;
fmt.tymed <<= 1)
1375 med.tymed =
fmt.tymed;
1376 hr = IDataObject_GetDataHere(
data, &
fmt, &med );
1381 fmt.tymed = TYMED_ISTREAM;
1382 med.tymed = TYMED_ISTORAGE;
1383 hr = IDataObject_GetDataHere(
data, &
fmt, &med );
1386 fmt.tymed = med.tymed = TYMED_ISTREAM;
1390 hr = IDataObject_GetDataHere(
data, &
fmt, &med );
1393 ok(
U(med).pstm == &
Test_Stream.IStream_iface,
"stm changed\n" );
1400 fmt.tymed = med.tymed = TYMED_ISTREAM;
1404 hr = IDataObject_GetDataHere(
data, &
fmt, &med );
1407 ok(
U(med).pstm == &
Test_Stream.IStream_iface,
"stm changed\n" );
1414 IDataObject_Release(
data );
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
ACPI_SIZE strlen(const char *String)
#define InterlockedIncrement
#define InterlockedDecrement
#define HeapFree(x, y, z)
HANDLE WINAPI DECLSPEC_HOTPATCH CreateThread(IN LPSECURITY_ATTRIBUTES lpThreadAttributes, IN DWORD dwStackSize, IN LPTHREAD_START_ROUTINE lpStartAddress, IN LPVOID lpParameter, IN DWORD dwCreationFlags, OUT LPDWORD lpThreadId)
int WINAPI lstrcmpW(LPCWSTR str1, LPCWSTR str2)
HRESULT WINAPI CoRegisterMessageFilter(LPMESSAGEFILTER lpMessageFilter, LPMESSAGEFILTER *lplpMessageFilter)
HRESULT WINAPI DECLSPEC_HOTPATCH CoInitializeEx(LPVOID lpReserved, DWORD dwCoInit)
void WINAPI DECLSPEC_HOTPATCH CoUninitialize(void)
HRESULT WINAPI CreateStreamOnHGlobal(HGLOBAL hGlobal, BOOL fDeleteOnRelease, LPSTREAM *ppstm)
HRESULT WINAPI CoReleaseMarshalData(IStream *pStream)
HRESULT WINAPI CoUnmarshalInterface(IStream *pStream, REFIID riid, LPVOID *ppv)
HRESULT WINAPI CoMarshalInterface(IStream *pStream, REFIID riid, IUnknown *pUnk, DWORD dwDestContext, void *pvDestContext, DWORD mshlFlags)
void __RPC_USER HBITMAP_UserFree(ULONG *flags, HBITMAP *bmp)
void __RPC_USER HMETAFILE_UserFree(ULONG *pFlags, HMETAFILE *phmf)
unsigned char *__RPC_USER CLIPFORMAT_UserMarshal(ULONG *pFlags, unsigned char *pBuffer, CLIPFORMAT *pCF)
unsigned char *__RPC_USER STGMEDIUM_UserMarshal(ULONG *pFlags, unsigned char *pBuffer, STGMEDIUM *pStgMedium)
ULONG __RPC_USER HMETAFILEPICT_UserSize(ULONG *pFlags, ULONG size, HMETAFILEPICT *phMfp)
ULONG __RPC_USER HMETAFILE_UserSize(ULONG *pFlags, ULONG StartingSize, HMETAFILE *phmf)
unsigned char *__RPC_USER SNB_UserUnmarshal(ULONG *pFlags, unsigned char *pBuffer, SNB *pSnb)
unsigned char *__RPC_USER HMETAFILEPICT_UserUnmarshal(ULONG *pFlags, unsigned char *pBuffer, HMETAFILEPICT *phMfp)
unsigned char *__RPC_USER HMETAFILE_UserUnmarshal(ULONG *pFlags, unsigned char *pBuffer, HMETAFILE *phmf)
void __RPC_USER HENHMETAFILE_UserFree(ULONG *pFlags, HENHMETAFILE *phEmf)
unsigned char *WINAPI WdtpInterfacePointer_UserMarshal(ULONG *pFlags, ULONG RealFlags, unsigned char *pBuffer, IUnknown *punk, REFIID riid)
ULONG __RPC_USER CLIPFORMAT_UserSize(ULONG *pFlags, ULONG size, CLIPFORMAT *pCF)
#define USER_MARSHAL_PTR_PREFIX
ULONG __RPC_USER HBITMAP_UserSize(ULONG *flags, ULONG size, HBITMAP *bmp)
unsigned char *__RPC_USER HMETAFILE_UserMarshal(ULONG *pFlags, unsigned char *pBuffer, HMETAFILE *phmf)
unsigned char *__RPC_USER HGLOBAL_UserMarshal(ULONG *pFlags, unsigned char *pBuffer, HGLOBAL *phGlobal)
unsigned char *__RPC_USER STGMEDIUM_UserUnmarshal(ULONG *pFlags, unsigned char *pBuffer, STGMEDIUM *pStgMedium)
unsigned char *__RPC_USER SNB_UserMarshal(ULONG *pFlags, unsigned char *pBuffer, SNB *pSnb)
unsigned char *__RPC_USER HENHMETAFILE_UserUnmarshal(ULONG *pFlags, unsigned char *pBuffer, HENHMETAFILE *phEmf)
unsigned char *__RPC_USER HBITMAP_UserMarshal(ULONG *flags, unsigned char *buffer, HBITMAP *bmp)
void __RPC_USER STGMEDIUM_UserFree(ULONG *flags, STGMEDIUM *med)
unsigned char *__RPC_USER HMETAFILEPICT_UserMarshal(ULONG *pFlags, unsigned char *pBuffer, HMETAFILEPICT *phMfp)
ULONG __RPC_USER HENHMETAFILE_UserSize(ULONG *pFlags, ULONG size, HENHMETAFILE *phEmf)
void __RPC_USER HMETAFILEPICT_UserFree(ULONG *pFlags, HMETAFILEPICT *phMfp)
unsigned char *__RPC_USER HENHMETAFILE_UserMarshal(ULONG *pFlags, unsigned char *pBuffer, HENHMETAFILE *phEmf)
ULONG __RPC_USER HGLOBAL_UserSize(ULONG *pFlags, ULONG StartingSize, HGLOBAL *phGlobal)
unsigned char *__RPC_USER HBITMAP_UserUnmarshal(ULONG *flags, unsigned char *buffer, HBITMAP *bmp)
ULONG __RPC_USER SNB_UserSize(ULONG *pFlags, ULONG StartingSize, SNB *pSnb)
ULONG __RPC_USER STGMEDIUM_UserSize(ULONG *pFlags, ULONG StartingSize, STGMEDIUM *pStgMedium)
void __RPC_USER CLIPFORMAT_UserFree(ULONG *pFlags, CLIPFORMAT *pCF)
unsigned char *WINAPI WdtpInterfacePointer_UserUnmarshal(ULONG *pFlags, unsigned char *pBuffer, IUnknown **ppunk, REFIID riid)
unsigned char *__RPC_USER CLIPFORMAT_UserUnmarshal(ULONG *pFlags, unsigned char *pBuffer, CLIPFORMAT *pCF)
void __RPC_USER SNB_UserFree(ULONG *pFlags, SNB *pSnb)
unsigned char *__RPC_USER HGLOBAL_UserUnmarshal(ULONG *pFlags, unsigned char *pBuffer, HGLOBAL *phGlobal)
void __RPC_USER HGLOBAL_UserFree(ULONG *pFlags, HGLOBAL *phGlobal)
ULONG __RPC_USER WdtpInterfacePointer_UserSize(ULONG *pFlags, ULONG RealFlags, ULONG StartingSize, IUnknown *punk, REFIID riid)
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
GLint GLint GLint GLint GLint GLint GLint GLbitfield GLenum filter
GLfloat GLfloat GLfloat GLfloat h
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
LPVOID NTAPI GlobalLock(HGLOBAL hMem)
HGLOBAL NTAPI GlobalFree(HGLOBAL hMem)
BOOL NTAPI GlobalUnlock(HGLOBAL hMem)
HGLOBAL NTAPI GlobalAlloc(UINT uFlags, SIZE_T dwBytes)
SIZE_T NTAPI GlobalSize(HGLOBAL hMem)
VOID WINAPI CoTaskMemFree(LPVOID ptr)
LPVOID WINAPI CoTaskMemAlloc(SIZE_T size)
static DWORD block_size(DWORD block)
static void WINAPI user_free(void *p)
static void marshal_STGMEDIUM(BOOL client, BOOL in, BOOL out)
static void test_marshal_HENHMETAFILE(void)
static const IStreamVtbl TestStream_Vtbl
static void marshal_WdtpInterfacePointer(DWORD umcb_ctx, DWORD ctx, BOOL client, BOOL in, BOOL out)
static HRESULT WINAPI Test_IUnknown_QueryInterface(LPUNKNOWN iface, REFIID riid, LPVOID *ppvObj)
static ULONG WINAPI obj_AddRef(IDataObject *iface)
static HMETAFILE create_mf(void)
static ULONG WINAPI Test_IStream_Release(IStream *iface)
static ULONG WINAPI Test_IStream_AddRef(IStream *iface)
static struct test_stream Test_Stream
static void test_marshal_WdtpInterfacePointer(void)
static void test_marshal_HMETAFILEPICT(void)
static HENHMETAFILE create_emf(void)
static ULONG WINAPI Test_IUnknown_Release(LPUNKNOWN iface)
static void test_marshal_HDC(void)
static BOOL g_expect_user_alloc
static void test_marshal_HICON(void)
static void test_marshal_CLIPFORMAT(void)
static void end_host_object(DWORD tid, HANDLE thread)
static void test_marshal_HBRUSH(void)
static void test_marshal_HWND(void)
static BOOL g_expect_user_free
static TestUnknown Test_Unknown2
static void test_GetDataHere_Proxy(void)
#define RELEASEMARSHALDATA
static HRESULT WINAPI obj_DO_GetDataHere(IDataObject *iface, FORMATETC *fmt, STGMEDIUM *med)
void __RPC_USER HBRUSH_UserFree(ULONG *, HBRUSH *)
static ULONG WINAPI Test_IUnknown_AddRef(LPUNKNOWN iface)
static TestUnknown * impl_from_IUnknown(IUnknown *iface)
static const IDataObjectVtbl obj_data_object_vtbl
ULONG __RPC_USER HBRUSH_UserSize(ULONG *, ULONG, HBRUSH *)
static void test_marshal_HMETAFILE(void)
static DWORD start_host_object2(IStream *stream, REFIID riid, IUnknown *object, MSHLFLAGS marshal_flags, IMessageFilter *filter, HANDLE *thread)
static HRESULT WINAPI obj_QueryInterface(IDataObject *iface, REFIID iid, void **obj)
unsigned char *__RPC_USER HBRUSH_UserUnmarshal(ULONG *, unsigned char *, HBRUSH *)
static TestUnknown Test_Unknown
static ULONG WINAPI obj_Release(IDataObject *iface)
static DWORD CALLBACK host_object_proc(LPVOID p)
static struct test_stream Test_Stream2
static void test_marshal_HBITMAP(void)
static struct test_stream * impl_from_IStream(IStream *iface)
static void test_marshal_STGMEDIUM(void)
static void test_marshal_SNB(void)
static void test_marshal_HGLOBAL(void)
static void init_user_marshal_cb(USER_MARSHAL_CB *umcb, PMIDL_STUB_MESSAGE stub_msg, PRPC_MESSAGE rpc_msg, unsigned char *buffer, unsigned int size, MSHCTX context)
static void *WINAPI user_allocate(SIZE_T size)
static HRESULT WINAPI Test_IStream_QueryInterface(IStream *iface, REFIID riid, LPVOID *ppvObj)
static const IUnknownVtbl TestUnknown_Vtbl
unsigned char *__RPC_USER HBRUSH_UserMarshal(ULONG *, unsigned char *, HBRUSH *)
static const char cf_marshaled[]
@ COINIT_APARTMENTTHREADED
const GUID IID_IDataObject
#define IsEqualGUID(rguid1, rguid2)
#define IsEqualIID(riid1, riid2)
#define NDR_LOCAL_DATA_REPRESENTATION
@ USER_MARSHAL_CB_BUFFER_SIZE
@ USER_MARSHAL_CB_UNMARSHALL
#define USER_MARSHAL_CB_SIGNATURE
USER_MARSHAL_CB_TYPE CBType
PMIDL_STUB_MESSAGE pStubMsg
IDataObject IDataObject_iface
DWORD WINAPI WaitForSingleObject(IN HANDLE hHandle, IN DWORD dwMilliseconds)
HANDLE WINAPI DECLSPEC_HOTPATCH CreateEventA(IN LPSECURITY_ATTRIBUTES lpEventAttributes OPTIONAL, IN BOOL bManualReset, IN BOOL bInitialState, IN LPCSTR lpName OPTIONAL)
BOOL WINAPI DECLSPEC_HOTPATCH SetEvent(IN HANDLE hEvent)
TW_UINT32 TW_UINT16 TW_UINT16 MSG
#define FIELD_OFFSET(t, f)
#define CONTAINING_RECORD(address, type, field)
DWORD WINAPI GetLastError(void)
BOOL WINAPI DeleteMetaFile(_In_ HMETAFILE)
HBRUSH WINAPI CreateBrushIndirect(_In_ const LOGBRUSH *plb)
HBITMAP WINAPI CreateBitmap(_In_ INT cx, _In_ INT cy, _In_ UINT cPlanes, _In_ UINT cBitsPerPel, _In_opt_ const VOID *pvBits)
BOOL WINAPI DeleteEnhMetaFile(_In_opt_ HENHMETAFILE)
int WINAPI GetObjectA(_In_ HANDLE h, _In_ int c, _Out_writes_bytes_opt_(c) LPVOID pv)
HDC WINAPI CreateMetaFileA(_In_opt_ LPCSTR)
HMETAFILE WINAPI CloseMetaFile(_In_ HDC hdc)
LONG WINAPI GetBitmapBits(_In_ HBITMAP hbit, _In_ LONG cb, _Out_writes_bytes_(cb) LPVOID lpvBits)
BOOL WINAPI ExtTextOutA(_In_ HDC hdc, _In_ int x, _In_ int y, _In_ UINT options, _In_opt_ const RECT *lprect, _In_reads_opt_(c) LPCSTR lpString, _In_ UINT c, _In_reads_opt_(c) const INT *lpDx)
HDC WINAPI CreateEnhMetaFileA(_In_opt_ HDC, _In_opt_ LPCSTR, _In_opt_ LPCRECT, _In_opt_ LPCSTR)
HENHMETAFILE WINAPI CloseEnhMetaFile(_In_ HDC hdc)
int WINAPI ReleaseDC(_In_opt_ HWND, _In_ HDC)
LRESULT WINAPI DispatchMessageA(_In_ const MSG *)
HICON WINAPI CreateIcon(_In_opt_ HINSTANCE, _In_ int, _In_ int, _In_ BYTE, _In_ BYTE, _In_ const BYTE *, _In_ const BYTE *)
HWND WINAPI GetDesktopWindow(void)
HDC WINAPI GetDC(_In_opt_ HWND)
BOOL WINAPI PeekMessageA(_Out_ LPMSG, _In_opt_ HWND, _In_ UINT, _In_ UINT, _In_ UINT)
BOOL WINAPI PostThreadMessageA(_In_ DWORD, _In_ UINT, _In_ WPARAM, _In_ LPARAM)
BOOL WINAPI GetMessageA(_Out_ LPMSG, _In_opt_ HWND, _In_ UINT, _In_ UINT)
UINT WINAPI RegisterClipboardFormatA(_In_ LPCSTR)
BOOL WINAPI DestroyIcon(_In_ HICON)