?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
vulkan-1/tests: Enable feature in private data test.
[wine.git] / dlls / wow64win / gdi.c
blob36af173405c115eb79ef58248a7b23911ac592ed
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_NtGdiDdDDIEscape( UINT *args )
511 {
512 const struct
513 {
514 D3DKMT_HANDLE hAdapter;
515 D3DKMT_HANDLE hDevice;
516 D3DKMT_ESCAPETYPE Type;
517 D3DDDI_ESCAPEFLAGS Flags;
518 ULONG pPrivateDriverData;
519 UINT PrivateDriverDataSize;
520 D3DKMT_HANDLE hContext;
521 } *desc32 = get_ptr( &args );
522 D3DKMT_ESCAPE desc;
523
524 if (!desc32) return STATUS_INVALID_PARAMETER;
525 desc.hAdapter = desc32->hAdapter;
526 desc.hDevice = desc32->hDevice;
527 desc.Type = desc32->Type;
528 desc.Flags = desc32->Flags;
529 desc.pPrivateDriverData = UlongToPtr( desc32->pPrivateDriverData );
530 desc.PrivateDriverDataSize = desc32->PrivateDriverDataSize;
531 desc.hContext = desc32->hContext;
532
533 return NtGdiDdDDIEscape( &desc );
534 }
535
536 NTSTATUS WINAPI wow64_NtGdiDdDDIOpenAdapterFromDeviceName( UINT *args )
537 {
538 struct _D3DKMT_OPENADAPTERFROMDEVICENAME
539 {
540 ULONG pDeviceName;
541 D3DKMT_HANDLE hAdapter;
542 LUID AdapterLuid;
543 } *desc32 = get_ptr( &args );
544 D3DKMT_OPENADAPTERFROMDEVICENAME desc;
545 NTSTATUS status;
546
547 if (!desc32) return STATUS_INVALID_PARAMETER;
548 desc.pDeviceName = UlongToPtr( desc32->pDeviceName );
549
550 if (!(status = NtGdiDdDDIOpenAdapterFromDeviceName( &desc )))
551 {
552 desc32->hAdapter = desc.hAdapter;
553 desc32->AdapterLuid = desc.AdapterLuid;
554 }
555 return status;
556 }
557
558 NTSTATUS WINAPI wow64_NtGdiDdDDIOpenAdapterFromHdc( UINT *args )
559 {
560 struct
561 {
562 ULONG hDc;
563 D3DKMT_HANDLE hAdapter;
564 LUID AdapterLuid;
565 D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId;
566 } *desc32 = get_ptr( &args );
567
568 D3DKMT_OPENADAPTERFROMHDC desc;
569 NTSTATUS status;
570
571 if (!desc32) return STATUS_INVALID_PARAMETER;
572 desc.hDc = UlongToHandle( desc32->hDc );
573 if (!(status = NtGdiDdDDIOpenAdapterFromHdc( &desc )))
574 {
575 desc32->hAdapter = desc.hAdapter;
576 desc32->AdapterLuid = desc.AdapterLuid;
577 desc32->VidPnSourceId = desc.VidPnSourceId;
578 }
579 return status;
580 }
581
582 NTSTATUS WINAPI wow64_NtGdiDdDDIOpenAdapterFromLuid( UINT *args )
583 {
584 D3DKMT_OPENADAPTERFROMLUID *desc = get_ptr( &args );
585
586 return NtGdiDdDDIOpenAdapterFromLuid( desc );
587 }
588
589 NTSTATUS WINAPI wow64_NtGdiDdDDIQueryAdapterInfo( UINT *args )
590 {
591 struct _D3DKMT_QUERYADAPTERINFO
592 {
593 D3DKMT_HANDLE hAdapter;
594 KMTQUERYADAPTERINFOTYPE Type;
595 ULONG pPrivateDriverData;
596 UINT PrivateDriverDataSize;
597 } *desc32 = get_ptr( &args );
598 D3DKMT_QUERYADAPTERINFO desc;
599
600 if (!desc32) return STATUS_INVALID_PARAMETER;
601
602 desc.hAdapter = desc32->hAdapter;
603 desc.Type = desc32->Type;
604 desc.pPrivateDriverData = UlongToPtr( desc32->pPrivateDriverData );
605 desc.PrivateDriverDataSize = desc32->PrivateDriverDataSize;
606
607 return NtGdiDdDDIQueryAdapterInfo( &desc );
608 }
609
610 NTSTATUS WINAPI wow64_NtGdiDdDDIQueryStatistics( UINT *args )
611 {
612 D3DKMT_QUERYSTATISTICS *stats = get_ptr( &args );
613
614 return NtGdiDdDDIQueryStatistics( stats );
615 }
616
617 NTSTATUS WINAPI wow64_NtGdiDdDDIQueryVideoMemoryInfo( UINT *args )
618 {
619 struct _D3DKMT_QUERYVIDEOMEMORYINFO
620 {
621 ULONG hProcess;
622 D3DKMT_HANDLE hAdapter;
623 D3DKMT_MEMORY_SEGMENT_GROUP MemorySegmentGroup;
624 UINT64 Budget;
625 UINT64 CurrentUsage;
626 UINT64 CurrentReservation;
627 UINT64 AvailableForReservation;
628 UINT PhysicalAdapterIndex;
629 } *desc32 = get_ptr( &args );
630 D3DKMT_QUERYVIDEOMEMORYINFO desc;
631 NTSTATUS status;
632
633 if (!desc32) return STATUS_INVALID_PARAMETER;
634 desc.hProcess = LongToHandle( desc32->hProcess );
635 desc.hAdapter = desc32->hAdapter;
636 desc.MemorySegmentGroup = desc32->MemorySegmentGroup;
637 desc.PhysicalAdapterIndex = desc32->PhysicalAdapterIndex;
638
639 if (!(status = NtGdiDdDDIQueryVideoMemoryInfo( &desc )))
640 {
641 desc32->Budget = desc.Budget;
642 desc32->CurrentUsage = desc.CurrentUsage;
643 desc32->CurrentReservation = desc.CurrentReservation;
644 desc32->AvailableForReservation = desc.AvailableForReservation;
645 }
646 return status;
647 }
648
649 NTSTATUS WINAPI wow64_NtGdiDdDDISetQueuedLimit( UINT *args )
650 {
651 D3DKMT_SETQUEUEDLIMIT *desc = get_ptr( &args );
652
653 return NtGdiDdDDISetQueuedLimit( desc );
654 }
655
656 NTSTATUS WINAPI wow64_NtGdiDdDDISetVidPnSourceOwner( UINT *args )
657 {
658 const struct
659 {
660 D3DKMT_HANDLE hDevice;
661 ULONG pType;
662 ULONG pVidPnSourceId;
663 UINT VidPnSourceCount;
664 } *desc32 = get_ptr( &args );
665 D3DKMT_SETVIDPNSOURCEOWNER desc;
666
667 if (!desc32) return STATUS_INVALID_PARAMETER;
668 desc.hDevice = desc32->hDevice;
669 desc.pType = UlongToPtr( desc32->pType );
670 desc.pVidPnSourceId = UlongToPtr( desc32->pVidPnSourceId );
671 desc.VidPnSourceCount = desc32->VidPnSourceCount;
672
673 return NtGdiDdDDISetVidPnSourceOwner( &desc );
674 }
675
676 NTSTATUS WINAPI wow64_NtGdiDeleteClientObj( UINT *args )
677 {
678 HGDIOBJ obj = get_handle( &args );
679
680 return NtGdiDeleteClientObj( obj );
681 }
682
683 NTSTATUS WINAPI wow64_NtGdiDeleteObjectApp( UINT *args )
684 {
685 HGDIOBJ obj = get_handle( &args );
686
687 return NtGdiDeleteObjectApp( obj );
688 }
689
690 NTSTATUS WINAPI wow64_NtGdiDescribePixelFormat( UINT *args )
691 {
692 HDC hdc = get_handle( &args );
693 INT format = get_ulong( &args );
694 UINT size = get_ulong( &args );
695 PIXELFORMATDESCRIPTOR *descr = get_ptr( &args );
696
697 return NtGdiDescribePixelFormat( hdc, format, size, descr );
698 }
699
700 NTSTATUS WINAPI wow64_NtGdiDoPalette( UINT *args )
701 {
702 HGDIOBJ handle = get_handle( &args );
703 WORD start = get_ulong( &args );
704 WORD count = get_ulong( &args );
705 void *entries = get_ptr( &args );
706 DWORD func = get_ulong( &args );
707 BOOL inbound = get_ulong( &args );
708
709 return NtGdiDoPalette( handle, start, count, entries, func, inbound );
710 }
711
712 NTSTATUS WINAPI wow64_NtGdiDrawStream( UINT *args )
713 {
714 HDC hdc = get_handle( &args );
715 ULONG in = get_ulong( &args );
716 void *pvin = get_ptr( &args );
717
718 return NtGdiDrawStream( hdc, in, pvin );
719 }
720
721 NTSTATUS WINAPI wow64_NtGdiEllipse( UINT *args )
722 {
723 HDC hdc = get_handle( &args );
724 INT left = get_ulong( &args );
725 INT top = get_ulong( &args );
726 INT right = get_ulong( &args );
727 INT bottom = get_ulong( &args );
728
729 return NtGdiEllipse( hdc, left, top, right, bottom );
730 }
731
732 NTSTATUS WINAPI wow64_NtGdiEndDoc( UINT *args )
733 {
734 HDC hdc = get_handle( &args );
735
736 return NtGdiEndDoc( hdc );
737 }
738
739 NTSTATUS WINAPI wow64_NtGdiEndPage( UINT *args )
740 {
741 HDC hdc = get_handle( &args );
742
743 return NtGdiEndPage( hdc );
744 }
745
746 NTSTATUS WINAPI wow64_NtGdiEndPath( UINT *args )
747 {
748 HDC hdc = get_handle( &args );
749
750 return NtGdiEndPath( hdc );
751 }
752
753 NTSTATUS WINAPI wow64_NtGdiEnumFonts( UINT *args )
754 {
755 HDC hdc = get_handle( &args );
756 ULONG type = get_ulong( &args );
757 ULONG win32_compat = get_ulong( &args );
758 ULONG face_name_len = get_ulong( &args );
759 const WCHAR *face_name = get_ptr( &args );
760 ULONG charset = get_ulong( &args );
761 ULONG *count = get_ptr( &args );
762 void *buf = get_ptr( &args );
763
764 return NtGdiEnumFonts( hdc, type, win32_compat, face_name_len, face_name, charset, count, buf );
765 }
766
767 NTSTATUS WINAPI wow64_NtGdiExcludeClipRect( UINT *args )
768 {
769 HDC hdc = get_handle( &args );
770 INT left = get_ulong( &args );
771 INT top = get_ulong( &args );
772 INT right = get_ulong( &args );
773 INT bottom = get_ulong( &args );
774
775 return NtGdiExcludeClipRect( hdc, left, top, right, bottom );
776 }
777
778 NTSTATUS WINAPI wow64_NtGdiEqualRgn( UINT *args )
779 {
780 HRGN hrgn1 = get_handle( &args );
781 HRGN hrgn2 = get_handle( &args );
782
783 return NtGdiEqualRgn( hrgn1, hrgn2 );
784 }
785
786 NTSTATUS WINAPI wow64_NtGdiExtCreatePen( UINT *args )
787 {
788 DWORD style = get_ulong( &args );
789 DWORD width = get_ulong( &args );
790 ULONG brush_style = get_ulong( &args );
791 ULONG color = get_ulong( &args );
792 ULONG_PTR client_hatch = get_ulong( &args );
793 ULONG_PTR hatch = get_ulong( &args );
794 DWORD style_count = get_ulong( &args );
795 const DWORD *style_bits = get_ptr( &args );
796 ULONG dib_size = get_ulong( &args );
797 BOOL old_style = get_ulong( &args );
798 HBRUSH brush = get_handle( &args );
799
800 return HandleToUlong( NtGdiExtCreatePen( style, width, brush_style, color, client_hatch,
801 hatch, style_count, style_bits, dib_size,
802 old_style, brush ));
803 }
804
805 NTSTATUS WINAPI wow64_NtGdiExtCreateRegion( UINT *args )
806 {
807 const XFORM *xform = get_ptr( &args );
808 DWORD count = get_ulong( &args );
809 const RGNDATA *data = get_ptr( &args );
810
811 return HandleToUlong( NtGdiExtCreateRegion( xform, count, data ));
812 }
813
814 NTSTATUS WINAPI wow64_NtGdiExtEscape( UINT *args )
815 {
816 HDC hdc = get_handle( &args );
817 WCHAR *driver = get_ptr( &args );
818 INT driver_id = get_ulong( &args );
819 INT escape = get_ulong( &args );
820 INT input_size = get_ulong( &args );
821 const char *input = get_ptr( &args );
822 INT output_size = get_ulong( &args );
823 char *output = get_ptr( &args );
824
825 return NtGdiExtEscape( hdc, driver, driver_id, escape, input_size, input, output_size, output );
826 }
827
828 NTSTATUS WINAPI wow64_NtGdiExtFloodFill( UINT *args )
829 {
830 HDC hdc = get_handle( &args );
831 INT x = get_ulong( &args );
832 INT y = get_ulong( &args );
833 COLORREF color = get_ulong( &args );
834 UINT type = get_ulong( &args );
835
836 return NtGdiExtFloodFill( hdc, x, y, color, type );
837 }
838
839 NTSTATUS WINAPI wow64_NtGdiExtGetObjectW( UINT *args )
840 {
841 HGDIOBJ handle = get_handle( &args );
842 INT count = get_ulong( &args );
843 void *buffer = get_ptr( &args );
844
845 switch (gdi_handle_type( handle ))
846 {
847 case NTGDI_OBJ_BITMAP:
848 {
849 BITMAP32 *bitmap32 = buffer;
850 struct
851 {
852 BITMAP32 dsBm;
853 BITMAPINFOHEADER dsBmih;
854 DWORD dsBitfields[3];
855 ULONG dshSection;
856 DWORD dsOffset;
857 } *dib32 = buffer;
858 DIBSECTION dib;
859 int ret;
860
861 if (buffer)
862 {
863 if (count < sizeof(*bitmap32)) return 0;
864 count = count < sizeof(*dib32) ? sizeof(BITMAP) : sizeof(DIBSECTION);
865 }
866
867 if (!(ret = NtGdiExtGetObjectW( handle, count, buffer ? &dib : NULL ))) return 0;
868
869 if (bitmap32)
870 {
871 bitmap32->bmType = dib.dsBm.bmType;
872 bitmap32->bmWidth = dib.dsBm.bmWidth;
873 bitmap32->bmHeight = dib.dsBm.bmHeight;
874 bitmap32->bmWidthBytes = dib.dsBm.bmWidthBytes;
875 bitmap32->bmPlanes = dib.dsBm.bmPlanes;
876 bitmap32->bmBitsPixel = dib.dsBm.bmBitsPixel;
877 bitmap32->bmBits = PtrToUlong( dib.dsBm.bmBits );
878 }
879 if (ret != sizeof(dib)) return sizeof(*bitmap32);
880
881 if (dib32)
882 {
883 dib32->dsBmih = dib.dsBmih;
884 dib32->dsBitfields[0] = dib.dsBitfields[0];
885 dib32->dsBitfields[1] = dib.dsBitfields[1];
886 dib32->dsBitfields[2] = dib.dsBitfields[2];
887 dib32->dshSection = HandleToUlong( dib.dshSection );
888 dib32->dsOffset = dib.dsOffset;
889 }
890 return sizeof(*dib32);
891 }
892
893 case NTGDI_OBJ_PEN:
894 case NTGDI_OBJ_EXTPEN:
895 {
896 EXTLOGPEN32 *pen32 = buffer;
897 EXTLOGPEN *pen = NULL;
898
899 if (count == sizeof(LOGPEN) || (buffer && !HIWORD( buffer )))
900 return NtGdiExtGetObjectW( handle, count, buffer );
901
902 if (pen32 && count && !(pen = Wow64AllocateTemp( count + sizeof(ULONG) ))) return 0;
903 count = NtGdiExtGetObjectW( handle, count + sizeof(ULONG), pen );
904
905 if (count == sizeof(LOGPEN))
906 {
907 if (buffer) memcpy( buffer, pen, count );
908 }
909 else if (count)
910 {
911 if (pen32)
912 {
913 pen32->elpPenStyle = pen->elpPenStyle;
914 pen32->elpWidth = pen->elpWidth;
915 pen32->elpBrushStyle = pen->elpBrushStyle;
916 pen32->elpColor = pen->elpColor;
917 pen32->elpHatch = pen->elpHatch;
918 pen32->elpNumEntries = pen->elpNumEntries;
919 }
920 count -= FIELD_OFFSET( EXTLOGPEN, elpStyleEntry );
921 if (count && pen32) memcpy( pen32->elpStyleEntry, pen->elpStyleEntry, count );
922 count += FIELD_OFFSET( EXTLOGPEN32, elpStyleEntry );
923 }
924 return count;
925 }
926
927 default:
928 return NtGdiExtGetObjectW( handle, count, buffer );
929 }
930 }
931
932 NTSTATUS WINAPI wow64_NtGdiExtSelectClipRgn( UINT *args )
933 {
934 HDC hdc = get_handle( &args );
935 HRGN region = get_handle( &args );
936 INT mode = get_ulong( &args );
937
938 return NtGdiExtSelectClipRgn( hdc, region, mode );
939 }
940
941 NTSTATUS WINAPI wow64_NtGdiExtTextOutW( UINT *args )
942 {
943 HDC hdc = get_handle( &args );
944 INT x = get_ulong( &args );
945 INT y = get_ulong( &args );
946 UINT flags = get_ulong( &args );
947 const RECT *rect = get_ptr( &args );
948 const WCHAR *str = get_ptr( &args );
949 UINT count = get_ulong( &args );
950 const INT *dx = get_ptr( &args );
951 DWORD cp = get_ulong( &args );
952
953 return NtGdiExtTextOutW( hdc, x, y, flags, rect, str, count, dx, cp );
954 }
955
956 NTSTATUS WINAPI wow64_NtGdiFillPath( UINT *args )
957 {
958 HDC hdc = get_handle( &args );
959
960 return NtGdiFillPath( hdc );
961 }
962
963 NTSTATUS WINAPI wow64_NtGdiFillRgn( UINT *args )
964 {
965 HDC hdc = get_handle( &args );
966 HRGN hrgn = get_handle( &args );
967 HBRUSH hbrush = get_handle( &args );
968
969 return NtGdiFillRgn( hdc, hrgn, hbrush );
970 }
971
972 NTSTATUS WINAPI wow64_NtGdiFlattenPath( UINT *args )
973 {
974 HDC hdc = get_handle( &args );
975
976 return NtGdiFlattenPath( hdc );
977 }
978
979 NTSTATUS WINAPI wow64_NtGdiFlush( UINT *args )
980 {
981 return NtGdiFlush();
982 }
983
984 NTSTATUS WINAPI wow64_NtGdiFontIsLinked( UINT *args )
985 {
986 HDC hdc = get_handle( &args );
987
988 return NtGdiFontIsLinked( hdc );
989 }
990
991 NTSTATUS WINAPI wow64_NtGdiFrameRgn( UINT *args )
992 {
993 HDC hdc = get_handle( &args );
994 HRGN hrgn = get_handle( &args );
995 HBRUSH brush = get_handle( &args );
996 INT width = get_ulong( &args );
997 INT height = get_ulong( &args );
998
999 return NtGdiFrameRgn( hdc, hrgn, brush, width, height );
1000 }
1001
1002 NTSTATUS WINAPI wow64_NtGdiGetAndSetDCDword( UINT *args )
1003 {
1004 HDC hdc = get_handle( &args );
1005 UINT method = get_ulong( &args );
1006 DWORD value = get_ulong( &args );
1007 DWORD *result = get_ptr( &args );
1008
1009 return NtGdiGetAndSetDCDword( hdc, method, value, result );
1010 }
1011
1012 NTSTATUS WINAPI wow64_NtGdiGetAppClipBox( UINT *args )
1013 {
1014 HDC hdc = get_handle( &args );
1015 RECT *rect = get_ptr( &args );
1016
1017 return NtGdiGetAppClipBox( hdc, rect );
1018 }
1019
1020 NTSTATUS WINAPI wow64_NtGdiGetBitmapBits( UINT *args )
1021 {
1022 HBITMAP bitmap = get_handle( &args );
1023 LONG count = get_ulong( &args );
1024 void *bits = get_ptr( &args );
1025
1026 return NtGdiGetBitmapBits( bitmap, count, bits );
1027 }
1028
1029 NTSTATUS WINAPI wow64_NtGdiGetBitmapDimension( UINT *args )
1030 {
1031 HBITMAP bitmap = get_handle( &args );
1032 SIZE *size = get_ptr( &args );
1033
1034 return NtGdiGetBitmapDimension( bitmap, size );
1035 }
1036
1037 NTSTATUS WINAPI wow64_NtGdiGetBoundsRect( UINT *args )
1038 {
1039 HDC hdc = get_handle( &args );
1040 RECT *rect = get_ptr( &args );
1041 UINT flags = get_ulong( &args );
1042
1043 return NtGdiGetBoundsRect( hdc, rect, flags );
1044 }
1045
1046 NTSTATUS WINAPI wow64_NtGdiGetCharABCWidthsW( UINT *args )
1047 {
1048 HDC hdc = get_handle( &args );
1049 UINT first = get_ulong( &args );
1050 UINT last = get_ulong( &args );
1051 WCHAR *chars = get_ptr( &args );
1052 ULONG flags = get_ulong( &args );
1053 void *buffer = get_ptr( &args );
1054
1055 return NtGdiGetCharABCWidthsW( hdc, first, last, chars, flags, buffer );
1056 }
1057
1058 NTSTATUS WINAPI wow64_NtGdiGetCharWidthW( UINT *args )
1059 {
1060 HDC hdc = get_handle( &args );
1061 UINT first_char = get_ulong( &args );
1062 UINT last_char = get_ulong( &args );
1063 WCHAR *chars = get_ptr( &args );
1064 ULONG flags = get_ulong( &args );
1065 void *buffer = get_ptr( &args );
1066
1067 return NtGdiGetCharWidthW( hdc, first_char, last_char, chars, flags, buffer );
1068 }
1069
1070 NTSTATUS WINAPI wow64_NtGdiGetCharWidthInfo( UINT *args )
1071 {
1072 HDC hdc = get_handle( &args );
1073 struct char_width_info *info = get_ptr( &args );
1074
1075 return NtGdiGetCharWidthInfo( hdc, info );
1076 }
1077
1078 NTSTATUS WINAPI wow64_NtGdiGetColorAdjustment( UINT *args )
1079 {
1080 HDC hdc = get_handle( &args );
1081 COLORADJUSTMENT *ca = get_ptr( &args );
1082
1083 return NtGdiGetColorAdjustment( hdc, ca );
1084 }
1085
1086 NTSTATUS WINAPI wow64_NtGdiGetDCDword( UINT *args )
1087 {
1088 HDC hdc = get_handle( &args );
1089 UINT method = get_ulong( &args );
1090 DWORD *result = get_ptr( &args );
1091
1092 return NtGdiGetDCDword( hdc, method, result );
1093 }
1094
1095 NTSTATUS WINAPI wow64_NtGdiGetDCObject( UINT *args )
1096 {
1097 HDC hdc = get_handle( &args );
1098 UINT type = get_ulong( &args );
1099
1100 return HandleToUlong( NtGdiGetDCObject( hdc, type ));
1101 }
1102
1103 NTSTATUS WINAPI wow64_NtGdiGetDCPoint( UINT *args )
1104 {
1105 HDC hdc = get_handle( &args );
1106 UINT method = get_ulong( &args );
1107 POINT *result = get_ptr( &args );
1108
1109 return NtGdiGetDCPoint( hdc, method, result );
1110 }
1111
1112 NTSTATUS WINAPI wow64_NtGdiGetDIBitsInternal( UINT *args )
1113 {
1114 HDC hdc = get_handle( &args );
1115 HBITMAP hbitmap = get_handle( &args );
1116 UINT startscan = get_ulong( &args );
1117 UINT lines = get_ulong( &args );
1118 void *bits = get_ptr( &args );
1119 BITMAPINFO *info = get_ptr( &args );
1120 UINT coloruse = get_ulong( &args );
1121 UINT max_bits = get_ulong( &args );
1122 UINT max_info = get_ulong( &args );
1123
1124 return NtGdiGetDIBitsInternal( hdc, hbitmap, startscan, lines, bits, info, coloruse,
1125 max_bits, max_info );
1126 }
1127
1128 NTSTATUS WINAPI wow64_NtGdiGetDeviceCaps( UINT *args )
1129 {
1130 HDC hdc = get_handle( &args );
1131 INT cap = get_ulong( &args );
1132
1133 return NtGdiGetDeviceCaps( hdc, cap );
1134 }
1135
1136 NTSTATUS WINAPI wow64_NtGdiGetDeviceGammaRamp( UINT *args )
1137 {
1138 HDC hdc = get_handle( &args );
1139 void *ptr = get_ptr( &args );
1140
1141 return NtGdiGetDeviceGammaRamp( hdc, ptr );
1142 }
1143
1144 NTSTATUS WINAPI wow64_NtGdiGetFontData( UINT *args )
1145 {
1146 HDC hdc = get_handle( &args );
1147 DWORD table = get_ulong( &args );
1148 DWORD offset = get_ulong( &args );
1149 void *buffer = get_ptr( &args );
1150 DWORD length = get_ulong( &args );
1151
1152 return NtGdiGetFontData( hdc, table, offset, buffer, length );
1153 }
1154
1155 NTSTATUS WINAPI wow64_NtGdiGetFontFileData( UINT *args )
1156 {
1157 DWORD instance_id = get_ulong( &args );
1158 DWORD file_index = get_ulong( &args );
1159 UINT64 *offset = get_ptr( &args );
1160 void *buff = get_ptr( &args );
1161 SIZE_T buff_size = get_ulong( &args );
1162
1163 return NtGdiGetFontFileData( instance_id, file_index, offset, buff, buff_size );
1164 }
1165
1166 NTSTATUS WINAPI wow64_NtGdiGetFontFileInfo( UINT *args )
1167 {
1168 DWORD instance_id = get_ulong( &args );
1169 DWORD file_index = get_ulong( &args );
1170 struct font_fileinfo *info = get_ptr( &args );
1171 SIZE_T size = get_ulong( &args );
1172 ULONG *needed32 = get_ptr( &args );
1173
1174 SIZE_T needed;
1175 BOOL ret;
1176
1177 ret = NtGdiGetFontFileInfo( instance_id, file_index, info, size, size_32to64( &needed, needed32 ));
1178 put_size( needed32, needed );
1179 return ret;
1180 }
1181
1182 NTSTATUS WINAPI wow64_NtGdiGetFontUnicodeRanges( UINT *args )
1183 {
1184 HDC hdc = get_handle( &args );
1185 GLYPHSET *lpgs = get_ptr( &args );
1186
1187 return NtGdiGetFontUnicodeRanges( hdc, lpgs );
1188 }
1189
1190 NTSTATUS WINAPI wow64_NtGdiGetGlyphIndicesW( UINT *args )
1191 {
1192 HDC hdc = get_handle( &args );
1193 const WCHAR *str = get_ptr( &args );
1194 INT count = get_ulong( &args );
1195 WORD *indices = get_ptr( &args );
1196 DWORD flags = get_ulong( &args );
1197
1198 return NtGdiGetGlyphIndicesW( hdc, str, count, indices, flags );
1199 }
1200
1201 NTSTATUS WINAPI wow64_NtGdiGetGlyphOutline( UINT *args )
1202 {
1203 HDC hdc = get_handle( &args );
1204 UINT ch = get_ulong( &args );
1205 UINT format = get_ulong( &args );
1206 GLYPHMETRICS *metrics = get_ptr( &args );
1207 DWORD size = get_ulong( &args );
1208 void *buffer = get_ptr( &args );
1209 const MAT2 *mat2 = get_ptr( &args );
1210 BOOL ignore_rotation = get_ulong( &args );
1211
1212 return NtGdiGetGlyphOutline( hdc, ch, format, metrics, size, buffer, mat2, ignore_rotation );
1213 }
1214
1215 NTSTATUS WINAPI wow64_NtGdiGetKerningPairs( UINT *args )
1216 {
1217 HDC hdc = get_handle( &args );
1218 DWORD count = get_ulong( &args );
1219 KERNINGPAIR *kern_pair = get_ptr( &args );
1220
1221 return NtGdiGetKerningPairs( hdc, count, kern_pair );
1222 }
1223
1224 NTSTATUS WINAPI wow64_NtGdiGetNearestColor( UINT *args )
1225 {
1226 HDC hdc = get_handle( &args );
1227 COLORREF color = get_ulong( &args );
1228
1229 return NtGdiGetNearestColor( hdc, color );
1230 }
1231
1232 NTSTATUS WINAPI wow64_NtGdiGetNearestPaletteIndex( UINT *args )
1233 {
1234 HPALETTE hpalette = get_handle( &args );
1235 COLORREF color = get_ulong( &args );
1236
1237 return NtGdiGetNearestPaletteIndex( hpalette, color );
1238 }
1239
1240 NTSTATUS WINAPI wow64_NtGdiGetOutlineTextMetricsInternalW( UINT *args )
1241 {
1242 HDC hdc = get_handle( &args );
1243 UINT size = get_ulong( &args );
1244 OUTLINETEXTMETRIC32 *otm32 = get_ptr( &args );
1245 ULONG opts = get_ulong( &args );
1246
1247 OUTLINETEXTMETRICW *otm, otm_buf;
1248 UINT ret, size64;
1249 static const size_t otm_size_diff = sizeof(*otm) - sizeof(*otm32);
1250
1251 if (!otm32)
1252 {
1253 size64 = 0;
1254 otm = NULL;
1255 }
1256 else if (size <= sizeof(*otm32))
1257 {
1258 size64 = sizeof(otm_buf);
1259 otm = &otm_buf;
1260 }
1261 else
1262 {
1263 size64 = size + otm_size_diff;
1264 if (!(otm = Wow64AllocateTemp( size64 ))) return 0;
1265 }
1266
1267 if (!(ret = NtGdiGetOutlineTextMetricsInternalW( hdc, size64, otm, opts ))) return 0;
1268
1269 if (otm32)
1270 {
1271 OUTLINETEXTMETRIC32 out;
1272
1273 memcpy( &out, otm, FIELD_OFFSET( OUTLINETEXTMETRIC32, otmpFamilyName ));
1274 if (out.otmSize >= sizeof(*otm)) out.otmSize -= otm_size_diff;
1275
1276 if (!otm->otmpFamilyName) out.otmpFamilyName = 0;
1277 else out.otmpFamilyName = PtrToUlong( otm->otmpFamilyName ) - otm_size_diff;
1278
1279 if (!otm->otmpFaceName) out.otmpFaceName = 0;
1280 else out.otmpFaceName = PtrToUlong( otm->otmpFaceName ) - otm_size_diff;
1281
1282 if (!otm->otmpStyleName) out.otmpStyleName = 0;
1283 else out.otmpStyleName = PtrToUlong( otm->otmpStyleName ) - otm_size_diff;
1284
1285 if (!otm->otmpFullName) out.otmpFullName = 0;
1286 else out.otmpFullName = PtrToUlong( otm->otmpFullName ) - otm_size_diff;
1287
1288 memcpy( otm32, &out, min( size, sizeof(out) ));
1289 if (ret > sizeof(*otm)) memcpy( otm32 + 1, otm + 1, ret - sizeof(*otm) );
1290 }
1291
1292 return ret >= sizeof(*otm) ? ret - otm_size_diff : ret;
1293 }
1294
1295 NTSTATUS WINAPI wow64_NtGdiGetPath( UINT *args )
1296 {
1297 HDC hdc = get_handle( &args );
1298 POINT *points = get_ptr( &args );
1299 BYTE *types = get_ptr( &args );
1300 INT size = get_ulong( &args );
1301
1302 return NtGdiGetPath( hdc, points, types, size );
1303 }
1304
1305 NTSTATUS WINAPI wow64_NtGdiGetPixel( UINT *args )
1306 {
1307 HDC hdc = get_handle( &args );
1308 INT x = get_ulong( &args );
1309 INT y = get_ulong( &args );
1310
1311 return NtGdiGetPixel( hdc, x, y );
1312 }
1313
1314 NTSTATUS WINAPI wow64_NtGdiGetRandomRgn( UINT *args )
1315 {
1316 HDC hdc = get_handle( &args );
1317 HRGN region = get_handle( &args );
1318 INT code = get_ulong( &args );
1319
1320 return NtGdiGetRandomRgn( hdc, region, code );
1321 }
1322
1323 NTSTATUS WINAPI wow64_NtGdiGetRasterizerCaps( UINT *args )
1324 {
1325 RASTERIZER_STATUS *status = get_ptr( &args );
1326 UINT size = get_ulong( &args );
1327
1328 return NtGdiGetRasterizerCaps( status, size );
1329 }
1330
1331 NTSTATUS WINAPI wow64_NtGdiGetRealizationInfo( UINT *args )
1332 {
1333 HDC hdc = get_handle( &args );
1334 struct font_realization_info *info = get_ptr( &args );
1335
1336 return NtGdiGetRealizationInfo( hdc, info );
1337 }
1338
1339 NTSTATUS WINAPI wow64_NtGdiGetRegionData( UINT *args )
1340 {
1341 HRGN hrgn = get_ptr( &args );
1342 DWORD count = get_ulong( &args );
1343 RGNDATA *data = get_ptr( &args );
1344
1345 return NtGdiGetRegionData( hrgn, count, data );
1346 }
1347
1348 NTSTATUS WINAPI wow64_NtGdiGetTextCharsetInfo( UINT *args )
1349 {
1350 HDC hdc = get_ptr( &args );
1351 FONTSIGNATURE *fs = get_ptr( &args );
1352 DWORD flags = get_ulong( &args );
1353
1354 return NtGdiGetTextCharsetInfo( hdc, fs, flags );
1355 }
1356
1357 NTSTATUS WINAPI wow64_NtGdiGetTextExtentExW( UINT *args )
1358 {
1359 HDC hdc = get_handle( &args );
1360 const WCHAR *str = get_ptr( &args );
1361 INT count = get_ulong( &args );
1362 INT max_ext = get_ulong( &args );
1363 INT *nfit = get_ptr( &args );
1364 INT *dxs = get_ptr( &args );
1365 SIZE *size = get_ptr( &args );
1366 UINT flags = get_ulong( &args );
1367
1368 return NtGdiGetTextExtentExW( hdc, str, count, max_ext, nfit, dxs, size, flags );
1369 }
1370
1371 NTSTATUS WINAPI wow64_NtGdiGetTextFaceW( UINT *args )
1372 {
1373 HDC hdc = get_handle( &args );
1374 INT count = get_ulong( &args );
1375 WCHAR *name = get_ptr( &args );
1376 BOOL alias_name = get_ulong( &args );
1377
1378 return NtGdiGetTextFaceW( hdc, count, name, alias_name );
1379 }
1380
1381 NTSTATUS WINAPI wow64_NtGdiGetTextMetricsW( UINT *args )
1382 {
1383 HDC hdc = get_handle( &args );
1384 TEXTMETRICW *metrics = get_ptr( &args );
1385 ULONG flags = get_ulong( &args );
1386
1387 return NtGdiGetTextMetricsW( hdc, metrics, flags );
1388 }
1389
1390 NTSTATUS WINAPI wow64_NtGdiGradientFill( UINT *args )
1391 {
1392 HDC hdc = get_handle( &args );
1393 TRIVERTEX *vert_array = get_ptr( &args );
1394 ULONG nvert = get_ulong( &args );
1395 void *grad_array = get_ptr( &args );
1396 ULONG ngrad = get_ulong( &args );
1397 ULONG mode = get_ulong( &args );
1398
1399 return NtGdiGradientFill( hdc, vert_array, nvert, grad_array, ngrad, mode );
1400 }
1401
1402 NTSTATUS WINAPI wow64_NtGdiIcmBrushInfo( UINT *args )
1403 {
1404 HDC hdc = get_handle( &args );
1405 HBRUSH handle = get_handle( &args );
1406 BITMAPINFO *info = get_ptr( &args );
1407 void *bits = get_ptr( &args );
1408 ULONG *bits_size = get_ptr( &args );
1409 UINT *usage = get_ptr( &args );
1410 BOOL *unk = get_ptr( &args );
1411 UINT mode = get_ulong( &args );
1412
1413 return NtGdiIcmBrushInfo( hdc, handle, info, bits, bits_size, usage, unk, mode );
1414 }
1415
1416 NTSTATUS WINAPI wow64_NtGdiInvertRgn( UINT *args )
1417 {
1418 HDC hdc = get_handle( &args );
1419 HRGN hrgn = get_handle( &args );
1420
1421 return NtGdiInvertRgn( hdc, hrgn );
1422 }
1423
1424 NTSTATUS WINAPI wow64_NtGdiLineTo( UINT *args )
1425 {
1426 HDC hdc = get_handle( &args );
1427 INT x = get_ulong( &args );
1428 INT y = get_ulong( &args );
1429
1430 return NtGdiLineTo( hdc, x, y );
1431 }
1432
1433 NTSTATUS WINAPI wow64_NtGdiMaskBlt( UINT *args )
1434 {
1435 HDC hdc = get_handle( &args );
1436 INT x_dst = get_ulong( &args );
1437 INT y_dst = get_ulong( &args );
1438 INT width_dst = get_ulong( &args );
1439 INT height_dst = get_ulong( &args );
1440 HDC hdc_src = get_handle( &args );
1441 INT x_src = get_ulong( &args );
1442 INT y_src = get_ulong( &args );
1443 HBITMAP mask = get_handle( &args );
1444 INT x_mask = get_ulong( &args );
1445 INT y_mask = get_ulong( &args );
1446 DWORD rop = get_ulong( &args );
1447 DWORD bk_color = get_ulong( &args );
1448
1449 return NtGdiMaskBlt( hdc, x_dst, y_dst, width_dst, height_dst, hdc_src,
1450 x_src, y_src, mask, x_mask, y_mask, rop, bk_color );
1451 }
1452
1453 NTSTATUS WINAPI wow64_NtGdiModifyWorldTransform( UINT *args )
1454 {
1455 HDC hdc = get_handle( &args );
1456 const XFORM *xform = get_ptr( &args );
1457 DWORD mode = get_ulong( &args );
1458
1459 return NtGdiModifyWorldTransform( hdc, xform, mode );
1460 }
1461
1462 NTSTATUS WINAPI wow64_NtGdiMoveTo( UINT *args )
1463 {
1464 HDC hdc = get_handle( &args );
1465 INT x = get_ulong( &args );
1466 INT y = get_ulong( &args );
1467 POINT *pt = get_ptr( &args );
1468
1469 return NtGdiMoveTo( hdc, x, y, pt );
1470 }
1471
1472 NTSTATUS WINAPI wow64_NtGdiPolyDraw( UINT *args )
1473 {
1474 HDC hdc = get_handle( &args );
1475 const POINT *points = get_ptr( &args );
1476 const BYTE *types = get_ptr( &args );
1477 DWORD count = get_ulong( &args );
1478
1479 return NtGdiPolyDraw( hdc, points, types, count );
1480 }
1481
1482 NTSTATUS WINAPI wow64_NtGdiPolyPolyDraw( UINT *args )
1483 {
1484 HDC hdc = get_handle( &args );
1485 const POINT *points = get_ptr( &args );
1486 const ULONG *counts = get_ptr( &args );
1487 DWORD count = get_ulong( &args );
1488 UINT function = get_ulong( &args );
1489
1490 return NtGdiPolyPolyDraw( hdc, points, counts, count, function );
1491 }
1492
1493 NTSTATUS WINAPI wow64_NtGdiRectangle( UINT *args )
1494 {
1495 HDC hdc = get_handle( &args );
1496 INT left = get_ulong( &args );
1497 INT top = get_ulong( &args );
1498 INT right = get_ulong( &args );
1499 INT bottom = get_ulong( &args );
1500
1501 return NtGdiRectangle( hdc, left, top, right, bottom );
1502 }
1503
1504 NTSTATUS WINAPI wow64_NtGdiResetDC( UINT *args )
1505 {
1506 HDC hdc = get_handle( &args );
1507 const DEVMODEW *devmode = get_ptr( &args );
1508 BOOL *banding = get_ptr( &args );
1509 DRIVER_INFO_2W *driver_info = get_ptr( &args );
1510 void *dev = get_ptr( &args );
1511
1512 return NtGdiResetDC( hdc, devmode, banding, driver_info, dev );
1513 }
1514
1515 NTSTATUS WINAPI wow64_NtGdiResizePalette( UINT *args )
1516 {
1517 HPALETTE palette = get_handle( &args );
1518 UINT count = get_ulong( &args );
1519
1520 return NtGdiResizePalette( palette, count );
1521 }
1522
1523 NTSTATUS WINAPI wow64_NtGdiRestoreDC( UINT *args )
1524 {
1525 HDC hdc = get_handle( &args );
1526 INT level = get_ulong( &args );
1527
1528 return NtGdiRestoreDC( hdc, level );
1529 }
1530
1531 NTSTATUS WINAPI wow64_NtGdiGetRgnBox( UINT *args )
1532 {
1533 HRGN hrgn = get_handle( &args );
1534 RECT *rect = get_ptr( &args );
1535
1536 return NtGdiGetRgnBox( hrgn, rect );
1537 }
1538
1539 NTSTATUS WINAPI wow64_NtGdiRoundRect( UINT *args )
1540 {
1541 HDC hdc = get_handle( &args );
1542 INT left = get_ulong( &args );
1543 INT top = get_ulong( &args );
1544 INT right = get_ulong( &args );
1545 INT bottom = get_ulong( &args );
1546 INT ell_width = get_ulong( &args );
1547 INT ell_height = get_ulong( &args );
1548
1549 return NtGdiRoundRect( hdc, left, top, right, bottom, ell_width, ell_height );
1550 }
1551
1552 NTSTATUS WINAPI wow64_NtGdiGetSpoolMessage( UINT *args )
1553 {
1554 void *ptr1 = get_ptr( &args );
1555 DWORD data2 = get_ulong( &args );
1556 void *ptr3 = get_ptr( &args );
1557 DWORD data4 = get_ulong( &args );
1558
1559 return NtGdiGetSpoolMessage( ptr1, data2, ptr3, data4 );
1560 }
1561
1562 NTSTATUS WINAPI wow64_NtGdiGetSystemPaletteUse( UINT *args )
1563 {
1564 HDC hdc = get_handle( &args );
1565
1566 return NtGdiGetSystemPaletteUse( hdc );
1567 }
1568
1569 NTSTATUS WINAPI wow64_NtGdiGetTransform( UINT *args )
1570 {
1571 HDC hdc = get_handle( &args );
1572 DWORD which = get_ulong( &args );
1573 XFORM *xform = get_ptr( &args );
1574
1575 return NtGdiGetTransform( hdc, which, xform );
1576 }
1577
1578 NTSTATUS WINAPI wow64_NtGdiHfontCreate( UINT *args )
1579 {
1580 const void *logfont = get_ptr( &args );
1581 ULONG unk2 = get_ulong( &args );
1582 ULONG unk3 = get_ulong( &args );
1583 ULONG unk4 = get_ulong( &args );
1584 void *data = get_ptr( &args );
1585
1586 return HandleToUlong( NtGdiHfontCreate( logfont, unk2, unk3, unk4, data ));
1587 }
1588
1589 NTSTATUS WINAPI wow64_NtGdiInitSpool( UINT *args )
1590 {
1591 return NtGdiInitSpool();
1592 }
1593
1594 NTSTATUS WINAPI wow64_NtGdiIntersectClipRect( UINT *args )
1595 {
1596 HDC hdc = get_handle( &args );
1597 INT left = get_ulong( &args );
1598 INT top = get_ulong( &args );
1599 INT right = get_ulong( &args );
1600 INT bottom = get_ulong( &args );
1601
1602 return NtGdiIntersectClipRect( hdc, left, top, right, bottom );
1603 }
1604
1605 NTSTATUS WINAPI wow64_NtGdiOffsetClipRgn( UINT *args )
1606 {
1607 HDC hdc = get_handle( &args );
1608 INT x = get_ulong( &args );
1609 INT y = get_ulong( &args );
1610
1611 return NtGdiOffsetClipRgn( hdc, x, y );
1612 }
1613
1614 NTSTATUS WINAPI wow64_NtGdiOffsetRgn( UINT *args )
1615 {
1616 HRGN hrgn = get_handle( &args );
1617 INT x = get_ulong( &args );
1618 INT y = get_ulong( &args );
1619
1620 return NtGdiOffsetRgn( hrgn, x, y );
1621 }
1622
1623 NTSTATUS WINAPI wow64_NtGdiOpenDCW( UINT *args )
1624 {
1625 UNICODE_STRING32 *device32 = get_ptr( &args );
1626 const DEVMODEW *devmode = get_ptr( &args );
1627 UNICODE_STRING32 *output32 = get_ptr( &args );
1628 ULONG type = get_ulong( &args );
1629 BOOL is_display = get_ulong( &args );
1630 HANDLE hspool = get_handle( &args );
1631 DRIVER_INFO_2W *driver_info = get_ptr( &args );
1632 void *pdev = get_ptr( &args );
1633
1634 UNICODE_STRING device, output;
1635 HDC ret = NtGdiOpenDCW( unicode_str_32to64( &device, device32 ), devmode,
1636 unicode_str_32to64( &output, output32 ), type,
1637 is_display, hspool, driver_info, pdev );
1638 return HandleToUlong( ret );
1639 }
1640
1641 NTSTATUS WINAPI wow64_NtGdiPatBlt( UINT *args )
1642 {
1643 HDC hdc = get_handle( &args );
1644 INT left = get_ulong( &args );
1645 INT top = get_ulong( &args );
1646 INT width = get_ulong( &args );
1647 INT height = get_ulong( &args );
1648 DWORD rop = get_ulong( &args );
1649
1650 return NtGdiPatBlt( hdc, left, top, width, height, rop );
1651 }
1652
1653 NTSTATUS WINAPI wow64_NtGdiPathToRegion( UINT *args )
1654 {
1655 HDC hdc = get_handle( &args );
1656
1657 return HandleToUlong( NtGdiPathToRegion( hdc ));
1658 }
1659
1660 NTSTATUS WINAPI wow64_NtGdiPlgBlt( UINT *args )
1661 {
1662 HDC hdc = get_handle( &args );
1663 const POINT *point = get_ptr( &args );
1664 HDC hdc_src = get_handle( &args );
1665 INT x_src = get_ulong( &args );
1666 INT y_src = get_ulong( &args );
1667 INT width = get_ulong( &args );
1668 INT height = get_ulong( &args );
1669 HBITMAP mask = get_handle( &args );
1670 INT x_mask = get_ulong( &args );
1671 INT y_mask = get_ulong( &args );
1672 DWORD bk_color = get_ulong( &args );
1673
1674 return NtGdiPlgBlt( hdc, point, hdc_src, x_src, y_src, width, height,
1675 mask, x_mask, y_mask, bk_color );
1676 }
1677
1678 NTSTATUS WINAPI wow64_NtGdiPtInRegion( UINT *args )
1679 {
1680 HRGN hrgn = get_handle( &args );
1681 INT x = get_ulong( &args );
1682 INT y = get_ulong( &args );
1683
1684 return NtGdiPtInRegion( hrgn, x, y );
1685 }
1686
1687 NTSTATUS WINAPI wow64_NtGdiPtVisible( UINT *args )
1688 {
1689 HDC hdc = get_handle( &args );
1690 INT x = get_ulong( &args );
1691 INT y = get_ulong( &args );
1692
1693 return NtGdiPtVisible( hdc, x, y );
1694 }
1695
1696 NTSTATUS WINAPI wow64_NtGdiRectInRegion( UINT *args )
1697 {
1698 HRGN hrgn = get_handle( &args );
1699 const RECT *rect = get_ptr( &args );
1700
1701 return NtGdiRectInRegion( hrgn, rect );
1702 }
1703
1704 NTSTATUS WINAPI wow64_NtGdiRectVisible( UINT *args )
1705 {
1706 HDC hdc = get_handle( &args );
1707 const RECT *rect = get_ptr( &args );
1708
1709 return NtGdiRectVisible( hdc, rect );
1710 }
1711
1712 NTSTATUS WINAPI wow64_NtGdiRemoveFontMemResourceEx( UINT *args )
1713 {
1714 HANDLE handle = get_handle( &args );
1715
1716 return NtGdiRemoveFontMemResourceEx( handle );
1717 }
1718
1719 NTSTATUS WINAPI wow64_NtGdiRemoveFontResourceW( UINT *args )
1720 {
1721 const WCHAR *str = get_ptr( &args );
1722 ULONG size = get_ulong( &args );
1723 ULONG files = get_ulong( &args );
1724 DWORD flags = get_ulong( &args );
1725 DWORD tid = get_ulong( &args );
1726 void *dv = get_ptr( &args );
1727
1728 return NtGdiRemoveFontResourceW( str, size, files, flags, tid, dv );
1729 }
1730
1731 NTSTATUS WINAPI wow64_NtGdiSaveDC( UINT *args )
1732 {
1733 HDC hdc = get_handle( &args );
1734
1735 return NtGdiSaveDC( hdc );
1736 }
1737
1738 NTSTATUS WINAPI wow64_NtGdiScaleViewportExtEx( UINT *args )
1739 {
1740 HDC hdc = get_handle( &args );
1741 INT x_num = get_ulong( &args );
1742 INT x_denom = get_ulong( &args );
1743 INT y_num = get_ulong( &args );
1744 INT y_denom = get_ulong( &args );
1745 SIZE *size = get_ptr( &args );
1746
1747 return NtGdiScaleViewportExtEx( hdc, x_num, x_denom, y_num, y_denom, size );
1748 }
1749
1750 NTSTATUS WINAPI wow64_NtGdiScaleWindowExtEx( UINT *args )
1751 {
1752 HDC hdc = get_handle( &args );
1753 INT x_num = get_ulong( &args );
1754 INT x_denom = get_ulong( &args );
1755 INT y_num = get_ulong( &args );
1756 INT y_denom = get_ulong( &args );
1757 SIZE *size = get_ptr( &args );
1758
1759 return NtGdiScaleWindowExtEx( hdc, x_num, x_denom, y_num, y_denom, size );
1760 }
1761
1762 NTSTATUS WINAPI wow64_NtGdiSelectBitmap( UINT *args )
1763 {
1764 HDC hdc = get_handle( &args );
1765 HGDIOBJ handle = get_handle( &args );
1766
1767 return HandleToUlong( NtGdiSelectBitmap( hdc, handle ));
1768 }
1769
1770 NTSTATUS WINAPI wow64_NtGdiSelectBrush( UINT *args )
1771 {
1772 HDC hdc = get_handle( &args );
1773 HGDIOBJ handle = get_handle( &args );
1774
1775 return HandleToUlong( NtGdiSelectBrush( hdc, handle ));
1776 }
1777
1778 NTSTATUS WINAPI wow64_NtGdiSelectClipPath( UINT *args )
1779 {
1780 HDC hdc = get_handle( &args );
1781 INT mode = get_ulong( &args );
1782
1783 return NtGdiSelectClipPath( hdc, mode );
1784 }
1785
1786 NTSTATUS WINAPI wow64_NtGdiSelectFont( UINT *args )
1787 {
1788 HDC hdc = get_handle( &args );
1789 HGDIOBJ handle = get_handle( &args );
1790
1791 return HandleToUlong( NtGdiSelectFont( hdc, handle ));
1792 }
1793
1794 NTSTATUS WINAPI wow64_NtGdiSelectPen( UINT *args )
1795 {
1796 HDC hdc = get_handle( &args );
1797 HGDIOBJ handle = get_handle( &args );
1798
1799 return HandleToUlong( NtGdiSelectPen( hdc, handle ));
1800 }
1801
1802 NTSTATUS WINAPI wow64_NtGdiSetBitmapBits( UINT *args )
1803 {
1804 HBITMAP hbitmap = get_handle( &args );
1805 LONG count = get_ulong( &args );
1806 const void *bits = get_ptr( &args );
1807
1808 return NtGdiSetBitmapBits( hbitmap, count, bits );
1809 }
1810
1811 NTSTATUS WINAPI wow64_NtGdiSetBitmapDimension( UINT *args )
1812 {
1813 HBITMAP hbitmap = get_handle( &args );
1814 INT x = get_ulong( &args );
1815 INT y = get_ulong( &args );
1816 SIZE *prev_size = get_ptr( &args );
1817
1818 return NtGdiSetBitmapDimension( hbitmap, x, y, prev_size );
1819 }
1820
1821 NTSTATUS WINAPI wow64_NtGdiSetBoundsRect( UINT *args )
1822 {
1823 HDC hdc = get_handle( &args );
1824 const RECT *rect = get_ptr( &args );
1825 UINT flags = get_ulong( &args );
1826
1827 return NtGdiSetBoundsRect( hdc, rect, flags );
1828 }
1829
1830 NTSTATUS WINAPI wow64_NtGdiSetBrushOrg( UINT *args )
1831 {
1832 HDC hdc = get_handle( &args );
1833 INT x = get_ulong( &args );
1834 INT y = get_ulong( &args );
1835 POINT *prev_org = get_ptr( &args );
1836
1837 return NtGdiSetBrushOrg( hdc, x, y, prev_org );
1838 }
1839
1840 NTSTATUS WINAPI wow64_NtGdiSetColorAdjustment( UINT *args )
1841 {
1842 HDC hdc = get_handle( &args );
1843 const COLORADJUSTMENT *ca = get_ptr( &args );
1844
1845 return NtGdiSetColorAdjustment( hdc, ca );
1846 }
1847
1848 NTSTATUS WINAPI wow64_NtGdiSetDIBitsToDeviceInternal( UINT *args )
1849 {
1850 HDC hdc = get_handle( &args );
1851 INT x_dst = get_ulong( &args );
1852 INT y_dst = get_ulong( &args );
1853 DWORD cx = get_ulong( &args );
1854 DWORD cy = get_ulong( &args );
1855 INT x_src = get_ulong( &args );
1856 INT y_src = get_ulong( &args );
1857 UINT startscan = get_ulong( &args );
1858 UINT lines = get_ulong( &args );
1859 const void *bits = get_ptr( &args );
1860 const BITMAPINFO *bmi = get_ptr( &args );
1861 UINT coloruse = get_ulong( &args );
1862 UINT max_bits = get_ulong( &args );
1863 UINT max_info = get_ulong( &args );
1864 BOOL xform_coords = get_ulong( &args );
1865 HANDLE xform = get_handle( &args );
1866
1867 return NtGdiSetDIBitsToDeviceInternal( hdc, x_dst, y_dst, cx, cy, x_src, y_src,
1868 startscan, lines, bits, bmi, coloruse,
1869 max_bits, max_info, xform_coords, xform );
1870 }
1871
1872 NTSTATUS WINAPI wow64_NtGdiSetDeviceGammaRamp( UINT *args )
1873 {
1874 HDC hdc = get_handle( &args );
1875 void *ptr = get_ptr( &args );
1876
1877 return NtGdiSetDeviceGammaRamp( hdc, ptr );
1878 }
1879
1880 NTSTATUS WINAPI wow64_NtGdiSetLayout( UINT *args )
1881 {
1882 HDC hdc = get_handle( &args );
1883 LONG wox = get_ulong( &args );
1884 DWORD layout = get_ulong( &args );
1885
1886 return NtGdiSetLayout( hdc, wox, layout );
1887 }
1888
1889 NTSTATUS WINAPI wow64_NtGdiSetMagicColors( UINT *args )
1890 {
1891 HDC hdc = get_handle( &args );
1892 DWORD magic = get_ulong( &args );
1893 ULONG index = get_ulong( &args );
1894
1895 return NtGdiSetMagicColors( hdc, magic, index );
1896 }
1897
1898 NTSTATUS WINAPI wow64_NtGdiSetMetaRgn( UINT *args )
1899 {
1900 HDC hdc = get_handle( &args );
1901
1902 return NtGdiSetMetaRgn( hdc );
1903 }
1904
1905 NTSTATUS WINAPI wow64_NtGdiSetPixel( UINT *args )
1906 {
1907 HDC hdc = get_handle( &args );
1908 INT x = get_ulong( &args );
1909 INT y = get_ulong( &args );
1910 COLORREF color = get_ulong( &args );
1911
1912 return NtGdiSetPixel( hdc, x, y, color );
1913 }
1914
1915 NTSTATUS WINAPI wow64_NtGdiSetPixelFormat( UINT *args )
1916 {
1917 HDC hdc = get_handle( &args );
1918 INT format = get_ulong( &args );
1919
1920 return NtGdiSetPixelFormat( hdc, format );
1921 }
1922
1923 NTSTATUS WINAPI wow64_NtGdiSetRectRgn( UINT *args )
1924 {
1925 HRGN hrgn = get_handle( &args );
1926 INT left = get_ulong( &args );
1927 INT top = get_ulong( &args );
1928 INT right = get_ulong( &args );
1929 INT bottom = get_ulong( &args );
1930
1931 return NtGdiSetRectRgn( hrgn, left, top, right, bottom );
1932 }
1933
1934 NTSTATUS WINAPI wow64_NtGdiSetSystemPaletteUse( UINT *args )
1935 {
1936 HDC hdc = get_handle( &args );
1937 UINT use = get_ulong( &args );
1938
1939 return NtGdiSetSystemPaletteUse( hdc, use );
1940 }
1941
1942 NTSTATUS WINAPI wow64_NtGdiSetTextJustification( UINT *args )
1943 {
1944 HDC hdc = get_handle( &args );
1945 INT extra = get_ulong( &args );
1946 INT breaks = get_ulong( &args );
1947
1948 return NtGdiSetTextJustification( hdc, extra, breaks );
1949 }
1950
1951 NTSTATUS WINAPI wow64_NtGdiSetVirtualResolution( UINT *args )
1952 {
1953 HDC hdc = get_handle( &args );
1954 DWORD horz_res = get_ulong( &args );
1955 DWORD vert_res = get_ulong( &args );
1956 DWORD horz_size = get_ulong( &args );
1957 DWORD vert_size = get_ulong( &args );
1958
1959 return NtGdiSetVirtualResolution( hdc, horz_res, vert_res, horz_size, vert_size );
1960 }
1961
1962 NTSTATUS WINAPI wow64_NtGdiStartDoc( UINT *args )
1963 {
1964 HDC hdc = get_handle( &args );
1965 const struct
1966 {
1967 INT cbSize;
1968 ULONG lpszDocName;
1969 ULONG lpszOutput;
1970 ULONG lpszDatatype;
1971 DWORD fwType;
1972 } *doc32 = get_ptr( &args );
1973 BOOL *banding = get_ptr( &args );
1974 INT job = get_ulong( &args );
1975
1976 DOCINFOW doc;
1977 doc.cbSize = sizeof(doc);
1978 doc.lpszDocName = UlongToPtr( doc32->lpszDocName );
1979 doc.lpszOutput = UlongToPtr( doc32->lpszOutput );
1980 doc.lpszDatatype = UlongToPtr( doc32->lpszDatatype );
1981 doc.fwType = doc32->fwType;
1982
1983 return NtGdiStartDoc( hdc, &doc, banding, job );
1984 }
1985
1986 NTSTATUS WINAPI wow64_NtGdiStartPage( UINT *args )
1987 {
1988 HDC hdc = get_handle( &args );
1989
1990 return NtGdiStartPage( hdc );
1991 }
1992
1993 NTSTATUS WINAPI wow64_NtGdiStretchBlt( UINT *args )
1994 {
1995 HDC hdc = get_handle( &args );
1996 INT x_dst = get_ulong( &args );
1997 INT y_dst = get_ulong( &args );
1998 INT width_dst = get_ulong( &args );
1999 INT height_dst = get_ulong( &args );
2000 HDC hdc_src = get_handle( &args );
2001 INT x_src = get_ulong( &args );
2002 INT y_src = get_ulong( &args );
2003 INT width_src = get_ulong( &args );
2004 INT height_src = get_ulong( &args );
2005 DWORD rop = get_ulong( &args );
2006 COLORREF bk_color = get_ulong( &args );
2007
2008 return NtGdiStretchBlt( hdc, x_dst, y_dst, width_dst, height_dst, hdc_src,
2009 x_src, y_src, width_src, height_src, rop, bk_color );
2010 }
2011
2012 NTSTATUS WINAPI wow64_NtGdiStretchDIBitsInternal( UINT *args )
2013 {
2014 HDC hdc = get_handle( &args );
2015 INT x_dst = get_ulong( &args );
2016 INT y_dst = get_ulong( &args );
2017 INT width_dst = get_ulong( &args );
2018 INT height_dst = get_ulong( &args );
2019 INT x_src = get_ulong( &args );
2020 INT y_src = get_ulong( &args );
2021 INT width_src = get_ulong( &args );
2022 INT height_src = get_ulong( &args );
2023 const void *bits = get_ptr( &args );
2024 const BITMAPINFO *bmi = get_ptr( &args );
2025 UINT coloruse = get_ulong( &args );
2026 DWORD rop = get_ulong( &args );
2027 UINT max_info = get_ulong( &args );
2028 UINT max_bits = get_ulong( &args );
2029 HANDLE xform = get_handle( &args );
2030
2031 return NtGdiStretchDIBitsInternal( hdc, x_dst, y_dst, width_dst, height_dst,
2032 x_src, y_src, width_src, height_src, bits, bmi,
2033 coloruse, rop, max_info, max_bits, xform );
2034 }
2035
2036 NTSTATUS WINAPI wow64_NtGdiStrokeAndFillPath( UINT *args )
2037 {
2038 HDC hdc = get_handle( &args );
2039
2040 return NtGdiStrokeAndFillPath( hdc );
2041 }
2042
2043 NTSTATUS WINAPI wow64_NtGdiStrokePath( UINT *args )
2044 {
2045 HDC hdc = get_handle( &args );
2046
2047 return NtGdiStrokePath( hdc );
2048 }
2049
2050 NTSTATUS WINAPI wow64_NtGdiSwapBuffers( UINT *args )
2051 {
2052 HDC hdc = get_handle( &args );
2053
2054 return NtGdiSwapBuffers( hdc );
2055 }
2056
2057 NTSTATUS WINAPI wow64_NtGdiTransparentBlt( UINT *args )
2058 {
2059 HDC hdc = get_handle( &args );
2060 int x_dst = get_ulong( &args );
2061 int y_dst = get_ulong( &args );
2062 int width_dst = get_ulong( &args );
2063 int height_dst = get_ulong( &args );
2064 HDC hdc_src = get_handle( &args );
2065 int x_src = get_ulong( &args );
2066 int y_src = get_ulong( &args );
2067 int width_src = get_ulong( &args );
2068 int height_src = get_ulong( &args );
2069 UINT color = get_ulong( &args );
2070
2071 return NtGdiTransparentBlt( hdc, x_dst, y_dst, width_dst, height_dst, hdc_src,
2072 x_src, y_src, width_src, height_src, color );
2073 }
2074
2075 NTSTATUS WINAPI wow64_NtGdiTransformPoints( UINT *args )
2076 {
2077 HDC hdc = get_handle( &args );
2078 const POINT *points_in = get_ptr( &args );
2079 POINT *points_out = get_ptr( &args );
2080 INT count = get_ulong( &args );
2081 UINT mode = get_ulong( &args );
2082
2083 return NtGdiTransformPoints( hdc, points_in, points_out, count, mode );
2084 }
2085
2086 NTSTATUS WINAPI wow64_NtGdiUnrealizeObject( UINT *args )
2087 {
2088 HGDIOBJ obj = get_handle( &args );
2089
2090 return NtGdiUnrealizeObject( obj );
2091 }
2092
2093 NTSTATUS WINAPI wow64_NtGdiUpdateColors( UINT *args )
2094 {
2095 HDC hdc = get_handle( &args );
2096
2097 return NtGdiUpdateColors( hdc );
2098 }
2099
2100 NTSTATUS WINAPI wow64_NtGdiWidenPath( UINT *args )
2101 {
2102 HDC hdc = get_handle( &args );
2103
2104 return NtGdiWidenPath( hdc );
2105 }
2106
2107 NTSTATUS WINAPI wow64___wine_get_icm_profile( UINT *args )
2108 {
2109 HDC hdc = get_handle( &args );
2110 BOOL allow_default = get_ulong( &args );
2111 DWORD *size = get_ptr( &args );
2112 WCHAR *filename = get_ptr( &args );
2113
2114 return __wine_get_icm_profile( hdc, allow_default, size, filename );
2115 }
2116
2117 NTSTATUS WINAPI wow64___wine_get_file_outline_text_metric( UINT *args )
2118 {
2119 const WCHAR *path = get_ptr( &args );
2120 TEXTMETRICW *otm = get_ptr( &args );
2121 UINT *em_square = get_ptr( &args );
2122 WCHAR *face_name = get_ptr( &args );
2123
2124 return __wine_get_file_outline_text_metric( path, otm, em_square, face_name );
2125 }
Windows API implementation