?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
windowscodecs: Silence fixme for IID_CMetaBitmapRenderTarget.
[wine.git] / dlls / wow64win / gdi.c
blob993580c32c34d0bb690cde3e261c0a339de65783
1 /*
2 * WoW64 GDI functions
3 *
4 * Copyright 2021 Jacek Caban for CodeWeavers
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 <stdarg.h>
22
23 #include "ntstatus.h"
24 #define WIN32_NO_STATUS
25 #include "windef.h"
26 #include "winbase.h"
27 #include "ntgdi.h"
28 #include "ddk/d3dkmthk.h"
29 #include "wow64win_private.h"
30
31 typedef struct
32 {
33 INT bmType;
34 INT bmWidth;
35 INT bmHeight;
36 INT bmWidthBytes;
37 WORD bmPlanes;
38 WORD bmBitsPixel;
39 ULONG bmBits;
40 } BITMAP32;
41
42 typedef struct
43 {
44 DWORD elpPenStyle;
45 DWORD elpWidth;
46 UINT elpBrushStyle;
47 COLORREF elpColor;
48 ULONG elpHatch;
49 DWORD elpNumEntries;
50 DWORD elpStyleEntry[1];
51 } EXTLOGPEN32;
52
53 typedef struct
54 {
55 UINT otmSize;
56 TEXTMETRICW otmTextMetrics;
57 BYTE otmFiller;
58 PANOSE otmPanoseNumber;
59 UINT otmfsSelection;
60 UINT otmfsType;
61 INT otmsCharSlopeRise;
62 INT otmsCharSlopeRun;
63 INT otmItalicAngle;
64 UINT otmEMSquare;
65 INT otmAscent;
66 INT otmDescent;
67 UINT otmLineGap;
68 UINT otmsCapEmHeight;
69 UINT otmsXHeight;
70 RECT otmrcFontBox;
71 INT otmMacAscent;
72 INT otmMacDescent;
73 UINT otmMacLineGap;
74 UINT otmusMinimumPPEM;
75 POINT otmptSubscriptSize;
76 POINT otmptSubscriptOffset;
77 POINT otmptSuperscriptSize;
78 POINT otmptSuperscriptOffset;
79 UINT otmsStrikeoutSize;
80 INT otmsStrikeoutPosition;
81 INT otmsUnderscoreSize;
82 INT otmsUnderscorePosition;
83 ULONG otmpFamilyName;
84 ULONG otmpFaceName;
85 ULONG otmpStyleName;
86 ULONG otmpFullName;
87 } OUTLINETEXTMETRIC32;
88
89
90 static DWORD gdi_handle_type( HGDIOBJ obj )
91 {
92 unsigned int handle = HandleToUlong( obj );
93 return handle & NTGDI_HANDLE_TYPE_MASK;
94 }
95
96 NTSTATUS WINAPI wow64_NtGdiAbortDoc( UINT *args )
97 {
98 HDC hdc = get_handle( &args );
99
100 return NtGdiAbortDoc( hdc );
101 }
102
103 NTSTATUS WINAPI wow64_NtGdiAbortPath( UINT *args )
104 {
105 HDC hdc = get_handle( &args );
106
107 return NtGdiAbortPath( hdc );
108 }
109
110 NTSTATUS WINAPI wow64_NtGdiAddFontMemResourceEx( UINT *args )
111 {
112 void *ptr = get_ptr( &args );
113 DWORD size = get_ulong( &args );
114 void *dv = get_ptr( &args );
115 ULONG dv_size = get_ulong( &args );
116 DWORD *count = get_ptr( &args );
117
118 return HandleToUlong( NtGdiAddFontMemResourceEx( ptr, size, dv, dv_size, count ));
119 }
120
121 NTSTATUS WINAPI wow64_NtGdiAddFontResourceW( UINT *args )
122 {
123 const WCHAR *str = get_ptr( &args );
124 ULONG size = get_ulong( &args );
125 ULONG files = get_ulong( &args );
126 DWORD flags = get_ulong( &args );
127 DWORD tid = get_ulong( &args );
128 void *dv = get_ptr( &args );
129
130 return NtGdiAddFontResourceW( str, size, files, flags, tid, dv );
131 }
132
133 NTSTATUS WINAPI wow64_NtGdiAlphaBlend( UINT *args )
134 {
135 HDC hdc_dst = get_handle( &args );
136 int x_dst = get_ulong( &args );
137 int y_dst = get_ulong( &args );
138 int width_dst = get_ulong( &args );
139 int height_dst = get_ulong( &args );
140 HDC hdc_src = get_handle( &args );
141 int x_src = get_ulong( &args );
142 int y_src = get_ulong( &args );
143 int width_src = get_ulong( &args );
144 int height_src = get_ulong( &args );
145 DWORD blend_function = get_ulong( &args );
146 HANDLE xform = get_handle( &args );
147
148 return NtGdiAlphaBlend( hdc_dst, x_dst, y_dst, width_dst, height_dst, hdc_src,
149 x_src, y_src, width_src, height_src, blend_function, xform );
150 }
151
152 NTSTATUS WINAPI wow64_NtGdiAngleArc( UINT *args )
153 {
154 HDC hdc = get_handle( &args );
155 INT x = get_ulong( &args );
156 INT y = get_ulong( &args );
157 DWORD radius = get_ulong( &args );
158 DWORD start_angle = get_ulong( &args );
159 DWORD sweep_angle = get_ulong( &args );
160
161 return NtGdiAngleArc( hdc, x, y, radius, start_angle, sweep_angle );
162 }
163
164 NTSTATUS WINAPI wow64_NtGdiArcInternal( UINT *args )
165 {
166 UINT type = get_ulong( &args );
167 HDC hdc = get_handle( &args );
168 INT left = get_ulong( &args );
169 INT top = get_ulong( &args );
170 INT right = get_ulong( &args );
171 INT bottom = get_ulong( &args );
172 INT xstart = get_ulong( &args );
173 INT ystart = get_ulong( &args );
174 INT xend = get_ulong( &args );
175 INT yend = get_ulong( &args );
176
177 return NtGdiArcInternal( type, hdc, left, top, right, bottom, xstart, ystart, xend, yend );
178 }
179
180 NTSTATUS WINAPI wow64_NtGdiBeginPath( UINT *args )
181 {
182 HDC hdc = get_handle( &args );
183
184 return NtGdiBeginPath( hdc );
185 }
186
187 NTSTATUS WINAPI wow64_NtGdiBitBlt( UINT *args )
188 {
189 HDC hdc_dst = get_handle( &args );
190 INT x_dst = get_ulong( &args );
191 INT y_dst = get_ulong( &args );
192 INT width = get_ulong( &args );
193 INT height = get_ulong( &args );
194 HDC hdc_src = get_handle( &args );
195 INT x_src = get_ulong( &args );
196 INT y_src = get_ulong( &args );
197 DWORD rop = get_ulong( &args );
198 DWORD bk_color = get_ulong( &args );
199 FLONG fl = get_ulong( &args );
200
201 return NtGdiBitBlt( hdc_dst, x_dst, y_dst, width, height, hdc_src,
202 x_src, y_src, rop, bk_color, fl );
203 }
204
205 NTSTATUS WINAPI wow64_NtGdiCloseFigure( UINT *args )
206 {
207 HDC hdc = get_handle( &args );
208
209 return NtGdiCloseFigure( hdc );
210 }
211
212 NTSTATUS WINAPI wow64_NtGdiCombineRgn( UINT *args )
213 {
214 HRGN dest = get_handle( &args );
215 HRGN src1 = get_handle( &args );
216 HRGN src2 = get_handle( &args );
217 INT mode = get_ulong( &args );
218
219 return NtGdiCombineRgn( dest, src1, src2, mode );
220 }
221
222 NTSTATUS WINAPI wow64_NtGdiComputeXformCoefficients( UINT *args )
223 {
224 HDC hdc = get_handle( &args );
225
226 return NtGdiComputeXformCoefficients( hdc );
227 }
228
229 NTSTATUS WINAPI wow64_NtGdiCreateBitmap( UINT *args )
230 {
231 INT width = get_ulong( &args );
232 INT height = get_ulong( &args );
233 UINT planes = get_ulong( &args );
234 UINT bpp = get_ulong( &args );
235 const void *bits = get_ptr( &args );
236
237 return HandleToUlong( NtGdiCreateBitmap( width, height, planes, bpp, bits ));
238 }
239
240 NTSTATUS WINAPI wow64_NtGdiCreateClientObj( UINT *args )
241 {
242 ULONG type = get_ulong( &args );
243
244 return HandleToUlong( NtGdiCreateClientObj( type ));
245 }
246
247 NTSTATUS WINAPI wow64_NtGdiCreateCompatibleBitmap( UINT *args )
248 {
249 HDC hdc = get_handle( &args );
250 INT width = get_ulong( &args );
251 INT height = get_ulong( &args );
252
253 return HandleToUlong( NtGdiCreateCompatibleBitmap( hdc, width, height ));
254 }
255
256 NTSTATUS WINAPI wow64_NtGdiCreateCompatibleDC( UINT *args )
257 {
258 HDC hdc = get_handle( &args );
259
260 return HandleToUlong( NtGdiCreateCompatibleDC( hdc ));
261 }
262
263 NTSTATUS WINAPI wow64_NtGdiCreateDIBBrush( UINT *args )
264 {
265 const void *data = get_ptr( &args );
266 UINT coloruse = get_ulong( &args );
267 UINT size = get_ulong( &args );
268 BOOL is_8x8 = get_ulong( &args );
269 BOOL pen = get_ulong( &args );
270 const void *client = get_ptr( &args );
271
272 return HandleToUlong( NtGdiCreateDIBBrush( data, coloruse, size, is_8x8, pen, client ));
273 }
274
275 NTSTATUS WINAPI wow64_NtGdiCreateDIBSection( UINT *args )
276 {
277 HDC hdc = get_handle( &args );
278 HANDLE section = get_handle( &args );
279 DWORD offset = get_ulong( &args );
280 const BITMAPINFO *bmi = get_ptr( &args );
281 UINT usage = get_ulong( &args );
282 UINT header_size = get_ulong( &args );
283 ULONG flags = get_ulong( &args );
284 ULONG_PTR color_space = get_ulong( &args );
285 void *bits32 = get_ptr( &args );
286
287 void *bits;
288 HBITMAP ret;
289
290 ret = NtGdiCreateDIBSection( hdc, section, offset, bmi, usage, header_size,
291 flags, color_space, addr_32to64( &bits, bits32 ));
292 put_addr( bits32, bits );
293 return HandleToUlong( ret );
294 }
295
296 NTSTATUS WINAPI wow64_NtGdiCreateDIBitmapInternal( UINT *args )
297 {
298 HDC hdc = get_handle( &args );
299 INT width = get_ulong( &args );
300 INT height = get_ulong( &args );
301 DWORD init = get_ulong( &args );
302 const void *bits = get_ptr( &args );
303 const BITMAPINFO *data = get_ptr( &args );
304 UINT coloruse = get_ulong( &args );
305 UINT max_info = get_ulong( &args );
306 UINT max_bits = get_ulong( &args );
307 ULONG flags = get_ulong( &args );
308 HANDLE xform = get_handle( &args );
309
310 HBITMAP ret = NtGdiCreateDIBitmapInternal( hdc, width, height, init, bits, data,
311 coloruse, max_info, max_bits, flags, xform );
312 return HandleToUlong( ret );
313 }
314
315 NTSTATUS WINAPI wow64_NtGdiCreateEllipticRgn( UINT *args )
316 {
317 INT left = get_ulong( &args );
318 INT top = get_ulong( &args );
319 INT right = get_ulong( &args );
320 INT bottom = get_ulong( &args );
321
322 return HandleToUlong( NtGdiCreateEllipticRgn( left, top, right, bottom ));
323 }
324
325 NTSTATUS WINAPI wow64_NtGdiCreateHalftonePalette( UINT *args )
326 {
327 HDC hdc = get_handle( &args );
328
329 return HandleToUlong( NtGdiCreateHalftonePalette( hdc ));
330 }
331
332 NTSTATUS WINAPI wow64_NtGdiCreateHatchBrushInternal( UINT *args )
333 {
334 INT style = get_ulong( &args );
335 COLORREF color = get_ulong( &args );
336 BOOL pen = get_ulong( &args );
337
338 return HandleToULong( NtGdiCreateHatchBrushInternal( style, color, pen ));
339 }
340
341 NTSTATUS WINAPI wow64_NtGdiCreateMetafileDC( UINT *args )
342 {
343 HDC hdc = get_handle( &args );
344
345 return HandleToUlong( NtGdiCreateMetafileDC( hdc ));
346 }
347
348 NTSTATUS WINAPI wow64_NtGdiCreatePaletteInternal( UINT *args )
349 {
350 const LOGPALETTE *palette = get_ptr( &args );
351 UINT count = get_ulong( &args );
352
353 return HandleToUlong( NtGdiCreatePaletteInternal( palette, count ));
354 }
355
356 NTSTATUS WINAPI wow64_NtGdiCreatePatternBrushInternal( UINT *args )
357 {
358 HBITMAP hbitmap = get_handle( &args );
359 BOOL pen = get_ulong( &args );
360 BOOL is_8x8 = get_ulong( &args );
361
362 return HandleToUlong( NtGdiCreatePatternBrushInternal( hbitmap, pen, is_8x8 ));
363 }
364
365 NTSTATUS WINAPI wow64_NtGdiCreatePen( UINT *args )
366 {
367 INT style = get_ulong( &args );
368 INT width = get_ulong( &args );
369 COLORREF color = get_ulong( &args );
370 HBRUSH brush = get_handle( &args );
371
372 return HandleToUlong( NtGdiCreatePen( style, width, color, brush ));
373 }
374
375 NTSTATUS WINAPI wow64_NtGdiCreateRectRgn( UINT *args )
376 {
377 INT left = get_ulong( &args );
378 INT top = get_ulong( &args );
379 INT right = get_ulong( &args );
380 INT bottom = get_ulong( &args );
381
382 return HandleToUlong( NtGdiCreateRectRgn( left, top, right, bottom ));
383 }
384
385 NTSTATUS WINAPI wow64_NtGdiCreateRoundRectRgn( UINT *args )
386 {
387 INT left = get_ulong( &args );
388 INT top = get_ulong( &args );
389 INT right = get_ulong( &args );
390 INT bottom = get_ulong( &args );
391 INT ellipse_width = get_ulong( &args );
392 INT ellipse_height = get_ulong( &args );
393
394 return HandleToUlong( NtGdiCreateRoundRectRgn( left, top, right, bottom,
395 ellipse_width, ellipse_height ));
396 }
397
398 NTSTATUS WINAPI wow64_NtGdiCreateSolidBrush( UINT *args )
399 {
400 COLORREF color = get_ulong( &args );
401 HBRUSH brush = get_handle( &args );
402
403 return HandleToUlong( NtGdiCreateSolidBrush( color, brush ));
404 }
405
406 NTSTATUS WINAPI wow64_NtGdiDdDDICheckVidPnExclusiveOwnership( UINT *args )
407 {
408 const D3DKMT_CHECKVIDPNEXCLUSIVEOWNERSHIP *desc = get_ptr( &args );
409
410 return NtGdiDdDDICheckVidPnExclusiveOwnership( desc );
411 }
412
413 NTSTATUS WINAPI wow64_NtGdiDdDDICloseAdapter( UINT *args )
414 {
415 const D3DKMT_CLOSEADAPTER *desc = get_ptr( &args );
416
417 return NtGdiDdDDICloseAdapter( desc );
418 }
419
420 NTSTATUS WINAPI wow64_NtGdiDdDDICreateDCFromMemory( UINT *args )
421 {
422 struct _D3DKMT_CREATEDCFROMMEMORY
423 {
424 ULONG pMemory;
425 D3DDDIFORMAT Format;
426 UINT Width;
427 UINT Height;
428 UINT Pitch;
429 ULONG hDeviceDc;
430 ULONG pColorTable;
431 ULONG hDc;
432 ULONG hBitmap;
433 } *desc32 = get_ptr( &args );
434
435 D3DKMT_CREATEDCFROMMEMORY desc;
436 NTSTATUS status;
437
438 if (!desc32) return STATUS_INVALID_PARAMETER;
439 desc.pMemory = UlongToPtr( desc32->pMemory );
440 desc.Format = desc32->Format;
441 desc.Width = desc32->Width;
442 desc.Height = desc32->Height;
443 desc.Pitch = desc32->Pitch;
444 desc.hDeviceDc = UlongToHandle( desc32->hDeviceDc );
445 desc.pColorTable = UlongToPtr( desc32->pColorTable );
446
447 if (!(status = NtGdiDdDDICreateDCFromMemory( &desc )))
448 {
449 desc32->hDc = HandleToUlong( desc.hDc );
450 desc32->hBitmap = HandleToUlong( desc.hBitmap );
451 }
452 return status;
453 }
454
455 NTSTATUS WINAPI wow64_NtGdiDdDDICreateDevice( UINT *args )
456 {
457 struct
458 {
459 D3DKMT_HANDLE hAdapter;
460 D3DKMT_CREATEDEVICEFLAGS Flags;
461 D3DKMT_HANDLE hDevice;
462 ULONG pCommandBuffer;
463 UINT CommandBufferSize;
464 ULONG pAllocationList;
465 UINT AllocationListSize;
466 ULONG pPatchLocationList;
467 UINT PatchLocationListSize;
468 } *desc32 = get_ptr( &args );
469
470 D3DKMT_CREATEDEVICE desc;
471 NTSTATUS status;
472
473 if (!desc32) return STATUS_INVALID_PARAMETER;
474 desc.hAdapter = desc32->hAdapter;
475 desc.Flags = desc32->Flags;
476 desc.pCommandBuffer = UlongToPtr( desc32->pCommandBuffer );
477 desc.CommandBufferSize = desc32->CommandBufferSize;
478 desc.pAllocationList = UlongToPtr( desc32->pAllocationList );
479 desc.AllocationListSize = desc32->AllocationListSize;
480 desc.pPatchLocationList = UlongToPtr( desc32->pPatchLocationList );
481 desc.PatchLocationListSize = desc32->PatchLocationListSize;
482 if (!(status = NtGdiDdDDICreateDevice( &desc )))
483 desc32->hDevice = desc.hDevice;
484 return status;
485 }
486
487 NTSTATUS WINAPI wow64_NtGdiDdDDIDestroyDCFromMemory( UINT *args )
488 {
489 const struct
490 {
491 ULONG hDc;
492 ULONG hBitmap;
493 } *desc32 = get_ptr( &args );
494 D3DKMT_DESTROYDCFROMMEMORY desc;
495
496 if (!desc32) return STATUS_INVALID_PARAMETER;
497 desc.hDc = UlongToHandle( desc32->hDc );
498 desc.hBitmap = UlongToHandle( desc32->hBitmap );
499
500 return NtGdiDdDDIDestroyDCFromMemory( &desc );
501 }
502
503 NTSTATUS WINAPI wow64_NtGdiDdDDIDestroyDevice( UINT *args )
504 {
505 const D3DKMT_DESTROYDEVICE *desc = get_ptr( &args );
506
507 return NtGdiDdDDIDestroyDevice( desc );
508 }
509
510 NTSTATUS WINAPI wow64_NtGdiDdDDIEnumAdapters2( UINT *args )
511 {
512 struct
513 {
514 ULONG NumAdapters;
515 ULONG pAdapters;
516 } *desc32 = get_ptr( &args );
517 D3DKMT_ENUMADAPTERS2 desc;
518 NTSTATUS status;
519
520 if (!desc32) return STATUS_INVALID_PARAMETER;
521
522 desc.NumAdapters = desc32->NumAdapters;
523 desc.pAdapters = UlongToPtr( desc32->pAdapters );
524
525 status = NtGdiDdDDIEnumAdapters2( &desc );
526
527 desc32->NumAdapters = desc.NumAdapters;
528
529 return status;
530 }
531
532 NTSTATUS WINAPI wow64_NtGdiDdDDIEscape( UINT *args )
533 {
534 const struct
535 {
536 D3DKMT_HANDLE hAdapter;
537 D3DKMT_HANDLE hDevice;
538 D3DKMT_ESCAPETYPE Type;
539 D3DDDI_ESCAPEFLAGS Flags;
540 ULONG pPrivateDriverData;
541 UINT PrivateDriverDataSize;
542 D3DKMT_HANDLE hContext;
543 } *desc32 = get_ptr( &args );
544 D3DKMT_ESCAPE desc;
545
546 if (!desc32) return STATUS_INVALID_PARAMETER;
547 desc.hAdapter = desc32->hAdapter;
548 desc.hDevice = desc32->hDevice;
549 desc.Type = desc32->Type;
550 desc.Flags = desc32->Flags;
551 desc.pPrivateDriverData = UlongToPtr( desc32->pPrivateDriverData );
552 desc.PrivateDriverDataSize = desc32->PrivateDriverDataSize;
553 desc.hContext = desc32->hContext;
554
555 return NtGdiDdDDIEscape( &desc );
556 }
557
558 NTSTATUS WINAPI wow64_NtGdiDdDDIOpenAdapterFromDeviceName( UINT *args )
559 {
560 struct _D3DKMT_OPENADAPTERFROMDEVICENAME
561 {
562 ULONG pDeviceName;
563 D3DKMT_HANDLE hAdapter;
564 LUID AdapterLuid;
565 } *desc32 = get_ptr( &args );
566 D3DKMT_OPENADAPTERFROMDEVICENAME desc;
567 NTSTATUS status;
568
569 if (!desc32) return STATUS_INVALID_PARAMETER;
570 desc.pDeviceName = UlongToPtr( desc32->pDeviceName );
571
572 if (!(status = NtGdiDdDDIOpenAdapterFromDeviceName( &desc )))
573 {
574 desc32->hAdapter = desc.hAdapter;
575 desc32->AdapterLuid = desc.AdapterLuid;
576 }
577 return status;
578 }
579
580 NTSTATUS WINAPI wow64_NtGdiDdDDIOpenAdapterFromHdc( UINT *args )
581 {
582 struct
583 {
584 ULONG hDc;
585 D3DKMT_HANDLE hAdapter;
586 LUID AdapterLuid;
587 D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId;
588 } *desc32 = get_ptr( &args );
589
590 D3DKMT_OPENADAPTERFROMHDC desc;
591 NTSTATUS status;
592
593 if (!desc32) return STATUS_INVALID_PARAMETER;
594 desc.hDc = UlongToHandle( desc32->hDc );
595 if (!(status = NtGdiDdDDIOpenAdapterFromHdc( &desc )))
596 {
597 desc32->hAdapter = desc.hAdapter;
598 desc32->AdapterLuid = desc.AdapterLuid;
599 desc32->VidPnSourceId = desc.VidPnSourceId;
600 }
601 return status;
602 }
603
604 NTSTATUS WINAPI wow64_NtGdiDdDDIOpenAdapterFromLuid( UINT *args )
605 {
606 D3DKMT_OPENADAPTERFROMLUID *desc = get_ptr( &args );
607
608 return NtGdiDdDDIOpenAdapterFromLuid( desc );
609 }
610
611 NTSTATUS WINAPI wow64_NtGdiDdDDIQueryAdapterInfo( UINT *args )
612 {
613 struct _D3DKMT_QUERYADAPTERINFO
614 {
615 D3DKMT_HANDLE hAdapter;
616 KMTQUERYADAPTERINFOTYPE Type;
617 ULONG pPrivateDriverData;
618 UINT PrivateDriverDataSize;
619 } *desc32 = get_ptr( &args );
620 D3DKMT_QUERYADAPTERINFO desc;
621
622 if (!desc32) return STATUS_INVALID_PARAMETER;
623
624 desc.hAdapter = desc32->hAdapter;
625 desc.Type = desc32->Type;
626 desc.pPrivateDriverData = UlongToPtr( desc32->pPrivateDriverData );
627 desc.PrivateDriverDataSize = desc32->PrivateDriverDataSize;
628
629 return NtGdiDdDDIQueryAdapterInfo( &desc );
630 }
631
632 NTSTATUS WINAPI wow64_NtGdiDdDDIQueryStatistics( UINT *args )
633 {
634 D3DKMT_QUERYSTATISTICS *stats = get_ptr( &args );
635
636 return NtGdiDdDDIQueryStatistics( stats );
637 }
638
639 NTSTATUS WINAPI wow64_NtGdiDdDDIQueryVideoMemoryInfo( UINT *args )
640 {
641 struct _D3DKMT_QUERYVIDEOMEMORYINFO
642 {
643 ULONG hProcess;
644 D3DKMT_HANDLE hAdapter;
645 D3DKMT_MEMORY_SEGMENT_GROUP MemorySegmentGroup;
646 UINT64 Budget;
647 UINT64 CurrentUsage;
648 UINT64 CurrentReservation;
649 UINT64 AvailableForReservation;
650 UINT PhysicalAdapterIndex;
651 } *desc32 = get_ptr( &args );
652 D3DKMT_QUERYVIDEOMEMORYINFO desc;
653 NTSTATUS status;
654
655 if (!desc32) return STATUS_INVALID_PARAMETER;
656 desc.hProcess = LongToHandle( desc32->hProcess );
657 desc.hAdapter = desc32->hAdapter;
658 desc.MemorySegmentGroup = desc32->MemorySegmentGroup;
659 desc.PhysicalAdapterIndex = desc32->PhysicalAdapterIndex;
660
661 if (!(status = NtGdiDdDDIQueryVideoMemoryInfo( &desc )))
662 {
663 desc32->Budget = desc.Budget;
664 desc32->CurrentUsage = desc.CurrentUsage;
665 desc32->CurrentReservation = desc.CurrentReservation;
666 desc32->AvailableForReservation = desc.AvailableForReservation;
667 }
668 return status;
669 }
670
671 NTSTATUS WINAPI wow64_NtGdiDdDDISetQueuedLimit( UINT *args )
672 {
673 D3DKMT_SETQUEUEDLIMIT *desc = get_ptr( &args );
674
675 return NtGdiDdDDISetQueuedLimit( desc );
676 }
677
678 NTSTATUS WINAPI wow64_NtGdiDdDDISetVidPnSourceOwner( UINT *args )
679 {
680 const struct
681 {
682 D3DKMT_HANDLE hDevice;
683 ULONG pType;
684 ULONG pVidPnSourceId;
685 UINT VidPnSourceCount;
686 } *desc32 = get_ptr( &args );
687 D3DKMT_SETVIDPNSOURCEOWNER desc;
688
689 if (!desc32) return STATUS_INVALID_PARAMETER;
690 desc.hDevice = desc32->hDevice;
691 desc.pType = UlongToPtr( desc32->pType );
692 desc.pVidPnSourceId = UlongToPtr( desc32->pVidPnSourceId );
693 desc.VidPnSourceCount = desc32->VidPnSourceCount;
694
695 return NtGdiDdDDISetVidPnSourceOwner( &desc );
696 }
697
698 NTSTATUS WINAPI wow64_NtGdiDeleteClientObj( UINT *args )
699 {
700 HGDIOBJ obj = get_handle( &args );
701
702 return NtGdiDeleteClientObj( obj );
703 }
704
705 NTSTATUS WINAPI wow64_NtGdiDeleteObjectApp( UINT *args )
706 {
707 HGDIOBJ obj = get_handle( &args );
708
709 return NtGdiDeleteObjectApp( obj );
710 }
711
712 NTSTATUS WINAPI wow64_NtGdiDescribePixelFormat( UINT *args )
713 {
714 HDC hdc = get_handle( &args );
715 INT format = get_ulong( &args );
716 UINT size = get_ulong( &args );
717 PIXELFORMATDESCRIPTOR *descr = get_ptr( &args );
718
719 return NtGdiDescribePixelFormat( hdc, format, size, descr );
720 }
721
722 NTSTATUS WINAPI wow64_NtGdiDoPalette( UINT *args )
723 {
724 HGDIOBJ handle = get_handle( &args );
725 WORD start = get_ulong( &args );
726 WORD count = get_ulong( &args );
727 void *entries = get_ptr( &args );
728 DWORD func = get_ulong( &args );
729 BOOL inbound = get_ulong( &args );
730
731 return NtGdiDoPalette( handle, start, count, entries, func, inbound );
732 }
733
734 NTSTATUS WINAPI wow64_NtGdiDrawStream( UINT *args )
735 {
736 HDC hdc = get_handle( &args );
737 ULONG in = get_ulong( &args );
738 void *pvin = get_ptr( &args );
739
740 return NtGdiDrawStream( hdc, in, pvin );
741 }
742
743 NTSTATUS WINAPI wow64_NtGdiEllipse( UINT *args )
744 {
745 HDC hdc = get_handle( &args );
746 INT left = get_ulong( &args );
747 INT top = get_ulong( &args );
748 INT right = get_ulong( &args );
749 INT bottom = get_ulong( &args );
750
751 return NtGdiEllipse( hdc, left, top, right, bottom );
752 }
753
754 NTSTATUS WINAPI wow64_NtGdiEndDoc( UINT *args )
755 {
756 HDC hdc = get_handle( &args );
757
758 return NtGdiEndDoc( hdc );
759 }
760
761 NTSTATUS WINAPI wow64_NtGdiEndPage( UINT *args )
762 {
763 HDC hdc = get_handle( &args );
764
765 return NtGdiEndPage( hdc );
766 }
767
768 NTSTATUS WINAPI wow64_NtGdiEndPath( UINT *args )
769 {
770 HDC hdc = get_handle( &args );
771
772 return NtGdiEndPath( hdc );
773 }
774
775 NTSTATUS WINAPI wow64_NtGdiEnumFonts( UINT *args )
776 {
777 HDC hdc = get_handle( &args );
778 ULONG type = get_ulong( &args );
779 ULONG win32_compat = get_ulong( &args );
780 ULONG face_name_len = get_ulong( &args );
781 const WCHAR *face_name = get_ptr( &args );
782 ULONG charset = get_ulong( &args );
783 ULONG *count = get_ptr( &args );
784 void *buf = get_ptr( &args );
785
786 return NtGdiEnumFonts( hdc, type, win32_compat, face_name_len, face_name, charset, count, buf );
787 }
788
789 NTSTATUS WINAPI wow64_NtGdiExcludeClipRect( UINT *args )
790 {
791 HDC hdc = get_handle( &args );
792 INT left = get_ulong( &args );
793 INT top = get_ulong( &args );
794 INT right = get_ulong( &args );
795 INT bottom = get_ulong( &args );
796
797 return NtGdiExcludeClipRect( hdc, left, top, right, bottom );
798 }
799
800 NTSTATUS WINAPI wow64_NtGdiEqualRgn( UINT *args )
801 {
802 HRGN hrgn1 = get_handle( &args );
803 HRGN hrgn2 = get_handle( &args );
804
805 return NtGdiEqualRgn( hrgn1, hrgn2 );
806 }
807
808 NTSTATUS WINAPI wow64_NtGdiExtCreatePen( UINT *args )
809 {
810 DWORD style = get_ulong( &args );
811 DWORD width = get_ulong( &args );
812 ULONG brush_style = get_ulong( &args );
813 ULONG color = get_ulong( &args );
814 ULONG_PTR client_hatch = get_ulong( &args );
815 ULONG_PTR hatch = get_ulong( &args );
816 DWORD style_count = get_ulong( &args );
817 const DWORD *style_bits = get_ptr( &args );
818 ULONG dib_size = get_ulong( &args );
819 BOOL old_style = get_ulong( &args );
820 HBRUSH brush = get_handle( &args );
821
822 return HandleToUlong( NtGdiExtCreatePen( style, width, brush_style, color, client_hatch,
823 hatch, style_count, style_bits, dib_size,
824 old_style, brush ));
825 }
826
827 NTSTATUS WINAPI wow64_NtGdiExtCreateRegion( UINT *args )
828 {
829 const XFORM *xform = get_ptr( &args );
830 DWORD count = get_ulong( &args );
831 const RGNDATA *data = get_ptr( &args );
832
833 return HandleToUlong( NtGdiExtCreateRegion( xform, count, data ));
834 }
835
836 NTSTATUS WINAPI wow64_NtGdiExtEscape( UINT *args )
837 {
838 HDC hdc = get_handle( &args );
839 WCHAR *driver = get_ptr( &args );
840 INT driver_id = get_ulong( &args );
841 INT escape = get_ulong( &args );
842 INT input_size = get_ulong( &args );
843 const char *input = get_ptr( &args );
844 INT output_size = get_ulong( &args );
845 char *output = get_ptr( &args );
846
847 return NtGdiExtEscape( hdc, driver, driver_id, escape, input_size, input, output_size, output );
848 }
849
850 NTSTATUS WINAPI wow64_NtGdiExtFloodFill( UINT *args )
851 {
852 HDC hdc = get_handle( &args );
853 INT x = get_ulong( &args );
854 INT y = get_ulong( &args );
855 COLORREF color = get_ulong( &args );
856 UINT type = get_ulong( &args );
857
858 return NtGdiExtFloodFill( hdc, x, y, color, type );
859 }
860
861 NTSTATUS WINAPI wow64_NtGdiExtGetObjectW( UINT *args )
862 {
863 HGDIOBJ handle = get_handle( &args );
864 INT count = get_ulong( &args );
865 void *buffer = get_ptr( &args );
866
867 switch (gdi_handle_type( handle ))
868 {
869 case NTGDI_OBJ_BITMAP:
870 {
871 BITMAP32 *bitmap32 = buffer;
872 struct
873 {
874 BITMAP32 dsBm;
875 BITMAPINFOHEADER dsBmih;
876 DWORD dsBitfields[3];
877 ULONG dshSection;
878 DWORD dsOffset;
879 } *dib32 = buffer;
880 DIBSECTION dib;
881 int ret;
882
883 if (buffer)
884 {
885 if (count < sizeof(*bitmap32)) return 0;
886 count = count < sizeof(*dib32) ? sizeof(BITMAP) : sizeof(DIBSECTION);
887 }
888
889 if (!(ret = NtGdiExtGetObjectW( handle, count, buffer ? &dib : NULL ))) return 0;
890
891 if (bitmap32)
892 {
893 bitmap32->bmType = dib.dsBm.bmType;
894 bitmap32->bmWidth = dib.dsBm.bmWidth;
895 bitmap32->bmHeight = dib.dsBm.bmHeight;
896 bitmap32->bmWidthBytes = dib.dsBm.bmWidthBytes;
897 bitmap32->bmPlanes = dib.dsBm.bmPlanes;
898 bitmap32->bmBitsPixel = dib.dsBm.bmBitsPixel;
899 bitmap32->bmBits = PtrToUlong( dib.dsBm.bmBits );
900 }
901 if (ret != sizeof(dib)) return sizeof(*bitmap32);
902
903 if (dib32)
904 {
905 dib32->dsBmih = dib.dsBmih;
906 dib32->dsBitfields[0] = dib.dsBitfields[0];
907 dib32->dsBitfields[1] = dib.dsBitfields[1];
908 dib32->dsBitfields[2] = dib.dsBitfields[2];
909 dib32->dshSection = HandleToUlong( dib.dshSection );
910 dib32->dsOffset = dib.dsOffset;
911 }
912 return sizeof(*dib32);
913 }
914
915 case NTGDI_OBJ_PEN:
916 case NTGDI_OBJ_EXTPEN:
917 {
918 EXTLOGPEN32 *pen32 = buffer;
919 EXTLOGPEN *pen = NULL;
920
921 if (count == sizeof(LOGPEN) || (buffer && !HIWORD( buffer )))
922 return NtGdiExtGetObjectW( handle, count, buffer );
923
924 if (pen32 && count && !(pen = Wow64AllocateTemp( count + sizeof(ULONG) ))) return 0;
925 count = NtGdiExtGetObjectW( handle, count + sizeof(ULONG), pen );
926
927 if (count == sizeof(LOGPEN))
928 {
929 if (buffer) memcpy( buffer, pen, count );
930 }
931 else if (count)
932 {
933 if (pen32)
934 {
935 pen32->elpPenStyle = pen->elpPenStyle;
936 pen32->elpWidth = pen->elpWidth;
937 pen32->elpBrushStyle = pen->elpBrushStyle;
938 pen32->elpColor = pen->elpColor;
939 pen32->elpHatch = pen->elpHatch;
940 pen32->elpNumEntries = pen->elpNumEntries;
941 }
942 count -= FIELD_OFFSET( EXTLOGPEN, elpStyleEntry );
943 if (count && pen32) memcpy( pen32->elpStyleEntry, pen->elpStyleEntry, count );
944 count += FIELD_OFFSET( EXTLOGPEN32, elpStyleEntry );
945 }
946 return count;
947 }
948
949 default:
950 return NtGdiExtGetObjectW( handle, count, buffer );
951 }
952 }
953
954 NTSTATUS WINAPI wow64_NtGdiExtSelectClipRgn( UINT *args )
955 {
956 HDC hdc = get_handle( &args );
957 HRGN region = get_handle( &args );
958 INT mode = get_ulong( &args );
959
960 return NtGdiExtSelectClipRgn( hdc, region, mode );
961 }
962
963 NTSTATUS WINAPI wow64_NtGdiExtTextOutW( UINT *args )
964 {
965 HDC hdc = get_handle( &args );
966 INT x = get_ulong( &args );
967 INT y = get_ulong( &args );
968 UINT flags = get_ulong( &args );
969 const RECT *rect = get_ptr( &args );
970 const WCHAR *str = get_ptr( &args );
971 UINT count = get_ulong( &args );
972 const INT *dx = get_ptr( &args );
973 DWORD cp = get_ulong( &args );
974
975 return NtGdiExtTextOutW( hdc, x, y, flags, rect, str, count, dx, cp );
976 }
977
978 NTSTATUS WINAPI wow64_NtGdiFillPath( UINT *args )
979 {
980 HDC hdc = get_handle( &args );
981
982 return NtGdiFillPath( hdc );
983 }
984
985 NTSTATUS WINAPI wow64_NtGdiFillRgn( UINT *args )
986 {
987 HDC hdc = get_handle( &args );
988 HRGN hrgn = get_handle( &args );
989 HBRUSH hbrush = get_handle( &args );
990
991 return NtGdiFillRgn( hdc, hrgn, hbrush );
992 }
993
994 NTSTATUS WINAPI wow64_NtGdiFlattenPath( UINT *args )
995 {
996 HDC hdc = get_handle( &args );
997
998 return NtGdiFlattenPath( hdc );
999 }
1000
1001 NTSTATUS WINAPI wow64_NtGdiFlush( UINT *args )
1002 {
1003 return NtGdiFlush();
1004 }
1005
1006 NTSTATUS WINAPI wow64_NtGdiFontIsLinked( UINT *args )
1007 {
1008 HDC hdc = get_handle( &args );
1009
1010 return NtGdiFontIsLinked( hdc );
1011 }
1012
1013 NTSTATUS WINAPI wow64_NtGdiFrameRgn( UINT *args )
1014 {
1015 HDC hdc = get_handle( &args );
1016 HRGN hrgn = get_handle( &args );
1017 HBRUSH brush = get_handle( &args );
1018 INT width = get_ulong( &args );
1019 INT height = get_ulong( &args );
1020
1021 return NtGdiFrameRgn( hdc, hrgn, brush, width, height );
1022 }
1023
1024 NTSTATUS WINAPI wow64_NtGdiGetAndSetDCDword( UINT *args )
1025 {
1026 HDC hdc = get_handle( &args );
1027 UINT method = get_ulong( &args );
1028 DWORD value = get_ulong( &args );
1029 DWORD *result = get_ptr( &args );
1030
1031 return NtGdiGetAndSetDCDword( hdc, method, value, result );
1032 }
1033
1034 NTSTATUS WINAPI wow64_NtGdiGetAppClipBox( UINT *args )
1035 {
1036 HDC hdc = get_handle( &args );
1037 RECT *rect = get_ptr( &args );
1038
1039 return NtGdiGetAppClipBox( hdc, rect );
1040 }
1041
1042 NTSTATUS WINAPI wow64_NtGdiGetBitmapBits( UINT *args )
1043 {
1044 HBITMAP bitmap = get_handle( &args );
1045 LONG count = get_ulong( &args );
1046 void *bits = get_ptr( &args );
1047
1048 return NtGdiGetBitmapBits( bitmap, count, bits );
1049 }
1050
1051 NTSTATUS WINAPI wow64_NtGdiGetBitmapDimension( UINT *args )
1052 {
1053 HBITMAP bitmap = get_handle( &args );
1054 SIZE *size = get_ptr( &args );
1055
1056 return NtGdiGetBitmapDimension( bitmap, size );
1057 }
1058
1059 NTSTATUS WINAPI wow64_NtGdiGetBoundsRect( UINT *args )
1060 {
1061 HDC hdc = get_handle( &args );
1062 RECT *rect = get_ptr( &args );
1063 UINT flags = get_ulong( &args );
1064
1065 return NtGdiGetBoundsRect( hdc, rect, flags );
1066 }
1067
1068 NTSTATUS WINAPI wow64_NtGdiGetCharABCWidthsW( UINT *args )
1069 {
1070 HDC hdc = get_handle( &args );
1071 UINT first = get_ulong( &args );
1072 UINT last = get_ulong( &args );
1073 WCHAR *chars = get_ptr( &args );
1074 ULONG flags = get_ulong( &args );
1075 void *buffer = get_ptr( &args );
1076
1077 return NtGdiGetCharABCWidthsW( hdc, first, last, chars, flags, buffer );
1078 }
1079
1080 NTSTATUS WINAPI wow64_NtGdiGetCharWidthW( UINT *args )
1081 {
1082 HDC hdc = get_handle( &args );
1083 UINT first_char = get_ulong( &args );
1084 UINT last_char = get_ulong( &args );
1085 WCHAR *chars = get_ptr( &args );
1086 ULONG flags = get_ulong( &args );
1087 void *buffer = get_ptr( &args );
1088
1089 return NtGdiGetCharWidthW( hdc, first_char, last_char, chars, flags, buffer );
1090 }
1091
1092 NTSTATUS WINAPI wow64_NtGdiGetCharWidthInfo( UINT *args )
1093 {
1094 HDC hdc = get_handle( &args );
1095 struct char_width_info *info = get_ptr( &args );
1096
1097 return NtGdiGetCharWidthInfo( hdc, info );
1098 }
1099
1100 NTSTATUS WINAPI wow64_NtGdiGetColorAdjustment( UINT *args )
1101 {
1102 HDC hdc = get_handle( &args );
1103 COLORADJUSTMENT *ca = get_ptr( &args );
1104
1105 return NtGdiGetColorAdjustment( hdc, ca );
1106 }
1107
1108 NTSTATUS WINAPI wow64_NtGdiGetDCDword( UINT *args )
1109 {
1110 HDC hdc = get_handle( &args );
1111 UINT method = get_ulong( &args );
1112 DWORD *result = get_ptr( &args );
1113
1114 return NtGdiGetDCDword( hdc, method, result );
1115 }
1116
1117 NTSTATUS WINAPI wow64_NtGdiGetDCObject( UINT *args )
1118 {
1119 HDC hdc = get_handle( &args );
1120 UINT type = get_ulong( &args );
1121
1122 return HandleToUlong( NtGdiGetDCObject( hdc, type ));
1123 }
1124
1125 NTSTATUS WINAPI wow64_NtGdiGetDCPoint( UINT *args )
1126 {
1127 HDC hdc = get_handle( &args );
1128 UINT method = get_ulong( &args );
1129 POINT *result = get_ptr( &args );
1130
1131 return NtGdiGetDCPoint( hdc, method, result );
1132 }
1133
1134 NTSTATUS WINAPI wow64_NtGdiGetDIBitsInternal( UINT *args )
1135 {
1136 HDC hdc = get_handle( &args );
1137 HBITMAP hbitmap = get_handle( &args );
1138 UINT startscan = get_ulong( &args );
1139 UINT lines = get_ulong( &args );
1140 void *bits = get_ptr( &args );
1141 BITMAPINFO *info = get_ptr( &args );
1142 UINT coloruse = get_ulong( &args );
1143 UINT max_bits = get_ulong( &args );
1144 UINT max_info = get_ulong( &args );
1145
1146 return NtGdiGetDIBitsInternal( hdc, hbitmap, startscan, lines, bits, info, coloruse,
1147 max_bits, max_info );
1148 }
1149
1150 NTSTATUS WINAPI wow64_NtGdiGetDeviceCaps( UINT *args )
1151 {
1152 HDC hdc = get_handle( &args );
1153 INT cap = get_ulong( &args );
1154
1155 return NtGdiGetDeviceCaps( hdc, cap );
1156 }
1157
1158 NTSTATUS WINAPI wow64_NtGdiGetDeviceGammaRamp( UINT *args )
1159 {
1160 HDC hdc = get_handle( &args );
1161 void *ptr = get_ptr( &args );
1162
1163 return NtGdiGetDeviceGammaRamp( hdc, ptr );
1164 }
1165
1166 NTSTATUS WINAPI wow64_NtGdiGetFontData( UINT *args )
1167 {
1168 HDC hdc = get_handle( &args );
1169 DWORD table = get_ulong( &args );
1170 DWORD offset = get_ulong( &args );
1171 void *buffer = get_ptr( &args );
1172 DWORD length = get_ulong( &args );
1173
1174 return NtGdiGetFontData( hdc, table, offset, buffer, length );
1175 }
1176
1177 NTSTATUS WINAPI wow64_NtGdiGetFontFileData( UINT *args )
1178 {
1179 DWORD instance_id = get_ulong( &args );
1180 DWORD file_index = get_ulong( &args );
1181 UINT64 *offset = get_ptr( &args );
1182 void *buff = get_ptr( &args );
1183 SIZE_T buff_size = get_ulong( &args );
1184
1185 return NtGdiGetFontFileData( instance_id, file_index, offset, buff, buff_size );
1186 }
1187
1188 NTSTATUS WINAPI wow64_NtGdiGetFontFileInfo( UINT *args )
1189 {
1190 DWORD instance_id = get_ulong( &args );
1191 DWORD file_index = get_ulong( &args );
1192 struct font_fileinfo *info = get_ptr( &args );
1193 SIZE_T size = get_ulong( &args );
1194 ULONG *needed32 = get_ptr( &args );
1195
1196 SIZE_T needed;
1197 BOOL ret;
1198
1199 ret = NtGdiGetFontFileInfo( instance_id, file_index, info, size, size_32to64( &needed, needed32 ));
1200 put_size( needed32, needed );
1201 return ret;
1202 }
1203
1204 NTSTATUS WINAPI wow64_NtGdiGetFontUnicodeRanges( UINT *args )
1205 {
1206 HDC hdc = get_handle( &args );
1207 GLYPHSET *lpgs = get_ptr( &args );
1208
1209 return NtGdiGetFontUnicodeRanges( hdc, lpgs );
1210 }
1211
1212 NTSTATUS WINAPI wow64_NtGdiGetGlyphIndicesW( UINT *args )
1213 {
1214 HDC hdc = get_handle( &args );
1215 const WCHAR *str = get_ptr( &args );
1216 INT count = get_ulong( &args );
1217 WORD *indices = get_ptr( &args );
1218 DWORD flags = get_ulong( &args );
1219
1220 return NtGdiGetGlyphIndicesW( hdc, str, count, indices, flags );
1221 }
1222
1223 NTSTATUS WINAPI wow64_NtGdiGetGlyphOutline( UINT *args )
1224 {
1225 HDC hdc = get_handle( &args );
1226 UINT ch = get_ulong( &args );
1227 UINT format = get_ulong( &args );
1228 GLYPHMETRICS *metrics = get_ptr( &args );
1229 DWORD size = get_ulong( &args );
1230 void *buffer = get_ptr( &args );
1231 const MAT2 *mat2 = get_ptr( &args );
1232 BOOL ignore_rotation = get_ulong( &args );
1233
1234 return NtGdiGetGlyphOutline( hdc, ch, format, metrics, size, buffer, mat2, ignore_rotation );
1235 }
1236
1237 NTSTATUS WINAPI wow64_NtGdiGetKerningPairs( UINT *args )
1238 {
1239 HDC hdc = get_handle( &args );
1240 DWORD count = get_ulong( &args );
1241 KERNINGPAIR *kern_pair = get_ptr( &args );
1242
1243 return NtGdiGetKerningPairs( hdc, count, kern_pair );
1244 }
1245
1246 NTSTATUS WINAPI wow64_NtGdiGetNearestColor( UINT *args )
1247 {
1248 HDC hdc = get_handle( &args );
1249 COLORREF color = get_ulong( &args );
1250
1251 return NtGdiGetNearestColor( hdc, color );
1252 }
1253
1254 NTSTATUS WINAPI wow64_NtGdiGetNearestPaletteIndex( UINT *args )
1255 {
1256 HPALETTE hpalette = get_handle( &args );
1257 COLORREF color = get_ulong( &args );
1258
1259 return NtGdiGetNearestPaletteIndex( hpalette, color );
1260 }
1261
1262 NTSTATUS WINAPI wow64_NtGdiGetOutlineTextMetricsInternalW( UINT *args )
1263 {
1264 HDC hdc = get_handle( &args );
1265 UINT size = get_ulong( &args );
1266 OUTLINETEXTMETRIC32 *otm32 = get_ptr( &args );
1267 ULONG opts = get_ulong( &args );
1268
1269 OUTLINETEXTMETRICW *otm, otm_buf;
1270 UINT ret, size64;
1271 static const size_t otm_size_diff = sizeof(*otm) - sizeof(*otm32);
1272
1273 if (!otm32)
1274 {
1275 size64 = 0;
1276 otm = NULL;
1277 }
1278 else if (size <= sizeof(*otm32))
1279 {
1280 size64 = sizeof(otm_buf);
1281 otm = &otm_buf;
1282 }
1283 else
1284 {
1285 size64 = size + otm_size_diff;
1286 if (!(otm = Wow64AllocateTemp( size64 ))) return 0;
1287 }
1288
1289 if (!(ret = NtGdiGetOutlineTextMetricsInternalW( hdc, size64, otm, opts ))) return 0;
1290
1291 if (otm32)
1292 {
1293 OUTLINETEXTMETRIC32 out;
1294
1295 memcpy( &out, otm, FIELD_OFFSET( OUTLINETEXTMETRIC32, otmpFamilyName ));
1296 if (out.otmSize >= sizeof(*otm)) out.otmSize -= otm_size_diff;
1297
1298 if (!otm->otmpFamilyName) out.otmpFamilyName = 0;
1299 else out.otmpFamilyName = PtrToUlong( otm->otmpFamilyName ) - otm_size_diff;
1300
1301 if (!otm->otmpFaceName) out.otmpFaceName = 0;
1302 else out.otmpFaceName = PtrToUlong( otm->otmpFaceName ) - otm_size_diff;
1303
1304 if (!otm->otmpStyleName) out.otmpStyleName = 0;
1305 else out.otmpStyleName = PtrToUlong( otm->otmpStyleName ) - otm_size_diff;
1306
1307 if (!otm->otmpFullName) out.otmpFullName = 0;
1308 else out.otmpFullName = PtrToUlong( otm->otmpFullName ) - otm_size_diff;
1309
1310 memcpy( otm32, &out, min( size, sizeof(out) ));
1311 if (ret > sizeof(*otm)) memcpy( otm32 + 1, otm + 1, ret - sizeof(*otm) );
1312 }
1313
1314 return ret >= sizeof(*otm) ? ret - otm_size_diff : ret;
1315 }
1316
1317 NTSTATUS WINAPI wow64_NtGdiGetPath( UINT *args )
1318 {
1319 HDC hdc = get_handle( &args );
1320 POINT *points = get_ptr( &args );
1321 BYTE *types = get_ptr( &args );
1322 INT size = get_ulong( &args );
1323
1324 return NtGdiGetPath( hdc, points, types, size );
1325 }
1326
1327 NTSTATUS WINAPI wow64_NtGdiGetPixel( UINT *args )
1328 {
1329 HDC hdc = get_handle( &args );
1330 INT x = get_ulong( &args );
1331 INT y = get_ulong( &args );
1332
1333 return NtGdiGetPixel( hdc, x, y );
1334 }
1335
1336 NTSTATUS WINAPI wow64_NtGdiGetRandomRgn( UINT *args )
1337 {
1338 HDC hdc = get_handle( &args );
1339 HRGN region = get_handle( &args );
1340 INT code = get_ulong( &args );
1341
1342 return NtGdiGetRandomRgn( hdc, region, code );
1343 }
1344
1345 NTSTATUS WINAPI wow64_NtGdiGetRasterizerCaps( UINT *args )
1346 {
1347 RASTERIZER_STATUS *status = get_ptr( &args );
1348 UINT size = get_ulong( &args );
1349
1350 return NtGdiGetRasterizerCaps( status, size );
1351 }
1352
1353 NTSTATUS WINAPI wow64_NtGdiGetRealizationInfo( UINT *args )
1354 {
1355 HDC hdc = get_handle( &args );
1356 struct font_realization_info *info = get_ptr( &args );
1357
1358 return NtGdiGetRealizationInfo( hdc, info );
1359 }
1360
1361 NTSTATUS WINAPI wow64_NtGdiGetRegionData( UINT *args )
1362 {
1363 HRGN hrgn = get_ptr( &args );
1364 DWORD count = get_ulong( &args );
1365 RGNDATA *data = get_ptr( &args );
1366
1367 return NtGdiGetRegionData( hrgn, count, data );
1368 }
1369
1370 NTSTATUS WINAPI wow64_NtGdiGetTextCharsetInfo( UINT *args )
1371 {
1372 HDC hdc = get_ptr( &args );
1373 FONTSIGNATURE *fs = get_ptr( &args );
1374 DWORD flags = get_ulong( &args );
1375
1376 return NtGdiGetTextCharsetInfo( hdc, fs, flags );
1377 }
1378
1379 NTSTATUS WINAPI wow64_NtGdiGetTextExtentExW( UINT *args )
1380 {
1381 HDC hdc = get_handle( &args );
1382 const WCHAR *str = get_ptr( &args );
1383 INT count = get_ulong( &args );
1384 INT max_ext = get_ulong( &args );
1385 INT *nfit = get_ptr( &args );
1386 INT *dxs = get_ptr( &args );
1387 SIZE *size = get_ptr( &args );
1388 UINT flags = get_ulong( &args );
1389
1390 return NtGdiGetTextExtentExW( hdc, str, count, max_ext, nfit, dxs, size, flags );
1391 }
1392
1393 NTSTATUS WINAPI wow64_NtGdiGetTextFaceW( UINT *args )
1394 {
1395 HDC hdc = get_handle( &args );
1396 INT count = get_ulong( &args );
1397 WCHAR *name = get_ptr( &args );
1398 BOOL alias_name = get_ulong( &args );
1399
1400 return NtGdiGetTextFaceW( hdc, count, name, alias_name );
1401 }
1402
1403 NTSTATUS WINAPI wow64_NtGdiGetTextMetricsW( UINT *args )
1404 {
1405 HDC hdc = get_handle( &args );
1406 TEXTMETRICW *metrics = get_ptr( &args );
1407 ULONG flags = get_ulong( &args );
1408
1409 return NtGdiGetTextMetricsW( hdc, metrics, flags );
1410 }
1411
1412 NTSTATUS WINAPI wow64_NtGdiGradientFill( UINT *args )
1413 {
1414 HDC hdc = get_handle( &args );
1415 TRIVERTEX *vert_array = get_ptr( &args );
1416 ULONG nvert = get_ulong( &args );
1417 void *grad_array = get_ptr( &args );
1418 ULONG ngrad = get_ulong( &args );
1419 ULONG mode = get_ulong( &args );
1420
1421 return NtGdiGradientFill( hdc, vert_array, nvert, grad_array, ngrad, mode );
1422 }
1423
1424 NTSTATUS WINAPI wow64_NtGdiIcmBrushInfo( UINT *args )
1425 {
1426 HDC hdc = get_handle( &args );
1427 HBRUSH handle = get_handle( &args );
1428 BITMAPINFO *info = get_ptr( &args );
1429 void *bits = get_ptr( &args );
1430 ULONG *bits_size = get_ptr( &args );
1431 UINT *usage = get_ptr( &args );
1432 BOOL *unk = get_ptr( &args );
1433 UINT mode = get_ulong( &args );
1434
1435 return NtGdiIcmBrushInfo( hdc, handle, info, bits, bits_size, usage, unk, mode );
1436 }
1437
1438 NTSTATUS WINAPI wow64_NtGdiInvertRgn( UINT *args )
1439 {
1440 HDC hdc = get_handle( &args );
1441 HRGN hrgn = get_handle( &args );
1442
1443 return NtGdiInvertRgn( hdc, hrgn );
1444 }
1445
1446 NTSTATUS WINAPI wow64_NtGdiLineTo( UINT *args )
1447 {
1448 HDC hdc = get_handle( &args );
1449 INT x = get_ulong( &args );
1450 INT y = get_ulong( &args );
1451
1452 return NtGdiLineTo( hdc, x, y );
1453 }
1454
1455 NTSTATUS WINAPI wow64_NtGdiMaskBlt( UINT *args )
1456 {
1457 HDC hdc = get_handle( &args );
1458 INT x_dst = get_ulong( &args );
1459 INT y_dst = get_ulong( &args );
1460 INT width_dst = get_ulong( &args );
1461 INT height_dst = get_ulong( &args );
1462 HDC hdc_src = get_handle( &args );
1463 INT x_src = get_ulong( &args );
1464 INT y_src = get_ulong( &args );
1465 HBITMAP mask = get_handle( &args );
1466 INT x_mask = get_ulong( &args );
1467 INT y_mask = get_ulong( &args );
1468 DWORD rop = get_ulong( &args );
1469 DWORD bk_color = get_ulong( &args );
1470
1471 return NtGdiMaskBlt( hdc, x_dst, y_dst, width_dst, height_dst, hdc_src,
1472 x_src, y_src, mask, x_mask, y_mask, rop, bk_color );
1473 }
1474
1475 NTSTATUS WINAPI wow64_NtGdiModifyWorldTransform( UINT *args )
1476 {
1477 HDC hdc = get_handle( &args );
1478 const XFORM *xform = get_ptr( &args );
1479 DWORD mode = get_ulong( &args );
1480
1481 return NtGdiModifyWorldTransform( hdc, xform, mode );
1482 }
1483
1484 NTSTATUS WINAPI wow64_NtGdiMoveTo( UINT *args )
1485 {
1486 HDC hdc = get_handle( &args );
1487 INT x = get_ulong( &args );
1488 INT y = get_ulong( &args );
1489 POINT *pt = get_ptr( &args );
1490
1491 return NtGdiMoveTo( hdc, x, y, pt );
1492 }
1493
1494 NTSTATUS WINAPI wow64_NtGdiPolyDraw( UINT *args )
1495 {
1496 HDC hdc = get_handle( &args );
1497 const POINT *points = get_ptr( &args );
1498 const BYTE *types = get_ptr( &args );
1499 DWORD count = get_ulong( &args );
1500
1501 return NtGdiPolyDraw( hdc, points, types, count );
1502 }
1503
1504 NTSTATUS WINAPI wow64_NtGdiPolyPolyDraw( UINT *args )
1505 {
1506 HDC hdc = get_handle( &args );
1507 const POINT *points = get_ptr( &args );
1508 const ULONG *counts = get_ptr( &args );
1509 DWORD count = get_ulong( &args );
1510 UINT function = get_ulong( &args );
1511
1512 return NtGdiPolyPolyDraw( hdc, points, counts, count, function );
1513 }
1514
1515 NTSTATUS WINAPI wow64_NtGdiRectangle( UINT *args )
1516 {
1517 HDC hdc = get_handle( &args );
1518 INT left = get_ulong( &args );
1519 INT top = get_ulong( &args );
1520 INT right = get_ulong( &args );
1521 INT bottom = get_ulong( &args );
1522
1523 return NtGdiRectangle( hdc, left, top, right, bottom );
1524 }
1525
1526 NTSTATUS WINAPI wow64_NtGdiResetDC( UINT *args )
1527 {
1528 HDC hdc = get_handle( &args );
1529 const DEVMODEW *devmode = get_ptr( &args );
1530 BOOL *banding = get_ptr( &args );
1531 DRIVER_INFO_2W *driver_info = get_ptr( &args );
1532 void *dev = get_ptr( &args );
1533
1534 return NtGdiResetDC( hdc, devmode, banding, driver_info, dev );
1535 }
1536
1537 NTSTATUS WINAPI wow64_NtGdiResizePalette( UINT *args )
1538 {
1539 HPALETTE palette = get_handle( &args );
1540 UINT count = get_ulong( &args );
1541
1542 return NtGdiResizePalette( palette, count );
1543 }
1544
1545 NTSTATUS WINAPI wow64_NtGdiRestoreDC( UINT *args )
1546 {
1547 HDC hdc = get_handle( &args );
1548 INT level = get_ulong( &args );
1549
1550 return NtGdiRestoreDC( hdc, level );
1551 }
1552
1553 NTSTATUS WINAPI wow64_NtGdiGetRgnBox( UINT *args )
1554 {
1555 HRGN hrgn = get_handle( &args );
1556 RECT *rect = get_ptr( &args );
1557
1558 return NtGdiGetRgnBox( hrgn, rect );
1559 }
1560
1561 NTSTATUS WINAPI wow64_NtGdiRoundRect( UINT *args )
1562 {
1563 HDC hdc = get_handle( &args );
1564 INT left = get_ulong( &args );
1565 INT top = get_ulong( &args );
1566 INT right = get_ulong( &args );
1567 INT bottom = get_ulong( &args );
1568 INT ell_width = get_ulong( &args );
1569 INT ell_height = get_ulong( &args );
1570
1571 return NtGdiRoundRect( hdc, left, top, right, bottom, ell_width, ell_height );
1572 }
1573
1574 NTSTATUS WINAPI wow64_NtGdiGetSpoolMessage( UINT *args )
1575 {
1576 void *ptr1 = get_ptr( &args );
1577 DWORD data2 = get_ulong( &args );
1578 void *ptr3 = get_ptr( &args );
1579 DWORD data4 = get_ulong( &args );
1580
1581 return NtGdiGetSpoolMessage( ptr1, data2, ptr3, data4 );
1582 }
1583
1584 NTSTATUS WINAPI wow64_NtGdiGetSystemPaletteUse( UINT *args )
1585 {
1586 HDC hdc = get_handle( &args );
1587
1588 return NtGdiGetSystemPaletteUse( hdc );
1589 }
1590
1591 NTSTATUS WINAPI wow64_NtGdiGetTransform( UINT *args )
1592 {
1593 HDC hdc = get_handle( &args );
1594 DWORD which = get_ulong( &args );
1595 XFORM *xform = get_ptr( &args );
1596
1597 return NtGdiGetTransform( hdc, which, xform );
1598 }
1599
1600 NTSTATUS WINAPI wow64_NtGdiHfontCreate( UINT *args )
1601 {
1602 const void *logfont = get_ptr( &args );
1603 ULONG unk2 = get_ulong( &args );
1604 ULONG unk3 = get_ulong( &args );
1605 ULONG unk4 = get_ulong( &args );
1606 void *data = get_ptr( &args );
1607
1608 return HandleToUlong( NtGdiHfontCreate( logfont, unk2, unk3, unk4, data ));
1609 }
1610
1611 NTSTATUS WINAPI wow64_NtGdiInitSpool( UINT *args )
1612 {
1613 return NtGdiInitSpool();
1614 }
1615
1616 NTSTATUS WINAPI wow64_NtGdiIntersectClipRect( UINT *args )
1617 {
1618 HDC hdc = get_handle( &args );
1619 INT left = get_ulong( &args );
1620 INT top = get_ulong( &args );
1621 INT right = get_ulong( &args );
1622 INT bottom = get_ulong( &args );
1623
1624 return NtGdiIntersectClipRect( hdc, left, top, right, bottom );
1625 }
1626
1627 NTSTATUS WINAPI wow64_NtGdiOffsetClipRgn( UINT *args )
1628 {
1629 HDC hdc = get_handle( &args );
1630 INT x = get_ulong( &args );
1631 INT y = get_ulong( &args );
1632
1633 return NtGdiOffsetClipRgn( hdc, x, y );
1634 }
1635
1636 NTSTATUS WINAPI wow64_NtGdiOffsetRgn( UINT *args )
1637 {
1638 HRGN hrgn = get_handle( &args );
1639 INT x = get_ulong( &args );
1640 INT y = get_ulong( &args );
1641
1642 return NtGdiOffsetRgn( hrgn, x, y );
1643 }
1644
1645 NTSTATUS WINAPI wow64_NtGdiOpenDCW( UINT *args )
1646 {
1647 UNICODE_STRING32 *device32 = get_ptr( &args );
1648 const DEVMODEW *devmode = get_ptr( &args );
1649 UNICODE_STRING32 *output32 = get_ptr( &args );
1650 ULONG type = get_ulong( &args );
1651 BOOL is_display = get_ulong( &args );
1652 HANDLE hspool = get_handle( &args );
1653 DRIVER_INFO_2W *driver_info = get_ptr( &args );
1654 void *pdev = get_ptr( &args );
1655
1656 UNICODE_STRING device, output;
1657 HDC ret = NtGdiOpenDCW( unicode_str_32to64( &device, device32 ), devmode,
1658 unicode_str_32to64( &output, output32 ), type,
1659 is_display, hspool, driver_info, pdev );
1660 return HandleToUlong( ret );
1661 }
1662
1663 NTSTATUS WINAPI wow64_NtGdiPatBlt( UINT *args )
1664 {
1665 HDC hdc = get_handle( &args );
1666 INT left = get_ulong( &args );
1667 INT top = get_ulong( &args );
1668 INT width = get_ulong( &args );
1669 INT height = get_ulong( &args );
1670 DWORD rop = get_ulong( &args );
1671
1672 return NtGdiPatBlt( hdc, left, top, width, height, rop );
1673 }
1674
1675 NTSTATUS WINAPI wow64_NtGdiPathToRegion( UINT *args )
1676 {
1677 HDC hdc = get_handle( &args );
1678
1679 return HandleToUlong( NtGdiPathToRegion( hdc ));
1680 }
1681
1682 NTSTATUS WINAPI wow64_NtGdiPlgBlt( UINT *args )
1683 {
1684 HDC hdc = get_handle( &args );
1685 const POINT *point = get_ptr( &args );
1686 HDC hdc_src = get_handle( &args );
1687 INT x_src = get_ulong( &args );
1688 INT y_src = get_ulong( &args );
1689 INT width = get_ulong( &args );
1690 INT height = get_ulong( &args );
1691 HBITMAP mask = get_handle( &args );
1692 INT x_mask = get_ulong( &args );
1693 INT y_mask = get_ulong( &args );
1694 DWORD bk_color = get_ulong( &args );
1695
1696 return NtGdiPlgBlt( hdc, point, hdc_src, x_src, y_src, width, height,
1697 mask, x_mask, y_mask, bk_color );
1698 }
1699
1700 NTSTATUS WINAPI wow64_NtGdiPtInRegion( UINT *args )
1701 {
1702 HRGN hrgn = get_handle( &args );
1703 INT x = get_ulong( &args );
1704 INT y = get_ulong( &args );
1705
1706 return NtGdiPtInRegion( hrgn, x, y );
1707 }
1708
1709 NTSTATUS WINAPI wow64_NtGdiPtVisible( UINT *args )
1710 {
1711 HDC hdc = get_handle( &args );
1712 INT x = get_ulong( &args );
1713 INT y = get_ulong( &args );
1714
1715 return NtGdiPtVisible( hdc, x, y );
1716 }
1717
1718 NTSTATUS WINAPI wow64_NtGdiRectInRegion( UINT *args )
1719 {
1720 HRGN hrgn = get_handle( &args );
1721 const RECT *rect = get_ptr( &args );
1722
1723 return NtGdiRectInRegion( hrgn, rect );
1724 }
1725
1726 NTSTATUS WINAPI wow64_NtGdiRectVisible( UINT *args )
1727 {
1728 HDC hdc = get_handle( &args );
1729 const RECT *rect = get_ptr( &args );
1730
1731 return NtGdiRectVisible( hdc, rect );
1732 }
1733
1734 NTSTATUS WINAPI wow64_NtGdiRemoveFontMemResourceEx( UINT *args )
1735 {
1736 HANDLE handle = get_handle( &args );
1737
1738 return NtGdiRemoveFontMemResourceEx( handle );
1739 }
1740
1741 NTSTATUS WINAPI wow64_NtGdiRemoveFontResourceW( UINT *args )
1742 {
1743 const WCHAR *str = get_ptr( &args );
1744 ULONG size = get_ulong( &args );
1745 ULONG files = get_ulong( &args );
1746 DWORD flags = get_ulong( &args );
1747 DWORD tid = get_ulong( &args );
1748 void *dv = get_ptr( &args );
1749
1750 return NtGdiRemoveFontResourceW( str, size, files, flags, tid, dv );
1751 }
1752
1753 NTSTATUS WINAPI wow64_NtGdiSaveDC( UINT *args )
1754 {
1755 HDC hdc = get_handle( &args );
1756
1757 return NtGdiSaveDC( hdc );
1758 }
1759
1760 NTSTATUS WINAPI wow64_NtGdiScaleViewportExtEx( UINT *args )
1761 {
1762 HDC hdc = get_handle( &args );
1763 INT x_num = get_ulong( &args );
1764 INT x_denom = get_ulong( &args );
1765 INT y_num = get_ulong( &args );
1766 INT y_denom = get_ulong( &args );
1767 SIZE *size = get_ptr( &args );
1768
1769 return NtGdiScaleViewportExtEx( hdc, x_num, x_denom, y_num, y_denom, size );
1770 }
1771
1772 NTSTATUS WINAPI wow64_NtGdiScaleWindowExtEx( UINT *args )
1773 {
1774 HDC hdc = get_handle( &args );
1775 INT x_num = get_ulong( &args );
1776 INT x_denom = get_ulong( &args );
1777 INT y_num = get_ulong( &args );
1778 INT y_denom = get_ulong( &args );
1779 SIZE *size = get_ptr( &args );
1780
1781 return NtGdiScaleWindowExtEx( hdc, x_num, x_denom, y_num, y_denom, size );
1782 }
1783
1784 NTSTATUS WINAPI wow64_NtGdiSelectBitmap( UINT *args )
1785 {
1786 HDC hdc = get_handle( &args );
1787 HGDIOBJ handle = get_handle( &args );
1788
1789 return HandleToUlong( NtGdiSelectBitmap( hdc, handle ));
1790 }
1791
1792 NTSTATUS WINAPI wow64_NtGdiSelectBrush( UINT *args )
1793 {
1794 HDC hdc = get_handle( &args );
1795 HGDIOBJ handle = get_handle( &args );
1796
1797 return HandleToUlong( NtGdiSelectBrush( hdc, handle ));
1798 }
1799
1800 NTSTATUS WINAPI wow64_NtGdiSelectClipPath( UINT *args )
1801 {
1802 HDC hdc = get_handle( &args );
1803 INT mode = get_ulong( &args );
1804
1805 return NtGdiSelectClipPath( hdc, mode );
1806 }
1807
1808 NTSTATUS WINAPI wow64_NtGdiSelectFont( UINT *args )
1809 {
1810 HDC hdc = get_handle( &args );
1811 HGDIOBJ handle = get_handle( &args );
1812
1813 return HandleToUlong( NtGdiSelectFont( hdc, handle ));
1814 }
1815
1816 NTSTATUS WINAPI wow64_NtGdiSelectPen( UINT *args )
1817 {
1818 HDC hdc = get_handle( &args );
1819 HGDIOBJ handle = get_handle( &args );
1820
1821 return HandleToUlong( NtGdiSelectPen( hdc, handle ));
1822 }
1823
1824 NTSTATUS WINAPI wow64_NtGdiSetBitmapBits( UINT *args )
1825 {
1826 HBITMAP hbitmap = get_handle( &args );
1827 LONG count = get_ulong( &args );
1828 const void *bits = get_ptr( &args );
1829
1830 return NtGdiSetBitmapBits( hbitmap, count, bits );
1831 }
1832
1833 NTSTATUS WINAPI wow64_NtGdiSetBitmapDimension( UINT *args )
1834 {
1835 HBITMAP hbitmap = get_handle( &args );
1836 INT x = get_ulong( &args );
1837 INT y = get_ulong( &args );
1838 SIZE *prev_size = get_ptr( &args );
1839
1840 return NtGdiSetBitmapDimension( hbitmap, x, y, prev_size );
1841 }
1842
1843 NTSTATUS WINAPI wow64_NtGdiSetBoundsRect( UINT *args )
1844 {
1845 HDC hdc = get_handle( &args );
1846 const RECT *rect = get_ptr( &args );
1847 UINT flags = get_ulong( &args );
1848
1849 return NtGdiSetBoundsRect( hdc, rect, flags );
1850 }
1851
1852 NTSTATUS WINAPI wow64_NtGdiSetBrushOrg( UINT *args )
1853 {
1854 HDC hdc = get_handle( &args );
1855 INT x = get_ulong( &args );
1856 INT y = get_ulong( &args );
1857 POINT *prev_org = get_ptr( &args );
1858
1859 return NtGdiSetBrushOrg( hdc, x, y, prev_org );
1860 }
1861
1862 NTSTATUS WINAPI wow64_NtGdiSetColorAdjustment( UINT *args )
1863 {
1864 HDC hdc = get_handle( &args );
1865 const COLORADJUSTMENT *ca = get_ptr( &args );
1866
1867 return NtGdiSetColorAdjustment( hdc, ca );
1868 }
1869
1870 NTSTATUS WINAPI wow64_NtGdiSetDIBitsToDeviceInternal( UINT *args )
1871 {
1872 HDC hdc = get_handle( &args );
1873 INT x_dst = get_ulong( &args );
1874 INT y_dst = get_ulong( &args );
1875 DWORD cx = get_ulong( &args );
1876 DWORD cy = get_ulong( &args );
1877 INT x_src = get_ulong( &args );
1878 INT y_src = get_ulong( &args );
1879 UINT startscan = get_ulong( &args );
1880 UINT lines = get_ulong( &args );
1881 const void *bits = get_ptr( &args );
1882 const BITMAPINFO *bmi = get_ptr( &args );
1883 UINT coloruse = get_ulong( &args );
1884 UINT max_bits = get_ulong( &args );
1885 UINT max_info = get_ulong( &args );
1886 BOOL xform_coords = get_ulong( &args );
1887 HANDLE xform = get_handle( &args );
1888
1889 return NtGdiSetDIBitsToDeviceInternal( hdc, x_dst, y_dst, cx, cy, x_src, y_src,
1890 startscan, lines, bits, bmi, coloruse,
1891 max_bits, max_info, xform_coords, xform );
1892 }
1893
1894 NTSTATUS WINAPI wow64_NtGdiSetDeviceGammaRamp( UINT *args )
1895 {
1896 HDC hdc = get_handle( &args );
1897 void *ptr = get_ptr( &args );
1898
1899 return NtGdiSetDeviceGammaRamp( hdc, ptr );
1900 }
1901
1902 NTSTATUS WINAPI wow64_NtGdiSetLayout( UINT *args )
1903 {
1904 HDC hdc = get_handle( &args );
1905 LONG wox = get_ulong( &args );
1906 DWORD layout = get_ulong( &args );
1907
1908 return NtGdiSetLayout( hdc, wox, layout );
1909 }
1910
1911 NTSTATUS WINAPI wow64_NtGdiSetMagicColors( UINT *args )
1912 {
1913 HDC hdc = get_handle( &args );
1914 DWORD magic = get_ulong( &args );
1915 ULONG index = get_ulong( &args );
1916
1917 return NtGdiSetMagicColors( hdc, magic, index );
1918 }
1919
1920 NTSTATUS WINAPI wow64_NtGdiSetMetaRgn( UINT *args )
1921 {
1922 HDC hdc = get_handle( &args );
1923
1924 return NtGdiSetMetaRgn( hdc );
1925 }
1926
1927 NTSTATUS WINAPI wow64_NtGdiSetPixel( UINT *args )
1928 {
1929 HDC hdc = get_handle( &args );
1930 INT x = get_ulong( &args );
1931 INT y = get_ulong( &args );
1932 COLORREF color = get_ulong( &args );
1933
1934 return NtGdiSetPixel( hdc, x, y, color );
1935 }
1936
1937 NTSTATUS WINAPI wow64_NtGdiSetPixelFormat( UINT *args )
1938 {
1939 HDC hdc = get_handle( &args );
1940 INT format = get_ulong( &args );
1941
1942 return NtGdiSetPixelFormat( hdc, format );
1943 }
1944
1945 NTSTATUS WINAPI wow64_NtGdiSetRectRgn( UINT *args )
1946 {
1947 HRGN hrgn = get_handle( &args );
1948 INT left = get_ulong( &args );
1949 INT top = get_ulong( &args );
1950 INT right = get_ulong( &args );
1951 INT bottom = get_ulong( &args );
1952
1953 return NtGdiSetRectRgn( hrgn, left, top, right, bottom );
1954 }
1955
1956 NTSTATUS WINAPI wow64_NtGdiSetSystemPaletteUse( UINT *args )
1957 {
1958 HDC hdc = get_handle( &args );
1959 UINT use = get_ulong( &args );
1960
1961 return NtGdiSetSystemPaletteUse( hdc, use );
1962 }
1963
1964 NTSTATUS WINAPI wow64_NtGdiSetTextJustification( UINT *args )
1965 {
1966 HDC hdc = get_handle( &args );
1967 INT extra = get_ulong( &args );
1968 INT breaks = get_ulong( &args );
1969
1970 return NtGdiSetTextJustification( hdc, extra, breaks );
1971 }
1972
1973 NTSTATUS WINAPI wow64_NtGdiSetVirtualResolution( UINT *args )
1974 {
1975 HDC hdc = get_handle( &args );
1976 DWORD horz_res = get_ulong( &args );
1977 DWORD vert_res = get_ulong( &args );
1978 DWORD horz_size = get_ulong( &args );
1979 DWORD vert_size = get_ulong( &args );
1980
1981 return NtGdiSetVirtualResolution( hdc, horz_res, vert_res, horz_size, vert_size );
1982 }
1983
1984 NTSTATUS WINAPI wow64_NtGdiStartDoc( UINT *args )
1985 {
1986 HDC hdc = get_handle( &args );
1987 const struct
1988 {
1989 INT cbSize;
1990 ULONG lpszDocName;
1991 ULONG lpszOutput;
1992 ULONG lpszDatatype;
1993 DWORD fwType;
1994 } *doc32 = get_ptr( &args );
1995 BOOL *banding = get_ptr( &args );
1996 INT job = get_ulong( &args );
1997
1998 DOCINFOW doc;
1999 doc.cbSize = sizeof(doc);
2000 doc.lpszDocName = UlongToPtr( doc32->lpszDocName );
2001 doc.lpszOutput = UlongToPtr( doc32->lpszOutput );
2002 doc.lpszDatatype = UlongToPtr( doc32->lpszDatatype );
2003 doc.fwType = doc32->fwType;
2004
2005 return NtGdiStartDoc( hdc, &doc, banding, job );
2006 }
2007
2008 NTSTATUS WINAPI wow64_NtGdiStartPage( UINT *args )
2009 {
2010 HDC hdc = get_handle( &args );
2011
2012 return NtGdiStartPage( hdc );
2013 }
2014
2015 NTSTATUS WINAPI wow64_NtGdiStretchBlt( UINT *args )
2016 {
2017 HDC hdc = get_handle( &args );
2018 INT x_dst = get_ulong( &args );
2019 INT y_dst = get_ulong( &args );
2020 INT width_dst = get_ulong( &args );
2021 INT height_dst = get_ulong( &args );
2022 HDC hdc_src = get_handle( &args );
2023 INT x_src = get_ulong( &args );
2024 INT y_src = get_ulong( &args );
2025 INT width_src = get_ulong( &args );
2026 INT height_src = get_ulong( &args );
2027 DWORD rop = get_ulong( &args );
2028 COLORREF bk_color = get_ulong( &args );
2029
2030 return NtGdiStretchBlt( hdc, x_dst, y_dst, width_dst, height_dst, hdc_src,
2031 x_src, y_src, width_src, height_src, rop, bk_color );
2032 }
2033
2034 NTSTATUS WINAPI wow64_NtGdiStretchDIBitsInternal( UINT *args )
2035 {
2036 HDC hdc = get_handle( &args );
2037 INT x_dst = get_ulong( &args );
2038 INT y_dst = get_ulong( &args );
2039 INT width_dst = get_ulong( &args );
2040 INT height_dst = get_ulong( &args );
2041 INT x_src = get_ulong( &args );
2042 INT y_src = get_ulong( &args );
2043 INT width_src = get_ulong( &args );
2044 INT height_src = get_ulong( &args );
2045 const void *bits = get_ptr( &args );
2046 const BITMAPINFO *bmi = get_ptr( &args );
2047 UINT coloruse = get_ulong( &args );
2048 DWORD rop = get_ulong( &args );
2049 UINT max_info = get_ulong( &args );
2050 UINT max_bits = get_ulong( &args );
2051 HANDLE xform = get_handle( &args );
2052
2053 return NtGdiStretchDIBitsInternal( hdc, x_dst, y_dst, width_dst, height_dst,
2054 x_src, y_src, width_src, height_src, bits, bmi,
2055 coloruse, rop, max_info, max_bits, xform );
2056 }
2057
2058 NTSTATUS WINAPI wow64_NtGdiStrokeAndFillPath( UINT *args )
2059 {
2060 HDC hdc = get_handle( &args );
2061
2062 return NtGdiStrokeAndFillPath( hdc );
2063 }
2064
2065 NTSTATUS WINAPI wow64_NtGdiStrokePath( UINT *args )
2066 {
2067 HDC hdc = get_handle( &args );
2068
2069 return NtGdiStrokePath( hdc );
2070 }
2071
2072 NTSTATUS WINAPI wow64_NtGdiSwapBuffers( UINT *args )
2073 {
2074 HDC hdc = get_handle( &args );
2075
2076 return NtGdiSwapBuffers( hdc );
2077 }
2078
2079 NTSTATUS WINAPI wow64_NtGdiTransparentBlt( UINT *args )
2080 {
2081 HDC hdc = get_handle( &args );
2082 int x_dst = get_ulong( &args );
2083 int y_dst = get_ulong( &args );
2084 int width_dst = get_ulong( &args );
2085 int height_dst = get_ulong( &args );
2086 HDC hdc_src = get_handle( &args );
2087 int x_src = get_ulong( &args );
2088 int y_src = get_ulong( &args );
2089 int width_src = get_ulong( &args );
2090 int height_src = get_ulong( &args );
2091 UINT color = get_ulong( &args );
2092
2093 return NtGdiTransparentBlt( hdc, x_dst, y_dst, width_dst, height_dst, hdc_src,
2094 x_src, y_src, width_src, height_src, color );
2095 }
2096
2097 NTSTATUS WINAPI wow64_NtGdiTransformPoints( UINT *args )
2098 {
2099 HDC hdc = get_handle( &args );
2100 const POINT *points_in = get_ptr( &args );
2101 POINT *points_out = get_ptr( &args );
2102 INT count = get_ulong( &args );
2103 UINT mode = get_ulong( &args );
2104
2105 return NtGdiTransformPoints( hdc, points_in, points_out, count, mode );
2106 }
2107
2108 NTSTATUS WINAPI wow64_NtGdiUnrealizeObject( UINT *args )
2109 {
2110 HGDIOBJ obj = get_handle( &args );
2111
2112 return NtGdiUnrealizeObject( obj );
2113 }
2114
2115 NTSTATUS WINAPI wow64_NtGdiUpdateColors( UINT *args )
2116 {
2117 HDC hdc = get_handle( &args );
2118
2119 return NtGdiUpdateColors( hdc );
2120 }
2121
2122 NTSTATUS WINAPI wow64_NtGdiWidenPath( UINT *args )
2123 {
2124 HDC hdc = get_handle( &args );
2125
2126 return NtGdiWidenPath( hdc );
2127 }
2128
2129 NTSTATUS WINAPI wow64___wine_get_icm_profile( UINT *args )
2130 {
2131 HDC hdc = get_handle( &args );
2132 BOOL allow_default = get_ulong( &args );
2133 DWORD *size = get_ptr( &args );
2134 WCHAR *filename = get_ptr( &args );
2135
2136 return __wine_get_icm_profile( hdc, allow_default, size, filename );
2137 }
2138
2139 NTSTATUS WINAPI wow64___wine_get_file_outline_text_metric( UINT *args )
2140 {
2141 const WCHAR *path = get_ptr( &args );
2142 TEXTMETRICW *otm = get_ptr( &args );
2143 UINT *em_square = get_ptr( &args );
2144 WCHAR *face_name = get_ptr( &args );
2145
2146 return __wine_get_file_outline_text_metric( path, otm, em_square, face_name );
2147 }
Windows API implementation