?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
winevulkan: Merge body and body_conversion.
[wine.git] / dlls / gdi32 / dc.c
blobcece962573912c7e3ebe81e30e5773f23be361dd
1 /*
2 * GDI Device Context functions
3 *
4 * Copyright 1993, 1994 Alexandre Julliard
5 * Copyright 1997 Bertho A. Stultiens
6 * 1999 Huw D M Davies
7 * Copyright 2021 Jacek Caban for CodeWeavers
8 *
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
13 *
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
18 *
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22 */
23
24 #include "gdi_private.h"
25 #include "ntuser.h"
26 #include "ddrawgdi.h"
27 #include "winnls.h"
28
29 #include "wine/list.h"
30 #include "wine/debug.h"
31
32 WINE_DEFAULT_DEBUG_CHANNEL(gdi);
33
34 static struct list drivers = LIST_INIT( drivers );
35
36 static CRITICAL_SECTION driver_section;
37 static CRITICAL_SECTION_DEBUG critsect_debug =
38 {
39 0, 0, &driver_section,
40 { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
41 0, 0, { (DWORD_PTR)(__FILE__ ": driver_section") }
42 };
43 static CRITICAL_SECTION driver_section = { &critsect_debug, -1, 0, 0, 0, 0 };
44
45 typedef const void * (CDECL *driver_entry_point)( unsigned int version );
46
47 struct graphics_driver
48 {
49 struct list entry;
50 HMODULE module; /* module handle */
51 driver_entry_point entry_point;
52 };
53
54
55 DC_ATTR *get_dc_attr( HDC hdc )
56 {
57 DWORD type = gdi_handle_type( hdc );
58 DC_ATTR *dc_attr;
59 if ((type & 0x1f0000) != NTGDI_OBJ_DC || !(dc_attr = get_gdi_client_ptr( hdc, 0 )))
60 {
61 SetLastError( ERROR_INVALID_HANDLE );
62 return NULL;
63 }
64 return dc_attr->disabled ? NULL : dc_attr;
65 }
66
67 static BOOL is_display_device( const WCHAR *name )
68 {
69 const WCHAR *p = name;
70
71 if (!name)
72 return FALSE;
73
74 if (wcsnicmp( name, L"\\\\.\\DISPLAY", lstrlenW(L"\\\\.\\DISPLAY") )) return FALSE;
75
76 p += lstrlenW(L"\\\\.\\DISPLAY");
77
78 if (!iswdigit( *p++ ))
79 return FALSE;
80
81 for (; *p; p++)
82 {
83 if (!iswdigit( *p ))
84 return FALSE;
85 }
86
87 return TRUE;
88 }
89
90 static BOOL get_driver_name( const WCHAR *device, WCHAR *driver, DWORD size )
91 {
92 WCHAR *p;
93
94 /* display is a special case */
95 if (!wcsicmp( device, L"display" ) || is_display_device( device ))
96 {
97 lstrcpynW( driver, L"display", size );
98 return TRUE;
99 }
100
101 size = GetProfileStringW(L"devices", device, L"", driver, size);
102 if (!size)
103 {
104 WARN("Unable to find %s in [devices] section of win.ini\n", debugstr_w(device));
105 return FALSE;
106 }
107 p = wcschr(driver, ',');
108 if (!p)
109 {
110 WARN("%s entry in [devices] section of win.ini is malformed.\n", debugstr_w(device));
111 return FALSE;
112 }
113 *p = 0;
114 TRACE("Found %s for %s\n", debugstr_w(driver), debugstr_w(device));
115 return TRUE;
116 }
117
118 static struct graphics_driver *create_driver( HMODULE module )
119 {
120 struct graphics_driver *driver;
121
122 if (!(driver = HeapAlloc( GetProcessHeap(), 0, sizeof(*driver)))) return NULL;
123 driver->module = module;
124
125 if (module)
126 driver->entry_point = (void *)GetProcAddress( module, "wine_get_gdi_driver" );
127 else
128 driver->entry_point = NULL;
129
130 return driver;
131 }
132
133 #ifdef __i386__
134 static const WCHAR printer_env[] = L"w32x86";
135 #elif defined __x86_64__
136 static const WCHAR printer_env[] = L"x64";
137 #elif defined __arm__
138 static const WCHAR printer_env[] = L"arm";
139 #elif defined __aarch64__
140 static const WCHAR printer_env[] = L"arm64";
141 #else
142 #error not defined for this cpu
143 #endif
144
145 static driver_entry_point load_driver( LPCWSTR name )
146 {
147 HMODULE module;
148 struct graphics_driver *driver, *new_driver;
149
150 if ((module = GetModuleHandleW( name )))
151 {
152 EnterCriticalSection( &driver_section );
153 LIST_FOR_EACH_ENTRY( driver, &drivers, struct graphics_driver, entry )
154 {
155 if (driver->module == module) goto done;
156 }
157 LeaveCriticalSection( &driver_section );
158 }
159
160 if (!(module = LoadLibraryW( name )))
161 {
162 WCHAR path[MAX_PATH];
163
164 GetSystemDirectoryW( path, MAX_PATH );
165 swprintf( path + wcslen(path), MAX_PATH - wcslen(path), L"\\spool\\drivers\\%s\\3\\%s",
166 printer_env, name );
167 if (!(module = LoadLibraryW( path ))) return NULL;
168 }
169
170 if (!(new_driver = create_driver( module )))
171 {
172 FreeLibrary( module );
173 return NULL;
174 }
175
176 /* check if someone else added it in the meantime */
177 EnterCriticalSection( &driver_section );
178 LIST_FOR_EACH_ENTRY( driver, &drivers, struct graphics_driver, entry )
179 {
180 if (driver->module != module) continue;
181 FreeLibrary( module );
182 HeapFree( GetProcessHeap(), 0, new_driver );
183 goto done;
184 }
185 driver = new_driver;
186 list_add_head( &drivers, &driver->entry );
187 TRACE( "loaded driver %p for %s\n", driver, debugstr_w(name) );
188 done:
189 LeaveCriticalSection( &driver_section );
190 return driver->entry_point;
191 }
192
193 /***********************************************************************
194 * CreateDCW (GDI32.@)
195 */
196 HDC WINAPI CreateDCW( LPCWSTR driver, LPCWSTR device, LPCWSTR output,
197 const DEVMODEW *devmode )
198 {
199 UNICODE_STRING device_str, output_str;
200 driver_entry_point entry_point = NULL;
201 const WCHAR *display = NULL, *p;
202 BOOL is_display = FALSE;
203 WCHAR buf[300];
204
205 if (!device || !get_driver_name( device, buf, 300 ))
206 {
207 if (!driver)
208 {
209 ERR( "no device found for %s\n", debugstr_w(device) );
210 return 0;
211 }
212 lstrcpyW(buf, driver);
213 }
214
215 if (is_display_device( driver ))
216 {
217 display = driver;
218 is_display = TRUE;
219 }
220 else if (is_display_device( device ))
221 {
222 display = device;
223 is_display = TRUE;
224 }
225 else if (!wcsicmp( buf, L"display" ) || is_display_device( buf ))
226 {
227 is_display = TRUE;
228 }
229 else if (!(entry_point = load_driver( buf )))
230 {
231 ERR( "no driver found for %s\n", debugstr_w(buf) );
232 return 0;
233 }
234
235 if (display)
236 {
237 /* Use only the display name. For example, \\.\DISPLAY1 in \\.\DISPLAY1\Monitor0 */
238 p = display + 12;
239 while (iswdigit( *p )) p++;
240
241 device_str.Length = device_str.MaximumLength = (p - display) * sizeof(WCHAR);
242 device_str.Buffer = (WCHAR *)display;
243 }
244 else if (device)
245 {
246 device_str.Length = device_str.MaximumLength = lstrlenW( device ) * sizeof(WCHAR);
247 device_str.Buffer = (WCHAR *)device;
248 }
249
250 if (output)
251 {
252 output_str.Length = output_str.MaximumLength = lstrlenW(output) * sizeof(WCHAR);
253 output_str.Buffer = (WCHAR *)output;
254 }
255
256 return NtGdiOpenDCW( device || display ? &device_str : NULL, devmode, output ? &output_str : NULL,
257 0, is_display, entry_point, NULL, NULL );
258 }
259
260 /***********************************************************************
261 * CreateDCA (GDI32.@)
262 */
263 HDC WINAPI CreateDCA( const char *driver, const char *device, const char *output,
264 const DEVMODEA *init_data )
265 {
266 UNICODE_STRING driverW, deviceW, outputW;
267 DEVMODEW *init_dataW = NULL;
268 HDC ret;
269
270 if (driver) RtlCreateUnicodeStringFromAsciiz( &driverW, driver );
271 else driverW.Buffer = NULL;
272
273 if (device) RtlCreateUnicodeStringFromAsciiz( &deviceW, device );
274 else deviceW.Buffer = NULL;
275
276 if (output) RtlCreateUnicodeStringFromAsciiz( &outputW, output );
277 else outputW.Buffer = NULL;
278
279 if (init_data)
280 {
281 /* don't convert init_data for DISPLAY driver, it's not used */
282 if (!driverW.Buffer || wcsicmp( driverW.Buffer, L"display" ))
283 init_dataW = GdiConvertToDevmodeW( init_data );
284 }
285
286 ret = CreateDCW( driverW.Buffer, deviceW.Buffer, outputW.Buffer, init_dataW );
287
288 RtlFreeUnicodeString( &driverW );
289 RtlFreeUnicodeString( &deviceW );
290 RtlFreeUnicodeString( &outputW );
291 HeapFree( GetProcessHeap(), 0, init_dataW );
292 return ret;
293 }
294
295 /***********************************************************************
296 * CreateICA (GDI32.@)
297 */
298 HDC WINAPI CreateICA( const char *driver, const char *device, const char *output,
299 const DEVMODEA *init_data )
300 {
301 /* Nothing special yet for ICs */
302 return CreateDCA( driver, device, output, init_data );
303 }
304
305
306 /***********************************************************************
307 * CreateICW (GDI32.@)
308 */
309 HDC WINAPI CreateICW( const WCHAR *driver, const WCHAR *device, const WCHAR *output,
310 const DEVMODEW *init_data )
311 {
312 /* Nothing special yet for ICs */
313 return CreateDCW( driver, device, output, init_data );
314 }
315
316 /***********************************************************************
317 * GdiConvertToDevmodeW (GDI32.@)
318 */
319 DEVMODEW *WINAPI GdiConvertToDevmodeW( const DEVMODEA *dmA )
320 {
321 DEVMODEW *dmW;
322 WORD dmW_size, dmA_size;
323
324 dmA_size = dmA->dmSize;
325
326 /* this is the minimal dmSize that XP accepts */
327 if (dmA_size < FIELD_OFFSET(DEVMODEA, dmFields))
328 return NULL;
329
330 if (dmA_size > sizeof(DEVMODEA))
331 dmA_size = sizeof(DEVMODEA);
332
333 dmW_size = dmA_size + CCHDEVICENAME;
334 if (dmA_size >= FIELD_OFFSET(DEVMODEA, dmFormName) + CCHFORMNAME)
335 dmW_size += CCHFORMNAME;
336
337 dmW = HeapAlloc( GetProcessHeap(), 0, dmW_size + dmA->dmDriverExtra );
338 if (!dmW) return NULL;
339
340 MultiByteToWideChar( CP_ACP, 0, (const char*) dmA->dmDeviceName, -1,
341 dmW->dmDeviceName, CCHDEVICENAME );
342 /* copy slightly more, to avoid long computations */
343 memcpy( &dmW->dmSpecVersion, &dmA->dmSpecVersion, dmA_size - CCHDEVICENAME );
344
345 if (dmA_size >= FIELD_OFFSET(DEVMODEA, dmFormName) + CCHFORMNAME)
346 {
347 if (dmA->dmFields & DM_FORMNAME)
348 MultiByteToWideChar( CP_ACP, 0, (const char*) dmA->dmFormName, -1,
349 dmW->dmFormName, CCHFORMNAME );
350 else
351 dmW->dmFormName[0] = 0;
352
353 if (dmA_size > FIELD_OFFSET(DEVMODEA, dmLogPixels))
354 memcpy( &dmW->dmLogPixels, &dmA->dmLogPixels, dmA_size - FIELD_OFFSET(DEVMODEA, dmLogPixels) );
355 }
356
357 if (dmA->dmDriverExtra)
358 memcpy( (char *)dmW + dmW_size, (const char *)dmA + dmA_size, dmA->dmDriverExtra );
359
360 dmW->dmSize = dmW_size;
361
362 return dmW;
363 }
364
365 /***********************************************************************
366 * DeleteDC (GDI32.@)
367 */
368 BOOL WINAPI DeleteDC( HDC hdc )
369 {
370 DC_ATTR *dc_attr;
371
372 if (is_meta_dc( hdc )) return METADC_DeleteDC( hdc );
373 if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
374 if (dc_attr->emf) EMFDC_DeleteDC( dc_attr );
375 return NtGdiDeleteObjectApp( hdc );
376 }
377
378 /***********************************************************************
379 * ResetDCA (GDI32.@)
380 */
381 HDC WINAPI ResetDCA( HDC hdc, const DEVMODEA *devmode )
382 {
383 DEVMODEW *devmodeW;
384 HDC ret;
385
386 if (devmode) devmodeW = GdiConvertToDevmodeW( devmode );
387 else devmodeW = NULL;
388
389 ret = ResetDCW( hdc, devmodeW );
390
391 HeapFree( GetProcessHeap(), 0, devmodeW );
392 return ret;
393 }
394
395 /***********************************************************************
396 * ResetDCW (GDI32.@)
397 */
398 HDC WINAPI ResetDCW( HDC hdc, const DEVMODEW *devmode )
399 {
400 return NtGdiResetDC( hdc, devmode, NULL, NULL, NULL ) ? hdc : 0;
401 }
402
403 /***********************************************************************
404 * SaveDC (GDI32.@)
405 */
406 INT WINAPI SaveDC( HDC hdc )
407 {
408 DC_ATTR *dc_attr;
409
410 if (is_meta_dc( hdc )) return METADC_SaveDC( hdc );
411 if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
412 if (dc_attr->emf && !EMFDC_SaveDC( dc_attr )) return FALSE;
413 return NtGdiSaveDC( hdc );
414 }
415
416 /***********************************************************************
417 * RestoreDC (GDI32.@)
418 */
419 BOOL WINAPI RestoreDC( HDC hdc, INT level )
420 {
421 DC_ATTR *dc_attr;
422
423 if (is_meta_dc( hdc )) return METADC_RestoreDC( hdc, level );
424 if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
425 if (dc_attr->emf && !EMFDC_RestoreDC( dc_attr, level )) return FALSE;
426 return NtGdiRestoreDC( hdc, level );
427 }
428
429 /***********************************************************************
430 * GetDeviceCaps (GDI32.@)
431 */
432 INT WINAPI GetDeviceCaps( HDC hdc, INT cap )
433 {
434 if (is_meta_dc( hdc )) return METADC_GetDeviceCaps( hdc, cap );
435 if (!get_dc_attr( hdc )) return FALSE;
436 return NtGdiGetDeviceCaps( hdc, cap );
437 }
438
439 /***********************************************************************
440 * Escape (GDI32.@)
441 */
442 INT WINAPI Escape( HDC hdc, INT escape, INT in_count, const char *in_data, void *out_data )
443 {
444 INT ret;
445 POINT *pt;
446
447 switch (escape)
448 {
449 case ABORTDOC:
450 return AbortDoc( hdc );
451
452 case ENDDOC:
453 return EndDoc( hdc );
454
455 case GETPHYSPAGESIZE:
456 pt = out_data;
457 pt->x = GetDeviceCaps( hdc, PHYSICALWIDTH );
458 pt->y = GetDeviceCaps( hdc, PHYSICALHEIGHT );
459 return 1;
460
461 case GETPRINTINGOFFSET:
462 pt = out_data;
463 pt->x = GetDeviceCaps( hdc, PHYSICALOFFSETX );
464 pt->y = GetDeviceCaps( hdc, PHYSICALOFFSETY );
465 return 1;
466
467 case GETSCALINGFACTOR:
468 pt = out_data;
469 pt->x = GetDeviceCaps( hdc, SCALINGFACTORX );
470 pt->y = GetDeviceCaps( hdc, SCALINGFACTORY );
471 return 1;
472
473 case NEWFRAME:
474 return EndPage( hdc );
475
476 case SETABORTPROC:
477 return SetAbortProc( hdc, (ABORTPROC)in_data );
478
479 case STARTDOC:
480 {
481 DOCINFOA doc;
482 char *name = NULL;
483
484 /* in_data may not be 0 terminated so we must copy it */
485 if (in_data)
486 {
487 name = HeapAlloc( GetProcessHeap(), 0, in_count+1 );
488 memcpy( name, in_data, in_count );
489 name[in_count] = 0;
490 }
491 /* out_data is actually a pointer to the DocInfo structure and used as
492 * a second input parameter */
493 if (out_data) doc = *(DOCINFOA *)out_data;
494 else
495 {
496 doc.cbSize = sizeof(doc);
497 doc.lpszOutput = NULL;
498 doc.lpszDatatype = NULL;
499 doc.fwType = 0;
500 }
501 doc.lpszDocName = name;
502 ret = StartDocA( hdc, &doc );
503 HeapFree( GetProcessHeap(), 0, name );
504 if (ret > 0) ret = StartPage( hdc );
505 return ret;
506 }
507
508 case QUERYESCSUPPORT:
509 {
510 DWORD code;
511
512 if (in_count < sizeof(SHORT)) return 0;
513 code = (in_count < sizeof(DWORD)) ? *(const USHORT *)in_data : *(const DWORD *)in_data;
514 switch (code)
515 {
516 case ABORTDOC:
517 case ENDDOC:
518 case GETPHYSPAGESIZE:
519 case GETPRINTINGOFFSET:
520 case GETSCALINGFACTOR:
521 case NEWFRAME:
522 case QUERYESCSUPPORT:
523 case SETABORTPROC:
524 case STARTDOC:
525 return TRUE;
526 }
527 break;
528 }
529 }
530
531 /* if not handled internally, pass it to the driver */
532 return ExtEscape( hdc, escape, in_count, in_data, 0, out_data );
533 }
534
535 /***********************************************************************
536 * ExtEscape [GDI32.@]
537 */
538 INT WINAPI ExtEscape( HDC hdc, INT escape, INT input_size, const char *input,
539 INT output_size, char *output )
540 {
541 if (is_meta_dc( hdc ))
542 return METADC_ExtEscape( hdc, escape, input_size, input, output_size, output );
543 return NtGdiExtEscape( hdc, NULL, 0, escape, input_size, input, output_size, output );
544 }
545
546 /***********************************************************************
547 * GetTextAlign (GDI32.@)
548 */
549 UINT WINAPI GetTextAlign( HDC hdc )
550 {
551 DC_ATTR *dc_attr = get_dc_attr( hdc );
552 return dc_attr ? dc_attr->text_align : 0;
553 }
554
555 /***********************************************************************
556 * SetTextAlign (GDI32.@)
557 */
558 UINT WINAPI SetTextAlign( HDC hdc, UINT align )
559 {
560 DC_ATTR *dc_attr;
561 UINT ret;
562
563 TRACE("hdc=%p align=%d\n", hdc, align);
564
565 if (is_meta_dc( hdc )) return METADC_SetTextAlign( hdc, align );
566 if (!(dc_attr = get_dc_attr( hdc ))) return GDI_ERROR;
567 if (dc_attr->emf && !EMFDC_SetTextAlign( dc_attr, align )) return GDI_ERROR;
568
569 ret = dc_attr->text_align;
570 dc_attr->text_align = align;
571 return ret;
572 }
573
574 /***********************************************************************
575 * GetBkColor (GDI32.@)
576 */
577 COLORREF WINAPI GetBkColor( HDC hdc )
578 {
579 DC_ATTR *dc_attr = get_dc_attr( hdc );
580 return dc_attr ? dc_attr->background_color : CLR_INVALID;
581 }
582
583 /***********************************************************************
584 * SetBkColor (GDI32.@)
585 */
586 COLORREF WINAPI SetBkColor( HDC hdc, COLORREF color )
587 {
588 DC_ATTR *dc_attr;
589 COLORREF ret;
590
591 if (is_meta_dc( hdc )) return METADC_SetBkColor( hdc, color );
592 if (!(dc_attr = get_dc_attr( hdc ))) return CLR_INVALID;
593 if (dc_attr->emf && !EMFDC_SetBkColor( dc_attr, color )) return CLR_INVALID;
594 return NtGdiGetAndSetDCDword( hdc, NtGdiSetBkColor, color, &ret ) ? ret : CLR_INVALID;
595 }
596
597 /***********************************************************************
598 * GetDCBrushColor (GDI32.@)
599 */
600 COLORREF WINAPI GetDCBrushColor( HDC hdc )
601 {
602 DC_ATTR *dc_attr = get_dc_attr( hdc );
603 return dc_attr ? dc_attr->brush_color : CLR_INVALID;
604 }
605
606 /***********************************************************************
607 * SetDCBrushColor (GDI32.@)
608 */
609 COLORREF WINAPI SetDCBrushColor( HDC hdc, COLORREF color )
610 {
611 DC_ATTR *dc_attr;
612 COLORREF ret;
613
614 if (!(dc_attr = get_dc_attr( hdc ))) return CLR_INVALID;
615 if (dc_attr->emf && !EMFDC_SetDCBrushColor( dc_attr, color )) return CLR_INVALID;
616 return NtGdiGetAndSetDCDword( hdc, NtGdiSetDCBrushColor, color, &ret ) ? ret : CLR_INVALID;
617 }
618
619 /***********************************************************************
620 * GetDCPenColor (GDI32.@)
621 */
622 COLORREF WINAPI GetDCPenColor(HDC hdc)
623 {
624 DC_ATTR *dc_attr = get_dc_attr( hdc );
625 return dc_attr ? dc_attr->pen_color : CLR_INVALID;
626 }
627
628 /***********************************************************************
629 * SetDCPenColor (GDI32.@)
630 */
631 COLORREF WINAPI SetDCPenColor( HDC hdc, COLORREF color )
632 {
633 DC_ATTR *dc_attr;
634 COLORREF ret;
635
636 if (!(dc_attr = get_dc_attr( hdc ))) return CLR_INVALID;
637 if (dc_attr->emf && !EMFDC_SetDCPenColor( dc_attr, color )) return CLR_INVALID;
638 return NtGdiGetAndSetDCDword( hdc, NtGdiSetDCPenColor, color, &ret ) ? ret : CLR_INVALID;
639 }
640
641 /***********************************************************************
642 * GetTextColor (GDI32.@)
643 */
644 COLORREF WINAPI GetTextColor( HDC hdc )
645 {
646 DC_ATTR *dc_attr = get_dc_attr( hdc );
647 return dc_attr ? dc_attr->text_color : 0;
648 }
649
650 /***********************************************************************
651 * SetTextColor (GDI32.@)
652 */
653 COLORREF WINAPI SetTextColor( HDC hdc, COLORREF color )
654 {
655 DC_ATTR *dc_attr;
656 COLORREF ret;
657
658 if (is_meta_dc( hdc )) return METADC_SetTextColor( hdc, color );
659 if (!(dc_attr = get_dc_attr( hdc ))) return CLR_INVALID;
660 if (dc_attr->emf && !EMFDC_SetTextColor( dc_attr, color )) return CLR_INVALID;
661 return NtGdiGetAndSetDCDword( hdc, NtGdiSetTextColor, color, &ret ) ? ret : CLR_INVALID;
662 }
663
664 /***********************************************************************
665 * GetBkMode (GDI32.@)
666 */
667 INT WINAPI GetBkMode( HDC hdc )
668 {
669 DC_ATTR *dc_attr = get_dc_attr( hdc );
670 return dc_attr ? dc_attr->background_mode : 0;
671 }
672
673 /***********************************************************************
674 * SetBkMode (GDI32.@)
675 */
676 INT WINAPI SetBkMode( HDC hdc, INT mode )
677 {
678 DC_ATTR *dc_attr;
679 INT ret;
680
681 if (mode <= 0 || mode > BKMODE_LAST)
682 {
683 SetLastError(ERROR_INVALID_PARAMETER);
684 return 0;
685 }
686
687 if (is_meta_dc( hdc )) return METADC_SetBkMode( hdc, mode );
688 if (!(dc_attr = get_dc_attr( hdc ))) return 0;
689 if (dc_attr->emf && !EMFDC_SetBkMode( dc_attr, mode )) return 0;
690
691 ret = dc_attr->background_mode;
692 dc_attr->background_mode = mode;
693 return ret;
694 }
695
696 /***********************************************************************
697 * GetGraphicsMode (GDI32.@)
698 */
699 INT WINAPI GetGraphicsMode( HDC hdc )
700 {
701 DC_ATTR *dc_attr = get_dc_attr( hdc );
702 return dc_attr ? dc_attr->graphics_mode : 0;
703 }
704
705 /***********************************************************************
706 * SetGraphicsMode (GDI32.@)
707 */
708 INT WINAPI SetGraphicsMode( HDC hdc, INT mode )
709 {
710 DWORD ret;
711 return NtGdiGetAndSetDCDword( hdc, NtGdiSetGraphicsMode, mode, &ret ) ? ret : 0;
712 }
713
714 /***********************************************************************
715 * GetArcDirection (GDI32.@)
716 */
717 INT WINAPI GetArcDirection( HDC hdc )
718 {
719 DC_ATTR *dc_attr = get_dc_attr( hdc );
720 return dc_attr ? dc_attr->arc_direction : 0;
721 }
722
723 /***********************************************************************
724 * SetArcDirection (GDI32.@)
725 */
726 INT WINAPI SetArcDirection( HDC hdc, INT dir )
727 {
728 DC_ATTR *dc_attr;
729 INT ret;
730
731 if (dir != AD_COUNTERCLOCKWISE && dir != AD_CLOCKWISE)
732 {
733 SetLastError(ERROR_INVALID_PARAMETER);
734 return 0;
735 }
736
737 if (!(dc_attr = get_dc_attr( hdc ))) return 0;
738 if (dc_attr->emf && !EMFDC_SetArcDirection( dc_attr, dir )) return 0;
739
740 ret = dc_attr->arc_direction;
741 dc_attr->arc_direction = dir;
742 return ret;
743 }
744
745 /***********************************************************************
746 * GetLayout (GDI32.@)
747 */
748 DWORD WINAPI GetLayout( HDC hdc )
749 {
750 DC_ATTR *dc_attr = get_dc_attr( hdc );
751 return dc_attr ? dc_attr->layout : GDI_ERROR;
752 }
753
754 /***********************************************************************
755 * SetLayout (GDI32.@)
756 */
757 DWORD WINAPI SetLayout( HDC hdc, DWORD layout )
758 {
759 DC_ATTR *dc_attr;
760
761 if (is_meta_dc( hdc )) return METADC_SetLayout( hdc, layout );
762 if (!(dc_attr = get_dc_attr( hdc ))) return GDI_ERROR;
763 if (dc_attr->emf && !EMFDC_SetLayout( dc_attr, layout )) return GDI_ERROR;
764 return NtGdiSetLayout( hdc, -1, layout );
765 }
766
767 /***********************************************************************
768 * GetMapMode (GDI32.@)
769 */
770 INT WINAPI GetMapMode( HDC hdc )
771 {
772 DC_ATTR *dc_attr = get_dc_attr( hdc );
773 return dc_attr ? dc_attr->map_mode : 0;
774 }
775
776 /***********************************************************************
777 * SetMapMode (GDI32.@)
778 */
779 INT WINAPI SetMapMode( HDC hdc, INT mode )
780 {
781 DC_ATTR *dc_attr;
782 DWORD ret;
783
784 TRACE("%p %d\n", hdc, mode );
785
786 if (is_meta_dc( hdc )) return METADC_SetMapMode( hdc, mode );
787 if (!(dc_attr = get_dc_attr( hdc ))) return 0;
788 if (dc_attr->emf && !EMFDC_SetMapMode( dc_attr, mode )) return 0;
789 return NtGdiGetAndSetDCDword( hdc, NtGdiSetMapMode, mode, &ret ) ? ret : 0;
790 }
791
792 /***********************************************************************
793 * GetTextCharacterExtra (GDI32.@)
794 */
795 INT WINAPI GetTextCharacterExtra( HDC hdc )
796 {
797 DC_ATTR *dc_attr = get_dc_attr( hdc );
798 return dc_attr ? dc_attr->char_extra : 0x80000000;
799 }
800
801 /***********************************************************************
802 * SetTextCharacterExtra (GDI32.@)
803 */
804 INT WINAPI SetTextCharacterExtra( HDC hdc, INT extra )
805 {
806 DC_ATTR *dc_attr;
807 INT ret;
808
809 if (is_meta_dc( hdc )) return METADC_SetTextCharacterExtra( hdc, extra );
810 if (!(dc_attr = get_dc_attr( hdc ))) return 0x8000000;
811 ret = dc_attr->char_extra;
812 dc_attr->char_extra = extra;
813 return ret;
814 }
815
816 /***********************************************************************
817 * SetMapperFlags (GDI32.@)
818 */
819 DWORD WINAPI SetMapperFlags( HDC hdc, DWORD flags )
820 {
821 DC_ATTR *dc_attr;
822 DWORD ret;
823
824 if (is_meta_dc( hdc )) return METADC_SetMapperFlags( hdc, flags );
825 if (!(dc_attr = get_dc_attr( hdc ))) return GDI_ERROR;
826 if (dc_attr->emf && !EMFDC_SetMapperFlags( dc_attr, flags )) return GDI_ERROR;
827 ret = dc_attr->mapper_flags;
828 dc_attr->mapper_flags = flags;
829 return ret;
830 }
831
832 /***********************************************************************
833 * GetPolyFillMode (GDI32.@)
834 */
835 INT WINAPI GetPolyFillMode( HDC hdc )
836 {
837 DC_ATTR *dc_attr = get_dc_attr( hdc );
838 return dc_attr ? dc_attr->poly_fill_mode : 0;
839 }
840
841 /***********************************************************************
842 * SetPolyFillMode (GDI32.@)
843 */
844 INT WINAPI SetPolyFillMode( HDC hdc, INT mode )
845 {
846 DC_ATTR *dc_attr;
847 INT ret;
848
849 if (mode <= 0 || mode > POLYFILL_LAST)
850 {
851 SetLastError(ERROR_INVALID_PARAMETER);
852 return 0;
853 }
854
855 if (is_meta_dc( hdc )) return METADC_SetPolyFillMode( hdc, mode );
856 if (!(dc_attr = get_dc_attr( hdc ))) return 0;
857 if (dc_attr->emf && !EMFDC_SetPolyFillMode( dc_attr, mode )) return 0;
858
859 ret = dc_attr->poly_fill_mode;
860 dc_attr->poly_fill_mode = mode;
861 return ret;
862 }
863
864 /***********************************************************************
865 * GetStretchBltMode (GDI32.@)
866 */
867 INT WINAPI GetStretchBltMode( HDC hdc )
868 {
869 DC_ATTR *dc_attr = get_dc_attr( hdc );
870 return dc_attr ? dc_attr->stretch_blt_mode : 0;
871 }
872
873 /***********************************************************************
874 * GetBrushOrgEx (GDI32.@)
875 */
876 BOOL WINAPI GetBrushOrgEx( HDC hdc, POINT *point )
877 {
878 DC_ATTR *dc_attr;
879 if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
880 *point = dc_attr->brush_org;
881 return TRUE;
882 }
883
884 /***********************************************************************
885 * SetBrushOrgEx (GDI32.@)
886 */
887 BOOL WINAPI SetBrushOrgEx( HDC hdc, INT x, INT y, POINT *oldorg )
888 {
889 DC_ATTR *dc_attr;
890 if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
891 if (oldorg) *oldorg = dc_attr->brush_org;
892 dc_attr->brush_org.x = x;
893 dc_attr->brush_org.y = y;
894 return TRUE;
895 }
896
897 /***********************************************************************
898 * FixBrushOrgEx (GDI32.@)
899 */
900 BOOL WINAPI FixBrushOrgEx( HDC hdc, INT x, INT y, POINT *oldorg )
901 {
902 return SetBrushOrgEx( hdc, x, y, oldorg );
903 }
904
905 /***********************************************************************
906 * GetDCOrgEx (GDI32.@)
907 */
908 BOOL WINAPI GetDCOrgEx( HDC hdc, POINT *point )
909 {
910 DC_ATTR *dc_attr;
911 if (!point || !(dc_attr = get_dc_attr( hdc ))) return FALSE;
912 point->x = dc_attr->vis_rect.left;
913 point->y = dc_attr->vis_rect.top;
914 return TRUE;
915 }
916
917 /***********************************************************************
918 * GetWindowExtEx (GDI32.@)
919 */
920 BOOL WINAPI GetWindowExtEx( HDC hdc, SIZE *size )
921 {
922 DC_ATTR *dc_attr;
923 if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
924 *size = dc_attr->wnd_ext;
925 return TRUE;
926 }
927
928 /***********************************************************************
929 * SetWindowExtEx (GDI32.@)
930 */
931 BOOL WINAPI SetWindowExtEx( HDC hdc, INT x, INT y, SIZE *size )
932 {
933 DC_ATTR *dc_attr;
934
935 if (is_meta_dc( hdc )) return METADC_SetWindowExtEx( hdc, x, y );
936 if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
937 if (dc_attr->emf && !EMFDC_SetWindowExtEx( dc_attr, x, y )) return FALSE;
938
939 if (size) *size = dc_attr->wnd_ext;
940 if (dc_attr->map_mode != MM_ISOTROPIC && dc_attr->map_mode != MM_ANISOTROPIC) return TRUE;
941 if (!x || !y) return FALSE;
942 dc_attr->wnd_ext.cx = x;
943 dc_attr->wnd_ext.cy = y;
944 return NtGdiComputeXformCoefficients( hdc );
945 }
946
947 /***********************************************************************
948 * GetWindowOrgEx (GDI32.@)
949 */
950 BOOL WINAPI GetWindowOrgEx( HDC hdc, POINT *point )
951 {
952 DC_ATTR *dc_attr;
953 if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
954 *point = dc_attr->wnd_org;
955 return TRUE;
956 }
957
958 /***********************************************************************
959 * SetWindowOrgEx (GDI32.@)
960 */
961 BOOL WINAPI SetWindowOrgEx( HDC hdc, INT x, INT y, POINT *point )
962 {
963 DC_ATTR *dc_attr;
964
965 if (is_meta_dc( hdc )) return METADC_SetWindowOrgEx( hdc, x, y );
966 if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
967 if (dc_attr->emf && !EMFDC_SetWindowOrgEx( dc_attr, x, y )) return FALSE;
968
969 if (point) *point = dc_attr->wnd_org;
970 dc_attr->wnd_org.x = x;
971 dc_attr->wnd_org.y = y;
972 return NtGdiComputeXformCoefficients( hdc );
973 }
974
975 /***********************************************************************
976 * OffsetWindowOrgEx (GDI32.@)
977 */
978 BOOL WINAPI OffsetWindowOrgEx( HDC hdc, INT x, INT y, POINT *point )
979 {
980 DC_ATTR *dc_attr;
981
982 if (is_meta_dc( hdc )) return METADC_OffsetWindowOrgEx( hdc, x, y );
983 if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
984 if (point) *point = dc_attr->wnd_org;
985 dc_attr->wnd_org.x += x;
986 dc_attr->wnd_org.y += y;
987 if (dc_attr->emf && !EMFDC_SetWindowOrgEx( dc_attr, dc_attr->wnd_org.x,
988 dc_attr->wnd_org.y )) return FALSE;
989 return NtGdiComputeXformCoefficients( hdc );
990 }
991
992 /***********************************************************************
993 * GetViewportExtEx (GDI32.@)
994 */
995 BOOL WINAPI GetViewportExtEx( HDC hdc, SIZE *size )
996 {
997 DC_ATTR *dc_attr;
998 if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
999 *size = dc_attr->vport_ext;
1000 return TRUE;
1001 }
1002
1003 /***********************************************************************
1004 * SetViewportExtEx (GDI32.@)
1005 */
1006 BOOL WINAPI SetViewportExtEx( HDC hdc, INT x, INT y, LPSIZE size )
1007 {
1008 DC_ATTR *dc_attr;
1009
1010 if (is_meta_dc( hdc )) return METADC_SetViewportExtEx( hdc, x, y );
1011 if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
1012 if (dc_attr->emf && !EMFDC_SetViewportExtEx( dc_attr, x, y )) return FALSE;
1013
1014 if (size) *size = dc_attr->vport_ext;
1015 if (dc_attr->map_mode != MM_ISOTROPIC && dc_attr->map_mode != MM_ANISOTROPIC) return TRUE;
1016 if (!x || !y) return FALSE;
1017 dc_attr->vport_ext.cx = x;
1018 dc_attr->vport_ext.cy = y;
1019 return NtGdiComputeXformCoefficients( hdc );
1020 }
1021
1022 /***********************************************************************
1023 * GetViewportOrgEx (GDI32.@)
1024 */
1025 BOOL WINAPI GetViewportOrgEx( HDC hdc, POINT *point )
1026 {
1027 DC_ATTR *dc_attr;
1028 if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
1029 *point = dc_attr->vport_org;
1030 return TRUE;
1031 }
1032
1033 /***********************************************************************
1034 * SetViewportOrgEx (GDI32.@)
1035 */
1036 BOOL WINAPI SetViewportOrgEx( HDC hdc, INT x, INT y, POINT *point )
1037 {
1038 DC_ATTR *dc_attr;
1039
1040 if (is_meta_dc( hdc )) return METADC_SetViewportOrgEx( hdc, x, y );
1041 if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
1042 if (dc_attr->emf && !EMFDC_SetViewportOrgEx( dc_attr, x, y )) return FALSE;
1043
1044 if (point) *point = dc_attr->vport_org;
1045 dc_attr->vport_org.x = x;
1046 dc_attr->vport_org.y = y;
1047 return NtGdiComputeXformCoefficients( hdc );
1048 }
1049
1050 /***********************************************************************
1051 * OffsetViewportOrgEx (GDI32.@)
1052 */
1053 BOOL WINAPI OffsetViewportOrgEx( HDC hdc, INT x, INT y, POINT *point )
1054 {
1055 DC_ATTR *dc_attr;
1056
1057 if (is_meta_dc( hdc )) return METADC_OffsetViewportOrgEx( hdc, x, y );
1058 if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
1059 if (point) *point = dc_attr->vport_org;
1060 dc_attr->vport_org.x += x;
1061 dc_attr->vport_org.y += y;
1062 if (dc_attr->emf && !EMFDC_SetViewportOrgEx( dc_attr, dc_attr->vport_org.x,
1063 dc_attr->vport_org.y )) return FALSE;
1064 return NtGdiComputeXformCoefficients( hdc );
1065 }
1066
1067 /***********************************************************************
1068 * GetWorldTransform (GDI32.@)
1069 */
1070 BOOL WINAPI GetWorldTransform( HDC hdc, XFORM *xform )
1071 {
1072 return NtGdiGetTransform( hdc, 0x203, xform );
1073 }
1074
1075 /****************************************************************************
1076 * ModifyWorldTransform (GDI32.@)
1077 */
1078 BOOL WINAPI ModifyWorldTransform( HDC hdc, const XFORM *xform, DWORD mode )
1079 {
1080 DC_ATTR *dc_attr;
1081
1082 if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
1083 if (dc_attr->emf && !EMFDC_ModifyWorldTransform( dc_attr, xform, mode )) return FALSE;
1084 return NtGdiModifyWorldTransform( hdc, xform, mode );
1085 }
1086
1087 /***********************************************************************
1088 * SetWorldTransform (GDI32.@)
1089 */
1090 BOOL WINAPI SetWorldTransform( HDC hdc, const XFORM *xform )
1091 {
1092 DC_ATTR *dc_attr;
1093
1094 if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
1095 if (dc_attr->emf && !EMFDC_SetWorldTransform( dc_attr, xform )) return FALSE;
1096 return NtGdiModifyWorldTransform( hdc, xform, MWT_SET );
1097 }
1098
1099 /***********************************************************************
1100 * SetStretchBltMode (GDI32.@)
1101 */
1102 INT WINAPI SetStretchBltMode( HDC hdc, INT mode )
1103 {
1104 DC_ATTR *dc_attr;
1105 INT ret;
1106
1107 if (mode <= 0 || mode > MAXSTRETCHBLTMODE)
1108 {
1109 SetLastError(ERROR_INVALID_PARAMETER);
1110 return 0;
1111 }
1112
1113 if (is_meta_dc( hdc )) return METADC_SetStretchBltMode( hdc, mode );
1114 if (!(dc_attr = get_dc_attr( hdc ))) return 0;
1115 if (dc_attr->emf && !EMFDC_SetStretchBltMode( dc_attr, mode )) return 0;
1116
1117 ret = dc_attr->stretch_blt_mode;
1118 dc_attr->stretch_blt_mode = mode;
1119 return ret;
1120 }
1121
1122 /***********************************************************************
1123 * GetCurrentPositionEx (GDI32.@)
1124 */
1125 BOOL WINAPI GetCurrentPositionEx( HDC hdc, POINT *point )
1126 {
1127 DC_ATTR *dc_attr;
1128 if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
1129 *point = dc_attr->cur_pos;
1130 return TRUE;
1131 }
1132
1133 /***********************************************************************
1134 * GetROP2 (GDI32.@)
1135 */
1136 INT WINAPI GetROP2( HDC hdc )
1137 {
1138 DC_ATTR *dc_attr = get_dc_attr( hdc );
1139 return dc_attr ? dc_attr->rop_mode : 0;
1140 }
1141
1142 /***********************************************************************
1143 * GetRelAbs (GDI32.@)
1144 */
1145 INT WINAPI GetRelAbs( HDC hdc, DWORD ignore )
1146 {
1147 DC_ATTR *dc_attr = get_dc_attr( hdc );
1148 return dc_attr ? dc_attr->rel_abs_mode : 0;
1149 }
1150
1151 /***********************************************************************
1152 * SetRelAbs (GDI32.@)
1153 */
1154 INT WINAPI SetRelAbs( HDC hdc, INT mode )
1155 {
1156 DC_ATTR *dc_attr;
1157 INT ret;
1158
1159 if (mode != ABSOLUTE && mode != RELATIVE)
1160 {
1161 SetLastError(ERROR_INVALID_PARAMETER);
1162 return 0;
1163 }
1164
1165 if (is_meta_dc( hdc )) return METADC_SetRelAbs( hdc, mode );
1166 if (!(dc_attr = get_dc_attr( hdc ))) return 0;
1167 ret = dc_attr->rel_abs_mode;
1168 dc_attr->rel_abs_mode = mode;
1169 return ret;
1170 }
1171
1172 /***********************************************************************
1173 * SetROP2 (GDI32.@)
1174 */
1175 INT WINAPI SetROP2( HDC hdc, INT mode )
1176 {
1177 DC_ATTR *dc_attr;
1178 INT ret;
1179
1180 if ((mode < R2_BLACK) || (mode > R2_WHITE))
1181 {
1182 SetLastError(ERROR_INVALID_PARAMETER);
1183 return 0;
1184 }
1185
1186 if (is_meta_dc( hdc )) return METADC_SetROP2( hdc, mode );
1187 if (!(dc_attr = get_dc_attr( hdc ))) return 0;
1188 if (dc_attr->emf && !EMFDC_SetROP2( dc_attr, mode )) return 0;
1189
1190 ret = dc_attr->rop_mode;
1191 dc_attr->rop_mode = mode;
1192 return ret;
1193 }
1194
1195 /***********************************************************************
1196 * GetMiterLimit (GDI32.@)
1197 */
1198 BOOL WINAPI GetMiterLimit( HDC hdc, FLOAT *limit )
1199 {
1200 DC_ATTR *dc_attr;
1201 if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
1202 if (limit) *limit = dc_attr->miter_limit;
1203 return TRUE;
1204 }
1205
1206 /*******************************************************************
1207 * SetMiterLimit (GDI32.@)
1208 */
1209 BOOL WINAPI SetMiterLimit( HDC hdc, FLOAT limit, FLOAT *old_limit )
1210 {
1211 DC_ATTR *dc_attr;
1212 if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
1213 /* FIXME: record EMFs */
1214 if (old_limit) *old_limit = dc_attr->miter_limit;
1215 dc_attr->miter_limit = limit;
1216 return TRUE;
1217 }
1218
1219 /***********************************************************************
1220 * SetPixel (GDI32.@)
1221 */
1222 COLORREF WINAPI SetPixel( HDC hdc, INT x, INT y, COLORREF color )
1223 {
1224 DC_ATTR *dc_attr;
1225
1226 if (is_meta_dc( hdc )) return METADC_SetPixel( hdc, x, y, color );
1227 if (!(dc_attr = get_dc_attr( hdc ))) return CLR_INVALID;
1228 if (dc_attr->emf && !EMFDC_SetPixel( dc_attr, x, y, color )) return CLR_INVALID;
1229 return NtGdiSetPixel( hdc, x, y, color );
1230 }
1231
1232 /***********************************************************************
1233 * SetPixelV (GDI32.@)
1234 */
1235 BOOL WINAPI SetPixelV( HDC hdc, INT x, INT y, COLORREF color )
1236 {
1237 return SetPixel( hdc, x, y, color ) != CLR_INVALID;
1238 }
1239
1240 /***********************************************************************
1241 * LineTo (GDI32.@)
1242 */
1243 BOOL WINAPI LineTo( HDC hdc, INT x, INT y )
1244 {
1245 DC_ATTR *dc_attr;
1246
1247 TRACE( "%p, (%d, %d)\n", hdc, x, y );
1248
1249 if (is_meta_dc( hdc )) return METADC_LineTo( hdc, x, y );
1250 if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
1251 if (dc_attr->emf && !EMFDC_LineTo( dc_attr, x, y )) return FALSE;
1252 return NtGdiLineTo( hdc, x, y );
1253 }
1254
1255 /***********************************************************************
1256 * MoveToEx (GDI32.@)
1257 */
1258 BOOL WINAPI MoveToEx( HDC hdc, INT x, INT y, POINT *pt )
1259 {
1260 DC_ATTR *dc_attr;
1261
1262 TRACE( "%p, (%d, %d), %p\n", hdc, x, y, pt );
1263
1264 if (is_meta_dc( hdc )) return METADC_MoveTo( hdc, x, y );
1265 if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
1266 if (dc_attr->emf && !EMFDC_MoveTo( dc_attr, x, y )) return FALSE;
1267 return NtGdiMoveTo( hdc, x, y, pt );
1268 }
1269
1270 /***********************************************************************
1271 * Arc (GDI32.@)
1272 */
1273 BOOL WINAPI Arc( HDC hdc, INT left, INT top, INT right, INT bottom,
1274 INT xstart, INT ystart, INT xend, INT yend )
1275 {
1276 DC_ATTR *dc_attr;
1277
1278 TRACE( "%p, (%d, %d)-(%d, %d), (%d, %d), (%d, %d)\n", hdc, left, top,
1279 right, bottom, xstart, ystart, xend, yend );
1280
1281 if (is_meta_dc( hdc ))
1282 return METADC_Arc( hdc, left, top, right, bottom,
1283 xstart, ystart, xend, yend );
1284
1285 if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
1286 if (dc_attr->emf && !EMFDC_ArcChordPie( dc_attr, left, top, right, bottom,
1287 xstart, ystart, xend, yend, EMR_ARC ))
1288 return FALSE;
1289
1290 return NtGdiArcInternal( NtGdiArc, hdc, left, top, right, bottom,
1291 xstart, ystart, xend, yend );
1292 }
1293
1294 /***********************************************************************
1295 * ArcTo (GDI32.@)
1296 */
1297 BOOL WINAPI ArcTo( HDC hdc, INT left, INT top, INT right, INT bottom,
1298 INT xstart, INT ystart, INT xend, INT yend )
1299 {
1300 DC_ATTR *dc_attr;
1301
1302 TRACE( "%p, (%d, %d)-(%d, %d), (%d, %d), (%d, %d)\n", hdc, left, top,
1303 right, bottom, xstart, ystart, xend, yend );
1304
1305 if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
1306 if (dc_attr->emf && !EMFDC_ArcChordPie( dc_attr, left, top, right, bottom,
1307 xstart, ystart, xend, yend, EMR_ARCTO ))
1308 return FALSE;
1309
1310 return NtGdiArcInternal( NtGdiArcTo, hdc, left, top, right, bottom,
1311 xstart, ystart, xend, yend );
1312 }
1313
1314 /***********************************************************************
1315 * Chord (GDI32.@)
1316 */
1317 BOOL WINAPI Chord( HDC hdc, INT left, INT top, INT right, INT bottom,
1318 INT xstart, INT ystart, INT xend, INT yend )
1319 {
1320 DC_ATTR *dc_attr;
1321
1322 TRACE( "%p, (%d, %d)-(%d, %d), (%d, %d), (%d, %d)\n", hdc, left, top,
1323 right, bottom, xstart, ystart, xend, yend );
1324
1325 if (is_meta_dc( hdc ))
1326 return METADC_Chord( hdc, left, top, right, bottom,
1327 xstart, ystart, xend, yend );
1328
1329 if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
1330 if (dc_attr->emf && !EMFDC_ArcChordPie( dc_attr, left, top, right, bottom,
1331 xstart, ystart, xend, yend, EMR_CHORD ))
1332 return FALSE;
1333
1334 return NtGdiArcInternal( NtGdiChord, hdc, left, top, right, bottom,
1335 xstart, ystart, xend, yend );
1336 }
1337
1338 /***********************************************************************
1339 * Pie (GDI32.@)
1340 */
1341 BOOL WINAPI Pie( HDC hdc, INT left, INT top, INT right, INT bottom,
1342 INT xstart, INT ystart, INT xend, INT yend )
1343 {
1344 DC_ATTR *dc_attr;
1345
1346 TRACE( "%p, (%d, %d)-(%d, %d), (%d, %d), (%d, %d)\n", hdc, left, top,
1347 right, bottom, xstart, ystart, xend, yend );
1348
1349 if (is_meta_dc( hdc ))
1350 return METADC_Pie( hdc, left, top, right, bottom,
1351 xstart, ystart, xend, yend );
1352
1353 if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
1354 if (dc_attr->emf && !EMFDC_ArcChordPie( dc_attr, left, top, right, bottom,
1355 xstart, ystart, xend, yend, EMR_PIE ))
1356 return FALSE;
1357
1358 return NtGdiArcInternal( NtGdiPie, hdc, left, top, right, bottom,
1359 xstart, ystart, xend, yend );
1360 }
1361
1362 /***********************************************************************
1363 * AngleArc (GDI32.@)
1364 */
1365 BOOL WINAPI AngleArc( HDC hdc, INT x, INT y, DWORD radius, FLOAT start_angle, FLOAT sweep_angle )
1366 {
1367 DC_ATTR *dc_attr;
1368
1369 TRACE( "%p, (%d, %d), %lu, %f, %f\n", hdc, x, y, radius, start_angle, sweep_angle );
1370
1371 if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
1372 if (dc_attr->emf && !EMFDC_AngleArc( dc_attr, x, y, radius, start_angle, sweep_angle ))
1373 return FALSE;
1374 return NtGdiAngleArc( hdc, x, y, radius, start_angle, sweep_angle );
1375 }
1376
1377 /***********************************************************************
1378 * Ellipse (GDI32.@)
1379 */
1380 BOOL WINAPI Ellipse( HDC hdc, INT left, INT top, INT right, INT bottom )
1381 {
1382 DC_ATTR *dc_attr;
1383
1384 TRACE( "%p, (%d, %d)-(%d, %d)\n", hdc, left, top, right, bottom );
1385
1386 if (is_meta_dc( hdc )) return METADC_Ellipse( hdc, left, top, right, bottom );
1387 if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
1388 if (dc_attr->emf && !EMFDC_Ellipse( dc_attr, left, top, right, bottom )) return FALSE;
1389 return NtGdiEllipse( hdc, left, top, right, bottom );
1390 }
1391
1392 /***********************************************************************
1393 * Rectangle (GDI32.@)
1394 */
1395 BOOL WINAPI Rectangle( HDC hdc, INT left, INT top, INT right, INT bottom )
1396 {
1397 DC_ATTR *dc_attr;
1398
1399 TRACE( "%p, (%d, %d)-(%d, %d)\n", hdc, left, top, right, bottom );
1400
1401 if (is_meta_dc( hdc )) return METADC_Rectangle( hdc, left, top, right, bottom );
1402 if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
1403 if (dc_attr->emf && !EMFDC_Rectangle( dc_attr, left, top, right, bottom )) return FALSE;
1404 return NtGdiRectangle( hdc, left, top, right, bottom );
1405 }
1406
1407 /***********************************************************************
1408 * RoundRect (GDI32.@)
1409 */
1410 BOOL WINAPI RoundRect( HDC hdc, INT left, INT top, INT right,
1411 INT bottom, INT ell_width, INT ell_height )
1412 {
1413 DC_ATTR *dc_attr;
1414
1415 TRACE( "%p, (%d, %d)-(%d, %d), %dx%d\n", hdc, left, top, right, bottom,
1416 ell_width, ell_height );
1417
1418 if (is_meta_dc( hdc ))
1419 return METADC_RoundRect( hdc, left, top, right, bottom, ell_width, ell_height );
1420
1421 if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
1422 if (dc_attr->emf && !EMFDC_RoundRect( dc_attr, left, top, right, bottom,
1423 ell_width, ell_height ))
1424 return FALSE;
1425
1426 return NtGdiRoundRect( hdc, left, top, right, bottom, ell_width, ell_height );
1427 }
1428
1429 /**********************************************************************
1430 * Polygon (GDI32.@)
1431 */
1432 BOOL WINAPI Polygon( HDC hdc, const POINT *points, INT count )
1433 {
1434 DC_ATTR *dc_attr;
1435
1436 TRACE( "%p, %p, %d\n", hdc, points, count );
1437
1438 if (is_meta_dc( hdc )) return METADC_Polygon( hdc, points, count );
1439 if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
1440 if (dc_attr->emf && !EMFDC_Polygon( dc_attr, points, count )) return FALSE;
1441 return NtGdiPolyPolyDraw( hdc, points, (const ULONG *)&count, 1, NtGdiPolyPolygon );
1442 }
1443
1444 /**********************************************************************
1445 * PolyPolygon (GDI32.@)
1446 */
1447 BOOL WINAPI PolyPolygon( HDC hdc, const POINT *points, const INT *counts, UINT polygons )
1448 {
1449 DC_ATTR *dc_attr;
1450
1451 TRACE( "%p, %p, %p, %u\n", hdc, points, counts, polygons );
1452
1453 if (is_meta_dc( hdc )) return METADC_PolyPolygon( hdc, points, counts, polygons );
1454 if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
1455 if (dc_attr->emf && !EMFDC_PolyPolygon( dc_attr, points, counts, polygons )) return FALSE;
1456 return NtGdiPolyPolyDraw( hdc, points, (const ULONG *)counts, polygons, NtGdiPolyPolygon );
1457 }
1458
1459 /**********************************************************************
1460 * Polyline (GDI32.@)
1461 */
1462 BOOL WINAPI Polyline( HDC hdc, const POINT *points, INT count )
1463 {
1464 DC_ATTR *dc_attr;
1465
1466 TRACE( "%p, %p, %d\n", hdc, points, count );
1467
1468 if (is_meta_dc( hdc )) return METADC_Polyline( hdc, points, count );
1469 if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
1470 if (dc_attr->emf && !EMFDC_Polyline( dc_attr, points, count )) return FALSE;
1471 return NtGdiPolyPolyDraw( hdc, points, (const ULONG *)&count, 1, NtGdiPolyPolyline );
1472 }
1473
1474 /**********************************************************************
1475 * PolyPolyline (GDI32.@)
1476 */
1477 BOOL WINAPI PolyPolyline( HDC hdc, const POINT *points, const DWORD *counts, DWORD polylines )
1478 {
1479 DC_ATTR *dc_attr;
1480
1481 TRACE( "%p, %p, %p, %lu\n", hdc, points, counts, polylines );
1482
1483 if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
1484 if (dc_attr->emf && !EMFDC_PolyPolyline( dc_attr, points, counts, polylines )) return FALSE;
1485 return NtGdiPolyPolyDraw( hdc, points, counts, polylines, NtGdiPolyPolyline );
1486 }
1487
1488 /******************************************************************************
1489 * PolyBezier (GDI32.@)
1490 */
1491 BOOL WINAPI PolyBezier( HDC hdc, const POINT *points, DWORD count )
1492 {
1493 DC_ATTR *dc_attr;
1494
1495 TRACE( "%p, %p, %lu\n", hdc, points, count );
1496
1497 if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
1498 if (dc_attr->emf && !EMFDC_PolyBezier( dc_attr, points, count )) return FALSE;
1499 return NtGdiPolyPolyDraw( hdc, points, &count, 1, NtGdiPolyBezier );
1500 }
1501
1502 /******************************************************************************
1503 * PolyBezierTo (GDI32.@)
1504 */
1505 BOOL WINAPI PolyBezierTo( HDC hdc, const POINT *points, DWORD count )
1506 {
1507 DC_ATTR *dc_attr;
1508
1509 TRACE( "%p, %p, %lu\n", hdc, points, count );
1510
1511 if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
1512 if (dc_attr->emf && !EMFDC_PolyBezierTo( dc_attr, points, count )) return FALSE;
1513 return NtGdiPolyPolyDraw( hdc, points, &count, 1, NtGdiPolyBezierTo );
1514 }
1515
1516 /**********************************************************************
1517 * PolylineTo (GDI32.@)
1518 */
1519 BOOL WINAPI PolylineTo( HDC hdc, const POINT *points, DWORD count )
1520 {
1521 DC_ATTR *dc_attr;
1522
1523 TRACE( "%p, %p, %lu\n", hdc, points, count );
1524
1525 if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
1526 if (dc_attr->emf && !EMFDC_PolylineTo( dc_attr, points, count )) return FALSE;
1527 return NtGdiPolyPolyDraw( hdc, points, &count, 1, NtGdiPolylineTo );
1528 }
1529
1530 /***********************************************************************
1531 * PolyDraw (GDI32.@)
1532 */
1533 BOOL WINAPI PolyDraw( HDC hdc, const POINT *points, const BYTE *types, DWORD count )
1534 {
1535 DC_ATTR *dc_attr;
1536
1537 TRACE( "%p, %p, %p, %lu\n", hdc, points, types, count );
1538
1539 if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
1540 if (dc_attr->emf && !EMFDC_PolyDraw( dc_attr, points, types, count )) return FALSE;
1541 return NtGdiPolyDraw( hdc, points, types, count );
1542 }
1543
1544 /***********************************************************************
1545 * FillRgn (GDI32.@)
1546 */
1547 BOOL WINAPI FillRgn( HDC hdc, HRGN hrgn, HBRUSH hbrush )
1548 {
1549 DC_ATTR *dc_attr;
1550
1551 TRACE( "%p, %p, %p\n", hdc, hrgn, hbrush );
1552
1553 if (is_meta_dc( hdc )) return METADC_FillRgn( hdc, hrgn, hbrush );
1554 if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
1555 if (dc_attr->emf && !EMFDC_FillRgn( dc_attr, hrgn, hbrush )) return FALSE;
1556 return NtGdiFillRgn( hdc, hrgn, hbrush );
1557 }
1558
1559 /***********************************************************************
1560 * PaintRgn (GDI32.@)
1561 */
1562 BOOL WINAPI PaintRgn( HDC hdc, HRGN hrgn )
1563 {
1564 DC_ATTR *dc_attr;
1565
1566 TRACE( "%p, %p\n", hdc, hrgn );
1567
1568 if (is_meta_dc( hdc )) return METADC_PaintRgn( hdc, hrgn );
1569 if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
1570 if (dc_attr->emf && !EMFDC_PaintRgn( dc_attr, hrgn )) return FALSE;
1571 return NtGdiFillRgn( hdc, hrgn, GetCurrentObject( hdc, OBJ_BRUSH ));
1572 }
1573
1574 /***********************************************************************
1575 * FrameRgn (GDI32.@)
1576 */
1577 BOOL WINAPI FrameRgn( HDC hdc, HRGN hrgn, HBRUSH hbrush, INT width, INT height )
1578 {
1579 DC_ATTR *dc_attr;
1580
1581 TRACE( "%p, %p, %p, %dx%d\n", hdc, hrgn, hbrush, width, height );
1582
1583 if (is_meta_dc( hdc )) return METADC_FrameRgn( hdc, hrgn, hbrush, width, height );
1584 if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
1585 if (dc_attr->emf && !EMFDC_FrameRgn( dc_attr, hrgn, hbrush, width, height ))
1586 return FALSE;
1587 return NtGdiFrameRgn( hdc, hrgn, hbrush, width, height );
1588 }
1589
1590 /***********************************************************************
1591 * InvertRgn (GDI32.@)
1592 */
1593 BOOL WINAPI InvertRgn( HDC hdc, HRGN hrgn )
1594 {
1595 DC_ATTR *dc_attr;
1596
1597 TRACE( "%p, %p\n", hdc, hrgn );
1598
1599 if (is_meta_dc( hdc )) return METADC_InvertRgn( hdc, hrgn );
1600 if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
1601 if (dc_attr->emf && !EMFDC_InvertRgn( dc_attr, hrgn )) return FALSE;
1602 return NtGdiInvertRgn( hdc, hrgn );
1603 }
1604
1605 /***********************************************************************
1606 * ExtFloodFill (GDI32.@)
1607 */
1608 BOOL WINAPI ExtFloodFill( HDC hdc, INT x, INT y, COLORREF color, UINT fill_type )
1609 {
1610 DC_ATTR *dc_attr;
1611
1612 TRACE( "%p, (%d, %d), %08lx, %x\n", hdc, x, y, color, fill_type );
1613
1614 if (is_meta_dc( hdc )) return METADC_ExtFloodFill( hdc, x, y, color, fill_type );
1615 if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
1616 if (dc_attr->emf && !EMFDC_ExtFloodFill( dc_attr, x, y, color, fill_type )) return FALSE;
1617 return NtGdiExtFloodFill( hdc, x, y, color, fill_type );
1618 }
1619
1620 /***********************************************************************
1621 * FloodFill (GDI32.@)
1622 */
1623 BOOL WINAPI FloodFill( HDC hdc, INT x, INT y, COLORREF color )
1624 {
1625 return ExtFloodFill( hdc, x, y, color, FLOODFILLBORDER );
1626 }
1627
1628 /******************************************************************************
1629 * GdiGradientFill (GDI32.@)
1630 */
1631 BOOL WINAPI GdiGradientFill( HDC hdc, TRIVERTEX *vert_array, ULONG nvert,
1632 void *grad_array, ULONG ngrad, ULONG mode )
1633 {
1634 DC_ATTR *dc_attr;
1635
1636 TRACE( "%p vert_array:%p nvert:%ld grad_array:%p ngrad:%ld\n", hdc, vert_array,
1637 nvert, grad_array, ngrad );
1638
1639 if (!(dc_attr = get_dc_attr( hdc )))
1640 {
1641 SetLastError( ERROR_INVALID_PARAMETER );
1642 return FALSE;
1643 }
1644 if (dc_attr->emf &&
1645 !EMFDC_GradientFill( dc_attr, vert_array, nvert, grad_array, ngrad, mode ))
1646 return FALSE;
1647 return NtGdiGradientFill( hdc, vert_array, nvert, grad_array, ngrad, mode );
1648 }
1649
1650 /***********************************************************************
1651 * SetTextJustification (GDI32.@)
1652 */
1653 BOOL WINAPI SetTextJustification( HDC hdc, INT extra, INT breaks )
1654 {
1655 DC_ATTR *dc_attr;
1656
1657 if (is_meta_dc( hdc )) return METADC_SetTextJustification( hdc, extra, breaks );
1658 if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
1659 if (dc_attr->emf && !EMFDC_SetTextJustification( dc_attr, extra, breaks ))
1660 return FALSE;
1661 return NtGdiSetTextJustification( hdc, extra, breaks );
1662 }
1663
1664 /***********************************************************************
1665 * PatBlt (GDI32.@)
1666 */
1667 BOOL WINAPI PatBlt( HDC hdc, INT left, INT top, INT width, INT height, DWORD rop )
1668 {
1669 DC_ATTR *dc_attr;
1670
1671 if (is_meta_dc( hdc )) return METADC_PatBlt( hdc, left, top, width, height, rop );
1672 if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
1673 if (dc_attr->emf && !EMFDC_PatBlt( dc_attr, left, top, width, height, rop ))
1674 return FALSE;
1675 return NtGdiPatBlt( hdc, left, top, width, height, rop );
1676 }
1677
1678 /***********************************************************************
1679 * BitBlt (GDI32.@)
1680 */
1681 BOOL WINAPI DECLSPEC_HOTPATCH BitBlt( HDC hdc_dst, INT x_dst, INT y_dst, INT width, INT height,
1682 HDC hdc_src, INT x_src, INT y_src, DWORD rop )
1683 {
1684 DC_ATTR *dc_attr;
1685
1686 if (is_meta_dc( hdc_dst )) return METADC_BitBlt( hdc_dst, x_dst, y_dst, width, height,
1687 hdc_src, x_src, y_src, rop );
1688 if (!(dc_attr = get_dc_attr( hdc_dst ))) return FALSE;
1689 if (dc_attr->emf && !EMFDC_BitBlt( dc_attr, x_dst, y_dst, width, height,
1690 hdc_src, x_src, y_src, rop ))
1691 return FALSE;
1692 return NtGdiBitBlt( hdc_dst, x_dst, y_dst, width, height,
1693 hdc_src, x_src, y_src, rop, 0 /* FIXME */, 0 /* FIXME */ );
1694 }
1695
1696 /***********************************************************************
1697 * StretchBlt (GDI32.@)
1698 */
1699 BOOL WINAPI StretchBlt( HDC hdc, INT x_dst, INT y_dst, INT width_dst, INT height_dst,
1700 HDC hdc_src, INT x_src, INT y_src, INT width_src, INT height_src,
1701 DWORD rop )
1702 {
1703 DC_ATTR *dc_attr;
1704
1705 if (is_meta_dc( hdc )) return METADC_StretchBlt( hdc, x_dst, y_dst, width_dst, height_dst,
1706 hdc_src, x_src, y_src, width_src,
1707 height_src, rop );
1708 if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
1709 if (dc_attr->emf && !EMFDC_StretchBlt( dc_attr, x_dst, y_dst, width_dst, height_dst,
1710 hdc_src, x_src, y_src, width_src,
1711 height_src, rop ))
1712 return FALSE;
1713 return NtGdiStretchBlt( hdc, x_dst, y_dst, width_dst, height_dst,
1714 hdc_src, x_src, y_src, width_src,
1715 height_src, rop, 0 /* FIXME */ );
1716 }
1717
1718 /***********************************************************************
1719 * MaskBlt [GDI32.@]
1720 */
1721 BOOL WINAPI MaskBlt( HDC hdc, INT x_dst, INT y_dst, INT width_dst, INT height_dst,
1722 HDC hdc_src, INT x_src, INT y_src, HBITMAP mask,
1723 INT x_mask, INT y_mask, DWORD rop )
1724 {
1725 DC_ATTR *dc_attr;
1726
1727 if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
1728 if (dc_attr->emf && !EMFDC_MaskBlt( dc_attr, x_dst, y_dst, width_dst, height_dst,
1729 hdc_src, x_src, y_src, mask, x_mask, y_mask, rop ))
1730 return FALSE;
1731 return NtGdiMaskBlt( hdc, x_dst, y_dst, width_dst, height_dst, hdc_src, x_src, y_src,
1732 mask, x_mask, y_mask, rop, 0 /* FIXME */ );
1733 }
1734
1735 /***********************************************************************
1736 * PlgBlt (GDI32.@)
1737 */
1738 BOOL WINAPI PlgBlt( HDC hdc, const POINT *points, HDC hdc_src, INT x_src, INT y_src,
1739 INT width, INT height, HBITMAP mask, INT x_mask, INT y_mask )
1740 {
1741 DC_ATTR *dc_attr;
1742
1743 if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
1744 if (dc_attr->emf && !EMFDC_PlgBlt( dc_attr, points, hdc_src, x_src, y_src,
1745 width, height, mask, x_mask, y_mask ))
1746 return FALSE;
1747 return NtGdiPlgBlt( hdc, points, hdc_src, x_src, y_src, width, height,
1748 mask, x_mask, y_mask, 0 /* FIXME */ );
1749 }
1750
1751 /******************************************************************************
1752 * GdiTransparentBlt (GDI32.@)
1753 */
1754 BOOL WINAPI GdiTransparentBlt( HDC hdc, int x_dst, int y_dst, int width_dst, int height_dst,
1755 HDC hdc_src, int x_src, int y_src, int width_src, int height_src,
1756 UINT color )
1757 {
1758 DC_ATTR *dc_attr;
1759
1760 if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
1761 if (dc_attr->emf && !EMFDC_TransparentBlt( dc_attr, x_dst, y_dst, width_dst, height_dst, hdc_src,
1762 x_src, y_src, width_src, height_src, color ))
1763 return FALSE;
1764 return NtGdiTransparentBlt( hdc, x_dst, y_dst, width_dst, height_dst, hdc_src, x_src, y_src,
1765 width_src, height_src, color );
1766 }
1767
1768 /******************************************************************************
1769 * GdiAlphaBlend (GDI32.@)
1770 */
1771 BOOL WINAPI GdiAlphaBlend( HDC hdc_dst, int x_dst, int y_dst, int width_dst, int height_dst,
1772 HDC hdc_src, int x_src, int y_src, int width_src, int height_src,
1773 BLENDFUNCTION blend_function)
1774 {
1775 DC_ATTR *dc_attr;
1776
1777 if (!(dc_attr = get_dc_attr( hdc_dst ))) return FALSE;
1778 if (dc_attr->emf && !EMFDC_AlphaBlend( dc_attr, x_dst, y_dst, width_dst, height_dst,
1779 hdc_src, x_src, y_src, width_src,
1780 height_src, blend_function ))
1781 return FALSE;
1782 return NtGdiAlphaBlend( hdc_dst, x_dst, y_dst, width_dst, height_dst,
1783 hdc_src, x_src, y_src, width_src, height_src,
1784 blend_function, 0 /* FIXME */ );
1785 }
1786
1787 /***********************************************************************
1788 * SetDIBitsToDevice (GDI32.@)
1789 */
1790 INT WINAPI SetDIBitsToDevice( HDC hdc, INT x_dst, INT y_dst, DWORD cx,
1791 DWORD cy, INT x_src, INT y_src, UINT startscan,
1792 UINT lines, const void *bits, const BITMAPINFO *bmi,
1793 UINT coloruse )
1794 {
1795 DC_ATTR *dc_attr;
1796
1797 if (is_meta_dc( hdc ))
1798 return METADC_SetDIBitsToDevice( hdc, x_dst, y_dst, cx, cy, x_src, y_src, startscan,
1799 lines, bits, bmi, coloruse );
1800 if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
1801 if (dc_attr->emf && !EMFDC_SetDIBitsToDevice( dc_attr, x_dst, y_dst, cx, cy, x_src, y_src,
1802 startscan, lines, bits, bmi, coloruse ))
1803 return 0;
1804 return NtGdiSetDIBitsToDeviceInternal( hdc, x_dst, y_dst, cx, cy, x_src, y_src,
1805 startscan, lines, bits, bmi, coloruse,
1806 0, 0, FALSE, NULL );
1807 }
1808
1809 /***********************************************************************
1810 * StretchDIBits (GDI32.@)
1811 */
1812 INT WINAPI DECLSPEC_HOTPATCH StretchDIBits( HDC hdc, INT x_dst, INT y_dst, INT width_dst,
1813 INT height_dst, INT x_src, INT y_src, INT width_src,
1814 INT height_src, const void *bits, const BITMAPINFO *bmi,
1815 UINT coloruse, DWORD rop )
1816 {
1817 DC_ATTR *dc_attr;
1818
1819 if (is_meta_dc( hdc ))
1820 return METADC_StretchDIBits( hdc, x_dst, y_dst, width_dst, height_dst, x_src, y_src,
1821 width_src, height_src, bits, bmi, coloruse, rop );
1822 if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
1823 if (dc_attr->emf && !EMFDC_StretchDIBits( dc_attr, x_dst, y_dst, width_dst, height_dst,
1824 x_src, y_src, width_src, height_src, bits,
1825 bmi, coloruse, rop ))
1826 return FALSE;
1827 return NtGdiStretchDIBitsInternal( hdc, x_dst, y_dst, width_dst, height_dst, x_src, y_src,
1828 width_src, height_src, bits, bmi, coloruse, rop,
1829 0, 0, NULL );
1830 }
1831
1832 /***********************************************************************
1833 * BeginPath (GDI32.@)
1834 */
1835 BOOL WINAPI BeginPath(HDC hdc)
1836 {
1837 DC_ATTR *dc_attr;
1838
1839 if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
1840 if (dc_attr->emf && !EMFDC_BeginPath( dc_attr )) return FALSE;
1841 return NtGdiBeginPath( hdc );
1842 }
1843
1844 /***********************************************************************
1845 * EndPath (GDI32.@)
1846 */
1847 BOOL WINAPI EndPath(HDC hdc)
1848 {
1849 DC_ATTR *dc_attr;
1850
1851 if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
1852 if (dc_attr->emf && !EMFDC_EndPath( dc_attr )) return FALSE;
1853 return NtGdiEndPath( hdc );
1854 }
1855
1856 /***********************************************************************
1857 * AbortPath (GDI32.@)
1858 */
1859 BOOL WINAPI AbortPath( HDC hdc )
1860 {
1861 DC_ATTR *dc_attr;
1862
1863 if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
1864 if (dc_attr->emf && !EMFDC_AbortPath( dc_attr )) return FALSE;
1865 return NtGdiAbortPath( hdc );
1866 }
1867
1868 /***********************************************************************
1869 * CloseFigure (GDI32.@)
1870 */
1871 BOOL WINAPI CloseFigure( HDC hdc )
1872 {
1873 DC_ATTR *dc_attr;
1874
1875 if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
1876 if (dc_attr->emf && !EMFDC_CloseFigure( dc_attr )) return FALSE;
1877 return NtGdiCloseFigure( hdc );
1878 }
1879
1880 /***********************************************************************
1881 * FillPath (GDI32.@)
1882 */
1883 BOOL WINAPI FillPath( HDC hdc )
1884 {
1885 DC_ATTR *dc_attr;
1886
1887 if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
1888 if (dc_attr->emf && !EMFDC_FillPath( dc_attr )) return FALSE;
1889 return NtGdiFillPath( hdc );
1890 }
1891
1892 /*******************************************************************
1893 * StrokeAndFillPath (GDI32.@)
1894 */
1895 BOOL WINAPI StrokeAndFillPath( HDC hdc )
1896 {
1897 DC_ATTR *dc_attr;
1898
1899 if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
1900 if (dc_attr->emf && !EMFDC_StrokeAndFillPath( dc_attr )) return FALSE;
1901 return NtGdiStrokeAndFillPath( hdc );
1902 }
1903
1904 /*******************************************************************
1905 * StrokePath (GDI32.@)
1906 */
1907 BOOL WINAPI StrokePath( HDC hdc )
1908 {
1909 DC_ATTR *dc_attr;
1910
1911 if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
1912 if (dc_attr->emf && !EMFDC_StrokePath( dc_attr )) return FALSE;
1913 return NtGdiStrokePath( hdc );
1914 }
1915
1916 /***********************************************************************
1917 * FlattenPath (GDI32.@)
1918 */
1919 BOOL WINAPI FlattenPath( HDC hdc )
1920 {
1921 DC_ATTR *dc_attr;
1922
1923 if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
1924 if (dc_attr->emf && !EMFDC_FlattenPath( dc_attr )) return FALSE;
1925 return NtGdiFlattenPath( hdc );
1926 }
1927
1928 /***********************************************************************
1929 * WidenPath (GDI32.@)
1930 */
1931 BOOL WINAPI WidenPath( HDC hdc )
1932 {
1933 DC_ATTR *dc_attr;
1934
1935 if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
1936 if (dc_attr->emf && !EMFDC_WidenPath( dc_attr )) return FALSE;
1937 return NtGdiWidenPath( hdc );
1938 }
1939
1940 /***********************************************************************
1941 * SelectClipPath (GDI32.@)
1942 */
1943 BOOL WINAPI SelectClipPath( HDC hdc, INT mode )
1944 {
1945 DC_ATTR *dc_attr;
1946
1947 if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
1948 if (dc_attr->emf && !EMFDC_SelectClipPath( dc_attr, mode )) return FALSE;
1949 return NtGdiSelectClipPath( hdc, mode );
1950 }
1951
1952 /***********************************************************************
1953 * GetClipRgn (GDI32.@)
1954 */
1955 INT WINAPI GetClipRgn( HDC hdc, HRGN rgn )
1956 {
1957 return NtGdiGetRandomRgn( hdc, rgn, NTGDI_RGN_MIRROR_RTL | 1 );
1958 }
1959
1960 /***********************************************************************
1961 * GetMetaRgn (GDI32.@)
1962 */
1963 INT WINAPI GetMetaRgn( HDC hdc, HRGN rgn )
1964 {
1965 return NtGdiGetRandomRgn( hdc, rgn, NTGDI_RGN_MIRROR_RTL | 2 );
1966 }
1967
1968 /***********************************************************************
1969 * IntersectClipRect (GDI32.@)
1970 */
1971 INT WINAPI IntersectClipRect( HDC hdc, INT left, INT top, INT right, INT bottom )
1972 {
1973 DC_ATTR *dc_attr;
1974
1975 TRACE("%p %d,%d - %d,%d\n", hdc, left, top, right, bottom );
1976
1977 if (is_meta_dc( hdc )) return METADC_IntersectClipRect( hdc, left, top, right, bottom );
1978 if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
1979 if (dc_attr->emf && !EMFDC_IntersectClipRect( dc_attr, left, top, right, bottom ))
1980 return FALSE;
1981 return NtGdiIntersectClipRect( hdc, left, top, right, bottom );
1982 }
1983
1984 /***********************************************************************
1985 * OffsetClipRgn (GDI32.@)
1986 */
1987 INT WINAPI OffsetClipRgn( HDC hdc, INT x, INT y )
1988 {
1989 DC_ATTR *dc_attr;
1990
1991 if (is_meta_dc( hdc )) return METADC_OffsetClipRgn( hdc, x, y );
1992 if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
1993 if (dc_attr->emf && !EMFDC_OffsetClipRgn( dc_attr, x, y )) return FALSE;
1994 return NtGdiOffsetClipRgn( hdc, x, y );
1995 }
1996
1997 /***********************************************************************
1998 * ExcludeClipRect (GDI32.@)
1999 */
2000 INT WINAPI ExcludeClipRect( HDC hdc, INT left, INT top, INT right, INT bottom )
2001 {
2002 DC_ATTR *dc_attr;
2003
2004 if (is_meta_dc( hdc )) return METADC_ExcludeClipRect( hdc, left, top, right, bottom );
2005 if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
2006 if (dc_attr->emf && !EMFDC_ExcludeClipRect( dc_attr, left, top, right, bottom ))
2007 return FALSE;
2008 return NtGdiExcludeClipRect( hdc, left, top, right, bottom );
2009 }
2010
2011 /******************************************************************************
2012 * ExtSelectClipRgn (GDI32.@)
2013 */
2014 INT WINAPI ExtSelectClipRgn( HDC hdc, HRGN hrgn, INT mode )
2015 {
2016 DC_ATTR *dc_attr;
2017
2018 TRACE("%p %p %d\n", hdc, hrgn, mode );
2019
2020 if (is_meta_dc( hdc )) return METADC_ExtSelectClipRgn( hdc, hrgn, mode );
2021 if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
2022 if (dc_attr->emf && !EMFDC_ExtSelectClipRgn( dc_attr, hrgn, mode ))
2023 return FALSE;
2024 return NtGdiExtSelectClipRgn( hdc, hrgn, mode );
2025 }
2026
2027 /***********************************************************************
2028 * SelectClipRgn (GDI32.@)
2029 */
2030 INT WINAPI SelectClipRgn( HDC hdc, HRGN hrgn )
2031 {
2032 return ExtSelectClipRgn( hdc, hrgn, RGN_COPY );
2033 }
2034
2035 /***********************************************************************
2036 * SetMetaRgn (GDI32.@)
2037 */
2038 INT WINAPI SetMetaRgn( HDC hdc )
2039 {
2040 DC_ATTR *dc_attr;
2041
2042 if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
2043 if (dc_attr->emf) FIXME( "EMFs are not yet supported\n" );
2044 return NtGdiSetMetaRgn( hdc );
2045 }
2046
2047 /***********************************************************************
2048 * DPtoLP (GDI32.@)
2049 */
2050 BOOL WINAPI DPtoLP( HDC hdc, POINT *points, INT count )
2051 {
2052 return NtGdiTransformPoints( hdc, points, points, count, NtGdiDPtoLP );
2053 }
2054
2055 /***********************************************************************
2056 * LPtoDP (GDI32.@)
2057 */
2058 BOOL WINAPI LPtoDP( HDC hdc, POINT *points, INT count )
2059 {
2060 return NtGdiTransformPoints( hdc, points, points, count, NtGdiLPtoDP );
2061 }
2062
2063 /***********************************************************************
2064 * ScaleViewportExtEx (GDI32.@)
2065 */
2066 BOOL WINAPI ScaleViewportExtEx( HDC hdc, INT x_num, INT x_denom,
2067 INT y_num, INT y_denom, SIZE *size )
2068 {
2069 DC_ATTR *dc_attr;
2070
2071 if (is_meta_dc( hdc )) return METADC_ScaleViewportExtEx( hdc, x_num, x_denom, y_num, y_denom );
2072 if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
2073 if (dc_attr->emf && !EMFDC_ScaleViewportExtEx( dc_attr, x_num, x_denom, y_num, y_denom ))
2074 return FALSE;
2075 return NtGdiScaleViewportExtEx( hdc, x_num, x_denom, y_num, y_denom, size );
2076 }
2077
2078 /***********************************************************************
2079 * ScaleWindowExtEx (GDI32.@)
2080 */
2081 BOOL WINAPI ScaleWindowExtEx( HDC hdc, INT x_num, INT x_denom,
2082 INT y_num, INT y_denom, SIZE *size )
2083 {
2084 DC_ATTR *dc_attr;
2085
2086 if (is_meta_dc( hdc )) return METADC_ScaleWindowExtEx( hdc, x_num, x_denom, y_num, y_denom );
2087 if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
2088 if (dc_attr->emf && !EMFDC_ScaleWindowExtEx( dc_attr, x_num, x_denom, y_num, y_denom ))
2089 return FALSE;
2090 return NtGdiScaleWindowExtEx( hdc, x_num, x_denom, y_num, y_denom, size );
2091 }
2092
2093 static UINT WINAPI realize_palette( HDC hdc )
2094 {
2095 return NtUserRealizePalette( hdc );
2096 }
2097
2098 /* Pointers to USER implementation of SelectPalette/RealizePalette */
2099 /* they will be patched by USER on startup */
2100 HPALETTE (WINAPI *pfnSelectPalette)( HDC hdc, HPALETTE hpal, WORD bkgnd ) = NtUserSelectPalette;
2101 UINT (WINAPI *pfnRealizePalette)( HDC hdc ) = realize_palette;
2102
2103 /***********************************************************************
2104 * SelectPalette (GDI32.@)
2105 */
2106 HPALETTE WINAPI SelectPalette( HDC hdc, HPALETTE palette, BOOL force_background )
2107 {
2108 DC_ATTR *dc_attr;
2109
2110 palette = get_full_gdi_handle( palette );
2111 if (is_meta_dc( hdc )) return ULongToHandle( METADC_SelectPalette( hdc, palette ) );
2112 if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
2113 if (dc_attr->emf && !EMFDC_SelectPalette( dc_attr, palette )) return 0;
2114 return pfnSelectPalette( hdc, palette, force_background );
2115 }
2116
2117 /***********************************************************************
2118 * RealizePalette (GDI32.@)
2119 */
2120 UINT WINAPI RealizePalette( HDC hdc )
2121 {
2122 if (is_meta_dc( hdc )) return METADC_RealizePalette( hdc );
2123 return pfnRealizePalette( hdc );
2124 }
2125
2126 /***********************************************************************
2127 * GdiSetPixelFormat (GDI32.@)
2128 */
2129 BOOL WINAPI GdiSetPixelFormat( HDC hdc, INT format, const PIXELFORMATDESCRIPTOR *descr )
2130 {
2131 TRACE( "(%p,%d,%p)\n", hdc, format, descr );
2132 return NtGdiSetPixelFormat( hdc, format );
2133 }
2134
2135 /***********************************************************************
2136 * CancelDC (GDI32.@)
2137 */
2138 BOOL WINAPI CancelDC(HDC hdc)
2139 {
2140 FIXME( "stub\n" );
2141 return TRUE;
2142 }
2143
2144 /***********************************************************************
2145 * StartDocW [GDI32.@]
2146 *
2147 * StartDoc calls the STARTDOC Escape with the input data pointing to DocName
2148 * and the output data (which is used as a second input parameter).pointing at
2149 * the whole docinfo structure. This seems to be an undocumented feature of
2150 * the STARTDOC Escape.
2151 *
2152 * Note: we now do it the other way, with the STARTDOC Escape calling StartDoc.
2153 */
2154 INT WINAPI StartDocW( HDC hdc, const DOCINFOW *doc )
2155 {
2156 DC_ATTR *dc_attr;
2157 ABORTPROC proc;
2158
2159 TRACE("DocName %s, Output %s, Datatype %s, fwType %#lx\n",
2160 debugstr_w(doc->lpszDocName), debugstr_w(doc->lpszOutput),
2161 debugstr_w(doc->lpszDatatype), doc->fwType);
2162
2163 if (!(dc_attr = get_dc_attr( hdc ))) return SP_ERROR;
2164
2165 proc = (ABORTPROC)(UINT_PTR)dc_attr->abort_proc;
2166 if (proc && !proc( hdc, 0 )) return 0;
2167 return NtGdiStartDoc( hdc, doc, NULL, 0 );
2168 }
2169
2170 /***********************************************************************
2171 * StartDocA [GDI32.@]
2172 */
2173 INT WINAPI StartDocA( HDC hdc, const DOCINFOA *doc )
2174 {
2175 WCHAR *doc_name = NULL, *output = NULL, *data_type = NULL;
2176 DOCINFOW docW;
2177 INT ret, len;
2178
2179 docW.cbSize = doc->cbSize;
2180 if (doc->lpszDocName)
2181 {
2182 len = MultiByteToWideChar( CP_ACP, 0, doc->lpszDocName, -1, NULL, 0 );
2183 doc_name = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
2184 MultiByteToWideChar( CP_ACP, 0, doc->lpszDocName, -1, doc_name, len );
2185 }
2186 if (doc->lpszOutput)
2187 {
2188 len = MultiByteToWideChar( CP_ACP, 0, doc->lpszOutput, -1, NULL, 0 );
2189 output = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
2190 MultiByteToWideChar( CP_ACP, 0, doc->lpszOutput, -1, output, len );
2191 }
2192 if (doc->lpszDatatype)
2193 {
2194 len = MultiByteToWideChar( CP_ACP, 0, doc->lpszDatatype, -1, NULL, 0);
2195 data_type = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
2196 MultiByteToWideChar( CP_ACP, 0, doc->lpszDatatype, -1, data_type, len );
2197 }
2198
2199 docW.lpszDocName = doc_name;
2200 docW.lpszOutput = output;
2201 docW.lpszDatatype = data_type;
2202 docW.fwType = doc->fwType;
2203
2204 ret = StartDocW(hdc, &docW);
2205
2206 HeapFree( GetProcessHeap(), 0, doc_name );
2207 HeapFree( GetProcessHeap(), 0, output );
2208 HeapFree( GetProcessHeap(), 0, data_type );
2209 return ret;
2210 }
2211
2212 /***********************************************************************
2213 * StartPage (GDI32.@)
2214 */
2215 INT WINAPI StartPage( HDC hdc )
2216 {
2217 return NtGdiStartPage( hdc );
2218 }
2219
2220 /***********************************************************************
2221 * EndPage (GDI32.@)
2222 */
2223 INT WINAPI EndPage( HDC hdc )
2224 {
2225 return NtGdiEndPage( hdc );
2226 }
2227
2228 /***********************************************************************
2229 * EndDoc (GDI32.@)
2230 */
2231 INT WINAPI EndDoc( HDC hdc )
2232 {
2233 return NtGdiEndDoc( hdc );
2234 }
2235
2236 /***********************************************************************
2237 * AbortDoc (GDI32.@)
2238 */
2239 INT WINAPI AbortDoc( HDC hdc )
2240 {
2241 return NtGdiAbortDoc( hdc );
2242 }
2243
2244 /**********************************************************************
2245 * SetAbortProc (GDI32.@)
2246 */
2247 INT WINAPI SetAbortProc( HDC hdc, ABORTPROC abrtprc )
2248 {
2249 DC_ATTR *dc_attr;
2250
2251 if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
2252 dc_attr->abort_proc = (UINT_PTR)abrtprc;
2253 return TRUE;
2254 }
2255
2256 /***********************************************************************
2257 * SetICMMode (GDI32.@)
2258 */
2259 INT WINAPI SetICMMode( HDC hdc, INT mode )
2260 {
2261 /* FIXME: Assume that ICM is always off, and cannot be turned on */
2262 switch (mode)
2263 {
2264 case ICM_OFF: return ICM_OFF;
2265 case ICM_ON: return 0;
2266 case ICM_QUERY: return ICM_OFF;
2267 }
2268 return 0;
2269 }
2270
2271 /***********************************************************************
2272 * GdiIsMetaPrintDC (GDI32.@)
2273 */
2274 BOOL WINAPI GdiIsMetaPrintDC( HDC hdc )
2275 {
2276 FIXME( "%p\n", hdc );
2277 return FALSE;
2278 }
2279
2280 /***********************************************************************
2281 * GdiIsMetaFileDC (GDI32.@)
2282 */
2283 BOOL WINAPI GdiIsMetaFileDC( HDC hdc )
2284 {
2285 TRACE( "%p\n", hdc );
2286
2287 switch (GetObjectType( hdc ))
2288 {
2289 case OBJ_METADC:
2290 case OBJ_ENHMETADC:
2291 return TRUE;
2292 }
2293 return FALSE;
2294 }
2295
2296 /***********************************************************************
2297 * GdiIsPlayMetafileDC (GDI32.@)
2298 */
2299 BOOL WINAPI GdiIsPlayMetafileDC( HDC hdc )
2300 {
2301 FIXME( "%p\n", hdc );
2302 return FALSE;
2303 }
2304
2305 /*******************************************************************
2306 * DrawEscape (GDI32.@)
2307 */
2308 INT WINAPI DrawEscape( HDC hdc, INT escape, INT input_size, const char *input )
2309 {
2310 FIXME( "stub\n" );
2311 return 0;
2312 }
2313
2314 /*******************************************************************
2315 * NamedEscape (GDI32.@)
2316 */
2317 INT WINAPI NamedEscape( HDC hdc, const WCHAR *driver, INT escape, INT input_size,
2318 const char *input, INT output_size, char *output )
2319 {
2320 FIXME( "(%p %s %d, %d %p %d %p)\n", hdc, wine_dbgstr_w(driver), escape, input_size,
2321 input, output_size, output );
2322 return 0;
2323 }
2324
2325 /*******************************************************************
2326 * DdQueryDisplaySettingsUniqueness (GDI32.@)
2327 * GdiEntry13
2328 */
2329 ULONG WINAPI DdQueryDisplaySettingsUniqueness(void)
2330 {
2331 static int warn_once;
2332 if (!warn_once++) FIXME( "stub\n" );
2333 return 0;
2334 }
Windows API implementation