dlls/gdi32/gdidc.c

   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  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  21  */
  22
  23 #include "gdi_private.h"
  24 #include "winternl.h"
  25
  26 #include "wine/debug.h"
  27
  28 WINE_DEFAULT_DEBUG_CHANNEL(gdi);
  29
  30 static DC_ATTR *get_dc_attr( HDC hdc )
  31 {
  32     WORD type = gdi_handle_type( hdc );
  33     DC_ATTR *dc_attr;
  34     if ((type & 0x1f) != NTGDI_OBJ_DC || !(dc_attr = get_gdi_client_ptr( hdc, 0 )))
  35     {
  36         SetLastError( ERROR_INVALID_HANDLE );
  37         return NULL;
  38     }
  39     return dc_attr->disabled ? NULL : dc_attr;
  40 }
  41
  42 /***********************************************************************
  43  *           CreateDCA  (GDI32.@)
  44  */
  45 HDC WINAPI CreateDCA( const char *driver, const char *device, const char *output,
  46                       const DEVMODEA *init_data )
  47 {
  48     UNICODE_STRING driverW, deviceW, outputW;
  49     DEVMODEW *init_dataW = NULL;
  50     HDC ret;
  51
  52     if (driver) RtlCreateUnicodeStringFromAsciiz( &driverW, driver );
  53     else driverW.Buffer = NULL;
  54
  55     if (device) RtlCreateUnicodeStringFromAsciiz( &deviceW, device );
  56     else deviceW.Buffer = NULL;
  57
  58     if (output) RtlCreateUnicodeStringFromAsciiz( &outputW, output );
  59     else outputW.Buffer = NULL;
  60
  61     if (init_data)
  62     {
  63         /* don't convert init_data for DISPLAY driver, it's not used */
  64         if (!driverW.Buffer || wcsicmp( driverW.Buffer, L"display" ))
  65             init_dataW = GdiConvertToDevmodeW( init_data );
  66     }
  67
  68     ret = CreateDCW( driverW.Buffer, deviceW.Buffer, outputW.Buffer, init_dataW );
  69
  70     RtlFreeUnicodeString( &driverW );
  71     RtlFreeUnicodeString( &deviceW );
  72     RtlFreeUnicodeString( &outputW );
  73     HeapFree( GetProcessHeap(), 0, init_dataW );
  74     return ret;
  75 }
  76
  77 /***********************************************************************
  78  *           CreateICA    (GDI32.@)
  79  */
  80 HDC WINAPI CreateICA( const char *driver, const char *device, const char *output,
  81                       const DEVMODEA *init_data )
  82 {
  83     /* Nothing special yet for ICs */
  84     return CreateDCA( driver, device, output, init_data );
  85 }
  86
  87
  88 /***********************************************************************
  89  *           CreateICW    (GDI32.@)
  90  */
  91 HDC WINAPI CreateICW( const WCHAR *driver, const WCHAR *device, const WCHAR *output,
  92                       const DEVMODEW *init_data )
  93 {
  94     /* Nothing special yet for ICs */
  95     return CreateDCW( driver, device, output, init_data );
  96 }
  97
  98 /***********************************************************************
  99  *           ResetDCA    (GDI32.@)
 100  */
 101 HDC WINAPI ResetDCA( HDC hdc, const DEVMODEA *devmode )
 102 {
 103     DEVMODEW *devmodeW;
 104     HDC ret;
 105
 106     if (devmode) devmodeW = GdiConvertToDevmodeW( devmode );
 107     else devmodeW = NULL;
 108
 109     ret = ResetDCW( hdc, devmodeW );
 110
 111     HeapFree( GetProcessHeap(), 0, devmodeW );
 112     return ret;
 113 }
 114
 115 /***********************************************************************
 116  *           SaveDC    (GDI32.@)
 117  */
 118 INT WINAPI SaveDC( HDC hdc )
 119 {
 120     DC_ATTR *dc_attr;
 121
 122     if (is_meta_dc( hdc )) return METADC_SaveDC( hdc );
 123     if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
 124     if (dc_attr->emf && !EMFDC_SaveDC( dc_attr )) return FALSE;
 125     return NtGdiSaveDC( hdc );
 126 }
 127
 128 /***********************************************************************
 129  *           GetDeviceCaps    (GDI32.@)
 130  */
 131 INT WINAPI GetDeviceCaps( HDC hdc, INT cap )
 132 {
 133     if (is_meta_dc( hdc )) return METADC_GetDeviceCaps( hdc, cap );
 134     if (!get_dc_attr( hdc )) return FALSE;
 135     return NtGdiGetDeviceCaps( hdc, cap );
 136 }
 137
 138 /***********************************************************************
 139  *              GetTextAlign (GDI32.@)
 140  */
 141 UINT WINAPI GetTextAlign( HDC hdc )
 142 {
 143     DC_ATTR *dc_attr = get_dc_attr( hdc );
 144     return dc_attr ? dc_attr->text_align : 0;
 145 }
 146
 147 /***********************************************************************
 148  *           SetTextAlign    (GDI32.@)
 149  */
 150 UINT WINAPI SetTextAlign( HDC hdc, UINT align )
 151 {
 152     DC_ATTR *dc_attr;
 153     UINT ret;
 154
 155     TRACE("hdc=%p align=%d\n", hdc, align);
 156
 157     if (is_meta_dc( hdc )) return METADC_SetTextAlign( hdc, align );
 158     if (!(dc_attr = get_dc_attr( hdc ))) return GDI_ERROR;
 159     if (dc_attr->emf && !EMFDC_SetTextAlign( dc_attr, align )) return GDI_ERROR;
 160
 161     ret = dc_attr->text_align;
 162     dc_attr->text_align = align;
 163     return ret;
 164 }
 165
 166 /***********************************************************************
 167  *              GetBkColor (GDI32.@)
 168  */
 169 COLORREF WINAPI GetBkColor( HDC hdc )
 170 {
 171     DC_ATTR *dc_attr = get_dc_attr( hdc );
 172     return dc_attr ? dc_attr->background_color : CLR_INVALID;
 173 }
 174
 175 /***********************************************************************
 176  *           GetDCBrushColor  (GDI32.@)
 177  */
 178 COLORREF WINAPI GetDCBrushColor( HDC hdc )
 179 {
 180     DC_ATTR *dc_attr = get_dc_attr( hdc );
 181     return dc_attr ? dc_attr->brush_color : CLR_INVALID;
 182 }
 183
 184 /***********************************************************************
 185  *           GetDCPenColor    (GDI32.@)
 186  */
 187 COLORREF WINAPI GetDCPenColor(HDC hdc)
 188 {
 189     DC_ATTR *dc_attr = get_dc_attr( hdc );
 190     return dc_attr ? dc_attr->pen_color : CLR_INVALID;
 191 }
 192
 193 /***********************************************************************
 194  *              GetTextColor (GDI32.@)
 195  */
 196 COLORREF WINAPI GetTextColor( HDC hdc )
 197 {
 198     DC_ATTR *dc_attr = get_dc_attr( hdc );
 199     return dc_attr ? dc_attr->text_color : 0;
 200 }
 201
 202 /***********************************************************************
 203  *              GetBkMode (GDI32.@)
 204  */
 205 INT WINAPI GetBkMode( HDC hdc )
 206 {
 207     DC_ATTR *dc_attr = get_dc_attr( hdc );
 208     return dc_attr ? dc_attr->background_mode : 0;
 209 }
 210
 211 /***********************************************************************
 212  *              SetBkMode (GDI32.@)
 213  */
 214 INT WINAPI SetBkMode( HDC hdc, INT mode )
 215 {
 216     DC_ATTR *dc_attr;
 217     INT ret;
 218
 219     if (mode <= 0 || mode > BKMODE_LAST)
 220     {
 221         SetLastError(ERROR_INVALID_PARAMETER);
 222         return 0;
 223     }
 224
 225     if (is_meta_dc( hdc )) return METADC_SetBkMode( hdc, mode );
 226     if (!(dc_attr = get_dc_attr( hdc ))) return 0;
 227     if (dc_attr->emf && !EMFDC_SetBkMode( dc_attr, mode )) return 0;
 228
 229     ret = dc_attr->background_mode;
 230     dc_attr->background_mode = mode;
 231     return ret;
 232 }
 233
 234 /***********************************************************************
 235  *              GetGraphicsMode (GDI32.@)
 236  */
 237 INT WINAPI GetGraphicsMode( HDC hdc )
 238 {
 239     DC_ATTR *dc_attr = get_dc_attr( hdc );
 240     return dc_attr ? dc_attr->graphics_mode : 0;
 241 }
 242
 243 /***********************************************************************
 244  *              GetArcDirection (GDI32.@)
 245  */
 246 INT WINAPI GetArcDirection( HDC hdc )
 247 {
 248     DC_ATTR *dc_attr = get_dc_attr( hdc );
 249     return dc_attr ? dc_attr->arc_direction : 0;
 250 }
 251
 252 /***********************************************************************
 253  *           SetArcDirection    (GDI32.@)
 254  */
 255 INT WINAPI SetArcDirection( HDC hdc, INT dir )
 256 {
 257     DC_ATTR *dc_attr;
 258     INT ret;
 259
 260     if (dir != AD_COUNTERCLOCKWISE && dir != AD_CLOCKWISE)
 261     {
 262         SetLastError(ERROR_INVALID_PARAMETER);
 263         return 0;
 264     }
 265
 266     if (!(dc_attr = get_dc_attr( hdc ))) return 0;
 267     if (dc_attr->emf && !EMFDC_SetArcDirection( dc_attr, dir )) return 0;
 268
 269     ret = dc_attr->arc_direction;
 270     dc_attr->arc_direction = dir;
 271     return ret;
 272 }
 273
 274 /***********************************************************************
 275  *           GetLayout    (GDI32.@)
 276  */
 277 DWORD WINAPI GetLayout( HDC hdc )
 278 {
 279     DC_ATTR *dc_attr = get_dc_attr( hdc );
 280     return dc_attr ? dc_attr->layout : GDI_ERROR;
 281 }
 282
 283 /***********************************************************************
 284  *           GetMapMode  (GDI32.@)
 285  */
 286 INT WINAPI GetMapMode( HDC hdc )
 287 {
 288     DC_ATTR *dc_attr = get_dc_attr( hdc );
 289     return dc_attr ? dc_attr->map_mode : 0;
 290 }
 291
 292 /***********************************************************************
 293  *              GetPolyFillMode  (GDI32.@)
 294  */
 295 INT WINAPI GetPolyFillMode( HDC hdc )
 296 {
 297     DC_ATTR *dc_attr = get_dc_attr( hdc );
 298     return dc_attr ? dc_attr->poly_fill_mode : 0;
 299 }
 300
 301 /***********************************************************************
 302  *              SetPolyFillMode (GDI32.@)
 303  */
 304 INT WINAPI SetPolyFillMode( HDC hdc, INT mode )
 305 {
 306     DC_ATTR *dc_attr;
 307     INT ret;
 308
 309     if (mode <= 0 || mode > POLYFILL_LAST)
 310     {
 311         SetLastError(ERROR_INVALID_PARAMETER);
 312         return 0;
 313     }
 314
 315     if (is_meta_dc( hdc )) return METADC_SetPolyFillMode( hdc, mode );
 316     if (!(dc_attr = get_dc_attr( hdc ))) return 0;
 317     if (dc_attr->emf && !EMFDC_SetPolyFillMode( dc_attr, mode )) return 0;
 318
 319     ret = dc_attr->poly_fill_mode;
 320     dc_attr->poly_fill_mode = mode;
 321     return ret;
 322 }
 323
 324 /***********************************************************************
 325  *              GetStretchBltMode (GDI32.@)
 326  */
 327 INT WINAPI GetStretchBltMode( HDC hdc )
 328 {
 329     DC_ATTR *dc_attr = get_dc_attr( hdc );
 330     return dc_attr ? dc_attr->stretch_blt_mode : 0;
 331 }
 332
 333 /***********************************************************************
 334  *              GetBrushOrgEx (GDI32.@)
 335  */
 336 BOOL WINAPI GetBrushOrgEx( HDC hdc, POINT *point )
 337 {
 338     DC_ATTR *dc_attr;
 339     if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
 340     *point = dc_attr->brush_org;
 341     return TRUE;
 342 }
 343
 344 /***********************************************************************
 345  *           SetBrushOrgEx    (GDI32.@)
 346  */
 347 BOOL WINAPI SetBrushOrgEx( HDC hdc, INT x, INT y, POINT *oldorg )
 348 {
 349     DC_ATTR *dc_attr;
 350     if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
 351     if (oldorg) *oldorg = dc_attr->brush_org;
 352     dc_attr->brush_org.x = x;
 353     dc_attr->brush_org.y = y;
 354     return TRUE;
 355 }
 356
 357 /***********************************************************************
 358  *           FixBrushOrgEx    (GDI32.@)
 359  */
 360 BOOL WINAPI FixBrushOrgEx( HDC hdc, INT x, INT y, POINT *oldorg )
 361 {
 362     return SetBrushOrgEx( hdc, x, y, oldorg );
 363 }
 364
 365 /***********************************************************************
 366  *           GetDCOrgEx  (GDI32.@)
 367  */
 368 BOOL WINAPI GetDCOrgEx( HDC hdc, POINT *point )
 369 {
 370     DC_ATTR *dc_attr;
 371     if (!point || !(dc_attr = get_dc_attr( hdc ))) return FALSE;
 372     point->x = dc_attr->vis_rect.left;
 373     point->y = dc_attr->vis_rect.top;
 374     return TRUE;
 375 }
 376
 377 /***********************************************************************
 378  *              GetWindowExtEx (GDI32.@)
 379  */
 380 BOOL WINAPI GetWindowExtEx( HDC hdc, SIZE *size )
 381 {
 382     DC_ATTR *dc_attr;
 383     if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
 384     *size = dc_attr->wnd_ext;
 385     return TRUE;
 386 }
 387
 388 /***********************************************************************
 389  *              GetWindowOrgEx (GDI32.@)
 390  */
 391 BOOL WINAPI GetWindowOrgEx( HDC hdc, POINT *point )
 392 {
 393     DC_ATTR *dc_attr;
 394     if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
 395     *point = dc_attr->wnd_org;
 396     return TRUE;
 397 }
 398
 399 /***********************************************************************
 400  *              GetViewportExtEx (GDI32.@)
 401  */
 402 BOOL WINAPI GetViewportExtEx( HDC hdc, SIZE *size )
 403 {
 404     DC_ATTR *dc_attr;
 405     if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
 406     *size = dc_attr->vport_ext;
 407     return TRUE;
 408 }
 409
 410 /***********************************************************************
 411  *              GetViewportOrgEx (GDI32.@)
 412  */
 413 BOOL WINAPI GetViewportOrgEx( HDC hdc, POINT *point )
 414 {
 415     DC_ATTR *dc_attr;
 416     if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
 417     *point = dc_attr->vport_org;
 418     return TRUE;
 419 }
 420
 421 /***********************************************************************
 422  *              SetStretchBltMode (GDI32.@)
 423  */
 424 INT WINAPI SetStretchBltMode( HDC hdc, INT mode )
 425 {
 426     DC_ATTR *dc_attr;
 427     INT ret;
 428
 429     if (mode <= 0 || mode > MAXSTRETCHBLTMODE)
 430     {
 431         SetLastError(ERROR_INVALID_PARAMETER);
 432         return 0;
 433     }
 434
 435     if (is_meta_dc( hdc )) return METADC_SetStretchBltMode( hdc, mode );
 436     if (!(dc_attr = get_dc_attr( hdc ))) return 0;
 437     if (dc_attr->emf && !EMFDC_SetStretchBltMode( dc_attr, mode )) return 0;
 438
 439     ret = dc_attr->stretch_blt_mode;
 440     dc_attr->stretch_blt_mode = mode;
 441     return ret;
 442 }
 443
 444 /***********************************************************************
 445  *              GetCurrentPositionEx (GDI32.@)
 446  */
 447 BOOL WINAPI GetCurrentPositionEx( HDC hdc, POINT *point )
 448 {
 449     DC_ATTR *dc_attr;
 450     if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
 451     *point = dc_attr->cur_pos;
 452     return TRUE;
 453 }
 454
 455 /***********************************************************************
 456  *              GetROP2 (GDI32.@)
 457  */
 458 INT WINAPI GetROP2( HDC hdc )
 459 {
 460     DC_ATTR *dc_attr = get_dc_attr( hdc );
 461     return dc_attr ? dc_attr->rop_mode : 0;
 462 }
 463
 464 /***********************************************************************
 465  *              GetRelAbs  (GDI32.@)
 466  */
 467 INT WINAPI GetRelAbs( HDC hdc, DWORD ignore )
 468 {
 469     DC_ATTR *dc_attr = get_dc_attr( hdc );
 470     return dc_attr ? dc_attr->rel_abs_mode : 0;
 471 }
 472
 473 /***********************************************************************
 474  *              SetRelAbs (GDI32.@)
 475  */
 476 INT WINAPI SetRelAbs( HDC hdc, INT mode )
 477 {
 478     DC_ATTR *dc_attr;
 479     INT ret;
 480
 481     if (mode != ABSOLUTE && mode != RELATIVE)
 482     {
 483         SetLastError(ERROR_INVALID_PARAMETER);
 484         return 0;
 485     }
 486
 487     if (is_meta_dc( hdc )) return METADC_SetRelAbs( hdc, mode );
 488     if (!(dc_attr = get_dc_attr( hdc ))) return 0;
 489     ret = dc_attr->rel_abs_mode;
 490     dc_attr->rel_abs_mode = mode;
 491     return ret;
 492 }
 493
 494 /***********************************************************************
 495  *              SetROP2 (GDI32.@)
 496  */
 497 INT WINAPI SetROP2( HDC hdc, INT mode )
 498 {
 499     DC_ATTR *dc_attr;
 500     INT ret;
 501
 502     if ((mode < R2_BLACK) || (mode > R2_WHITE))
 503     {
 504         SetLastError(ERROR_INVALID_PARAMETER);
 505         return 0;
 506     }
 507
 508     if (is_meta_dc( hdc )) return METADC_SetROP2( hdc, mode );
 509     if (!(dc_attr = get_dc_attr( hdc ))) return 0;
 510     if (dc_attr->emf && !EMFDC_SetROP2( dc_attr, mode )) return 0;
 511
 512     ret = dc_attr->rop_mode;
 513     dc_attr->rop_mode = mode;
 514     return ret;
 515 }
 516
 517 /***********************************************************************
 518  *           GetMiterLimit  (GDI32.@)
 519  */
 520 BOOL WINAPI GetMiterLimit( HDC hdc, FLOAT *limit )
 521 {
 522     DC_ATTR *dc_attr;
 523     if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
 524     if (limit) *limit = dc_attr->miter_limit;
 525     return TRUE;
 526 }
 527
 528 /*******************************************************************
 529  *           SetMiterLimit  (GDI32.@)
 530  */
 531 BOOL WINAPI SetMiterLimit( HDC hdc, FLOAT limit, FLOAT *old_limit )
 532 {
 533     DC_ATTR *dc_attr;
 534     if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
 535     /* FIXME: record EMFs */
 536     if (old_limit) *old_limit = dc_attr->miter_limit;
 537     dc_attr->miter_limit = limit;
 538     return TRUE;
 539 }
 540
 541 /***********************************************************************
 542  *           SetPixel    (GDI32.@)
 543  */
 544 COLORREF WINAPI SetPixel( HDC hdc, INT x, INT y, COLORREF color )
 545 {
 546     DC_ATTR *dc_attr;
 547
 548     if (is_meta_dc( hdc )) return METADC_SetPixel( hdc, x, y, color );
 549     if (!(dc_attr = get_dc_attr( hdc ))) return CLR_INVALID;
 550     if (dc_attr->emf && !EMFDC_SetPixel( dc_attr, x, y, color )) return CLR_INVALID;
 551     return NtGdiSetPixel( hdc, x, y, color );
 552 }
 553
 554 /***********************************************************************
 555  *           SetPixelV    (GDI32.@)
 556  */
 557 BOOL WINAPI SetPixelV( HDC hdc, INT x, INT y, COLORREF color )
 558 {
 559     return SetPixel( hdc, x, y, color ) != CLR_INVALID;
 560 }
 561
 562 /***********************************************************************
 563  *           LineTo    (GDI32.@)
 564  */
 565 BOOL WINAPI LineTo( HDC hdc, INT x, INT y )
 566 {
 567     DC_ATTR *dc_attr;
 568
 569     TRACE( "%p, (%d, %d)\n", hdc, x, y );
 570
 571     if (is_meta_dc( hdc )) return METADC_LineTo( hdc, x, y );
 572     if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
 573     if (dc_attr->emf && !EMFDC_LineTo( dc_attr, x, y )) return FALSE;
 574     return NtGdiLineTo( hdc, x, y );
 575 }
 576
 577 /***********************************************************************
 578  *           MoveToEx    (GDI32.@)
 579  */
 580 BOOL WINAPI MoveToEx( HDC hdc, INT x, INT y, POINT *pt )
 581 {
 582     DC_ATTR *dc_attr;
 583
 584     TRACE( "%p, (%d, %d), %p\n", hdc, x, y, pt );
 585
 586     if (is_meta_dc( hdc )) return METADC_MoveTo( hdc, x, y );
 587     if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
 588     if (dc_attr->emf && !EMFDC_MoveTo( dc_attr, x, y )) return FALSE;
 589     return NtGdiMoveTo( hdc, x, y, pt );
 590 }
 591
 592 /***********************************************************************
 593  *           Arc    (GDI32.@)
 594  */
 595 BOOL WINAPI Arc( HDC hdc, INT left, INT top, INT right, INT bottom,
 596                  INT xstart, INT ystart, INT xend, INT yend )
 597 {
 598     DC_ATTR *dc_attr;
 599
 600     TRACE( "%p, (%d, %d)-(%d, %d), (%d, %d), (%d, %d)\n", hdc, left, top,
 601            right, bottom, xstart, ystart, xend, yend );
 602
 603     if (is_meta_dc( hdc ))
 604         return METADC_Arc( hdc, left, top, right, bottom,
 605                            xstart, ystart, xend, yend );
 606
 607     if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
 608     if (dc_attr->emf && !EMFDC_ArcChordPie( dc_attr, left, top, right, bottom,
 609                                             xstart, ystart, xend, yend, EMR_ARC ))
 610         return FALSE;
 611
 612     return NtGdiArcInternal( NtGdiArc, hdc, left, top, right, bottom,
 613                              xstart, ystart, xend, yend );
 614 }
 615
 616 /***********************************************************************
 617  *           ArcTo    (GDI32.@)
 618  */
 619 BOOL WINAPI ArcTo( HDC hdc, INT left, INT top, INT right, INT bottom,
 620                    INT xstart, INT ystart, INT xend, INT yend )
 621 {
 622     DC_ATTR *dc_attr;
 623
 624     TRACE( "%p, (%d, %d)-(%d, %d), (%d, %d), (%d, %d)\n", hdc, left, top,
 625            right, bottom, xstart, ystart, xend, yend );
 626
 627     if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
 628     if (dc_attr->emf && !EMFDC_ArcChordPie( dc_attr, left, top, right, bottom,
 629                                             xstart, ystart, xend, yend, EMR_ARCTO ))
 630         return FALSE;
 631
 632     return NtGdiArcInternal( NtGdiArcTo, hdc, left, top, right, bottom,
 633                              xstart, ystart, xend, yend );
 634 }
 635
 636 /***********************************************************************
 637  *           Chord    (GDI32.@)
 638  */
 639 BOOL WINAPI Chord( HDC hdc, INT left, INT top, INT right, INT bottom,
 640                    INT xstart, INT ystart, INT xend, INT yend )
 641 {
 642     DC_ATTR *dc_attr;
 643
 644     TRACE( "%p, (%d, %d)-(%d, %d), (%d, %d), (%d, %d)\n", hdc, left, top,
 645            right, bottom, xstart, ystart, xend, yend );
 646
 647     if (is_meta_dc( hdc ))
 648         return METADC_Chord( hdc, left, top, right, bottom,
 649                              xstart, ystart, xend, yend );
 650
 651     if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
 652     if (dc_attr->emf && !EMFDC_ArcChordPie( dc_attr, left, top, right, bottom,
 653                                             xstart, ystart, xend, yend, EMR_CHORD ))
 654         return FALSE;
 655
 656     return NtGdiArcInternal( NtGdiChord, hdc, left, top, right, bottom,
 657                              xstart, ystart, xend, yend );
 658 }
 659
 660 /***********************************************************************
 661  *           Pie   (GDI32.@)
 662  */
 663 BOOL WINAPI Pie( HDC hdc, INT left, INT top, INT right, INT bottom,
 664                  INT xstart, INT ystart, INT xend, INT yend )
 665 {
 666     DC_ATTR *dc_attr;
 667
 668     TRACE( "%p, (%d, %d)-(%d, %d), (%d, %d), (%d, %d)\n", hdc, left, top,
 669            right, bottom, xstart, ystart, xend, yend );
 670
 671     if (is_meta_dc( hdc ))
 672         return METADC_Pie( hdc, left, top, right, bottom,
 673                            xstart, ystart, xend, yend );
 674
 675     if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
 676     if (dc_attr->emf && !EMFDC_ArcChordPie( dc_attr, left, top, right, bottom,
 677                                             xstart, ystart, xend, yend, EMR_PIE ))
 678         return FALSE;
 679
 680     return NtGdiArcInternal( NtGdiPie, hdc, left, top, right, bottom,
 681                              xstart, ystart, xend, yend );
 682 }
 683
 684 /***********************************************************************
 685  *      AngleArc (GDI32.@)
 686  */
 687 BOOL WINAPI AngleArc( HDC hdc, INT x, INT y, DWORD radius, FLOAT start_angle, FLOAT sweep_angle )
 688 {
 689     DC_ATTR *dc_attr;
 690
 691     TRACE( "%p, (%d, %d), %u, %f, %f\n", hdc, x, y, radius, start_angle, sweep_angle );
 692
 693     if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
 694     if (dc_attr->emf && !EMFDC_AngleArc( dc_attr, x, y, radius, start_angle, sweep_angle ))
 695         return FALSE;
 696     return NtGdiAngleArc( hdc, x, y, radius, start_angle, sweep_angle );
 697 }
 698
 699 /***********************************************************************
 700  *           Ellipse    (GDI32.@)
 701  */
 702 BOOL WINAPI Ellipse( HDC hdc, INT left, INT top, INT right, INT bottom )
 703 {
 704     DC_ATTR *dc_attr;
 705
 706     TRACE( "%p, (%d, %d)-(%d, %d)\n", hdc, left, top, right, bottom );
 707
 708     if (is_meta_dc( hdc )) return METADC_Ellipse( hdc, left, top, right, bottom );
 709     if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
 710     if (dc_attr->emf && !EMFDC_Ellipse( dc_attr, left, top, right, bottom )) return FALSE;
 711     return NtGdiEllipse( hdc, left, top, right, bottom );
 712 }
 713
 714 /***********************************************************************
 715  *           Rectangle    (GDI32.@)
 716  */
 717 BOOL WINAPI Rectangle( HDC hdc, INT left, INT top, INT right, INT bottom )
 718 {
 719     DC_ATTR *dc_attr;
 720
 721     TRACE( "%p, (%d, %d)-(%d, %d)\n", hdc, left, top, right, bottom );
 722
 723     if (is_meta_dc( hdc )) return METADC_Rectangle( hdc, left, top, right, bottom );
 724     if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
 725     if (dc_attr->emf && !EMFDC_Rectangle( dc_attr, left, top, right, bottom )) return FALSE;
 726     return NtGdiRectangle( hdc, left, top, right, bottom );
 727 }
 728
 729 /***********************************************************************
 730  *           RoundRect    (GDI32.@)
 731  */
 732 BOOL WINAPI RoundRect( HDC hdc, INT left, INT top, INT right,
 733                        INT bottom, INT ell_width, INT ell_height )
 734 {
 735     DC_ATTR *dc_attr;
 736
 737     TRACE( "%p, (%d, %d)-(%d, %d), %dx%d\n", hdc, left, top, right, bottom,
 738            ell_width, ell_height );
 739
 740     if (is_meta_dc( hdc ))
 741         return METADC_RoundRect( hdc, left, top, right, bottom, ell_width, ell_height );
 742
 743     if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
 744     if (dc_attr->emf && !EMFDC_RoundRect( dc_attr, left, top, right, bottom,
 745                                           ell_width, ell_height ))
 746         return FALSE;
 747
 748     return NtGdiRoundRect( hdc, left, top, right, bottom, ell_width, ell_height );
 749 }
 750
 751 /**********************************************************************
 752  *          Polygon  (GDI32.@)
 753  */
 754 BOOL WINAPI Polygon( HDC hdc, const POINT *points, INT count )
 755 {
 756     DC_ATTR *dc_attr;
 757
 758     TRACE( "%p, %p, %d\n", hdc, points, count );
 759
 760     if (is_meta_dc( hdc )) return METADC_Polygon( hdc, points, count );
 761     if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
 762     if (dc_attr->emf && !EMFDC_Polygon( dc_attr, points, count )) return FALSE;
 763     return NtGdiPolyPolyDraw( hdc, points, (const UINT *)&count, 1, NtGdiPolyPolygon );
 764 }
 765
 766 /**********************************************************************
 767  *          PolyPolygon  (GDI32.@)
 768  */
 769 BOOL WINAPI PolyPolygon( HDC hdc, const POINT *points, const INT *counts, UINT polygons )
 770 {
 771     DC_ATTR *dc_attr;
 772
 773     TRACE( "%p, %p, %p, %u\n", hdc, points, counts, polygons );
 774
 775     if (is_meta_dc( hdc )) return METADC_PolyPolygon( hdc, points, counts, polygons );
 776     if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
 777     if (dc_attr->emf && !EMFDC_PolyPolygon( dc_attr, points, counts, polygons )) return FALSE;
 778     return NtGdiPolyPolyDraw( hdc, points, (const UINT *)counts, polygons, NtGdiPolyPolygon );
 779 }
 780
 781 /**********************************************************************
 782  *          Polyline   (GDI32.@)
 783  */
 784 BOOL WINAPI Polyline( HDC hdc, const POINT *points, INT count )
 785 {
 786     DC_ATTR *dc_attr;
 787
 788     TRACE( "%p, %p, %d\n", hdc, points, count );
 789
 790     if (is_meta_dc( hdc )) return METADC_Polyline( hdc, points, count );
 791     if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
 792     if (dc_attr->emf && !EMFDC_Polyline( dc_attr, points, count )) return FALSE;
 793     return NtGdiPolyPolyDraw( hdc, points, (const UINT *)&count, 1, NtGdiPolyPolyline );
 794 }
 795
 796 /**********************************************************************
 797  *          PolyPolyline  (GDI32.@)
 798  */
 799 BOOL WINAPI PolyPolyline( HDC hdc, const POINT *points, const DWORD *counts, DWORD polylines )
 800 {
 801     DC_ATTR *dc_attr;
 802
 803     TRACE( "%p, %p, %p, %u\n", hdc, points, counts, polylines );
 804
 805     if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
 806     if (dc_attr->emf && !EMFDC_PolyPolyline( dc_attr, points, counts, polylines )) return FALSE;
 807     return NtGdiPolyPolyDraw( hdc, points, counts, polylines, NtGdiPolyPolyline );
 808 }
 809
 810 /******************************************************************************
 811  *          PolyBezier  (GDI32.@)
 812  */
 813 BOOL WINAPI PolyBezier( HDC hdc, const POINT *points, DWORD count )
 814 {
 815     DC_ATTR *dc_attr;
 816
 817     TRACE( "%p, %p, %u\n", hdc, points, count );
 818
 819     if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
 820     if (dc_attr->emf && !EMFDC_PolyBezier( dc_attr, points, count )) return FALSE;
 821     return NtGdiPolyPolyDraw( hdc, points, &count, 1, NtGdiPolyBezier );
 822 }
 823
 824 /******************************************************************************
 825  *          PolyBezierTo  (GDI32.@)
 826  */
 827 BOOL WINAPI PolyBezierTo( HDC hdc, const POINT *points, DWORD count )
 828 {
 829     DC_ATTR *dc_attr;
 830
 831     TRACE( "%p, %p, %u\n", hdc, points, count );
 832
 833     if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
 834     if (dc_attr->emf && !EMFDC_PolyBezierTo( dc_attr, points, count )) return FALSE;
 835     return NtGdiPolyPolyDraw( hdc, points, &count, 1, NtGdiPolyBezierTo );
 836 }
 837
 838 /**********************************************************************
 839  *          PolylineTo   (GDI32.@)
 840  */
 841 BOOL WINAPI PolylineTo( HDC hdc, const POINT *points, DWORD count )
 842 {
 843     DC_ATTR *dc_attr;
 844
 845     TRACE( "%p, %p, %u\n", hdc, points, count );
 846
 847     if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
 848     if (dc_attr->emf && !EMFDC_PolylineTo( dc_attr, points, count )) return FALSE;
 849     return NtGdiPolyPolyDraw( hdc, points, &count, 1, NtGdiPolylineTo );
 850 }
 851
 852 /***********************************************************************
 853  *      PolyDraw (GDI32.@)
 854  */
 855 BOOL WINAPI PolyDraw( HDC hdc, const POINT *points, const BYTE *types, DWORD count )
 856 {
 857     DC_ATTR *dc_attr;
 858
 859     TRACE( "%p, %p, %p, %u\n", hdc, points, types, count );
 860
 861     if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
 862     if (dc_attr->emf && !EMFDC_PolyDraw( dc_attr, points, types, count )) return FALSE;
 863     return NtGdiPolyDraw( hdc, points, types, count );
 864 }
 865
 866 /***********************************************************************
 867  *           FillRgn    (GDI32.@)
 868  */
 869 BOOL WINAPI FillRgn( HDC hdc, HRGN hrgn, HBRUSH hbrush )
 870 {
 871     DC_ATTR *dc_attr;
 872
 873     TRACE( "%p, %p, %p\n", hdc, hrgn, hbrush );
 874
 875     if (is_meta_dc( hdc )) return METADC_FillRgn( hdc, hrgn, hbrush );
 876     if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
 877     if (dc_attr->emf && !EMFDC_FillRgn( dc_attr, hrgn, hbrush )) return FALSE;
 878     return NtGdiFillRgn( hdc, hrgn, hbrush );
 879 }
 880
 881 /***********************************************************************
 882  *           PaintRgn    (GDI32.@)
 883  */
 884 BOOL WINAPI PaintRgn( HDC hdc, HRGN hrgn )
 885 {
 886     DC_ATTR *dc_attr;
 887
 888     TRACE( "%p, %p\n", hdc, hrgn );
 889
 890     if (is_meta_dc( hdc )) return METADC_PaintRgn( hdc, hrgn );
 891     if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
 892     if (dc_attr->emf && !EMFDC_PaintRgn( dc_attr, hrgn )) return FALSE;
 893     return NtGdiFillRgn( hdc, hrgn, GetCurrentObject( hdc, OBJ_BRUSH ));
 894 }
 895
 896 /***********************************************************************
 897  *           FrameRgn     (GDI32.@)
 898  */
 899 BOOL WINAPI FrameRgn( HDC hdc, HRGN hrgn, HBRUSH hbrush, INT width, INT height )
 900 {
 901     DC_ATTR *dc_attr;
 902
 903     TRACE( "%p, %p, %p, %dx%d\n", hdc, hrgn, hbrush, width, height );
 904
 905     if (is_meta_dc( hdc )) return METADC_FrameRgn( hdc, hrgn, hbrush, width, height );
 906     if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
 907     if (dc_attr->emf && !EMFDC_FrameRgn( dc_attr, hrgn, hbrush, width, height ))
 908         return FALSE;
 909     return NtGdiFrameRgn( hdc, hrgn, hbrush, width, height );
 910 }
 911
 912 /***********************************************************************
 913  *           InvertRgn    (GDI32.@)
 914  */
 915 BOOL WINAPI InvertRgn( HDC hdc, HRGN hrgn )
 916 {
 917     DC_ATTR *dc_attr;
 918
 919     TRACE( "%p, %p\n", hdc, hrgn );
 920
 921     if (is_meta_dc( hdc )) return METADC_InvertRgn( hdc, hrgn );
 922     if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
 923     if (dc_attr->emf && !EMFDC_InvertRgn( dc_attr, hrgn )) return FALSE;
 924     return NtGdiInvertRgn( hdc, hrgn );
 925 }
 926
 927 /***********************************************************************
 928  *          ExtFloodFill   (GDI32.@)
 929  */
 930 BOOL WINAPI ExtFloodFill( HDC hdc, INT x, INT y, COLORREF color, UINT fill_type )
 931 {
 932     DC_ATTR *dc_attr;
 933
 934     TRACE( "%p, (%d, %d), %08x, %x\n", hdc, x, y, color, fill_type );
 935
 936     if (is_meta_dc( hdc )) return METADC_ExtFloodFill( hdc, x, y, color, fill_type );
 937     if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
 938     if (dc_attr->emf && !EMFDC_ExtFloodFill( dc_attr, x, y, color, fill_type )) return FALSE;
 939     return NtGdiExtFloodFill( hdc, x, y, color, fill_type );
 940 }
 941
 942 /***********************************************************************
 943  *          FloodFill   (GDI32.@)
 944  */
 945 BOOL WINAPI FloodFill( HDC hdc, INT x, INT y, COLORREF color )
 946 {
 947     return ExtFloodFill( hdc, x, y, color, FLOODFILLBORDER );
 948 }
 949
 950 /******************************************************************************
 951  *           GdiGradientFill   (GDI32.@)
 952  */
 953 BOOL WINAPI GdiGradientFill( HDC hdc, TRIVERTEX *vert_array, ULONG nvert,
 954                              void *grad_array, ULONG ngrad, ULONG mode )
 955 {
 956     DC_ATTR *dc_attr;
 957
 958     TRACE( "%p vert_array:%p nvert:%d grad_array:%p ngrad:%d\n", hdc, vert_array,
 959            nvert, grad_array, ngrad );
 960
 961     if (!(dc_attr = get_dc_attr( hdc )))
 962     {
 963         SetLastError( ERROR_INVALID_PARAMETER );
 964         return FALSE;
 965     }
 966     if (dc_attr->emf &&
 967         !EMFDC_GradientFill( dc_attr, vert_array, nvert, grad_array, ngrad, mode ))
 968         return FALSE;
 969     return NtGdiGradientFill( hdc, vert_array, nvert, grad_array, ngrad, mode );
 970 }
 971
 972 /***********************************************************************
 973  *           ExtTextOutW    (GDI32.@)
 974  */
 975 BOOL WINAPI ExtTextOutW( HDC hdc, INT x, INT y, UINT flags, const RECT *rect,
 976                          const WCHAR *str, UINT count, const INT *dx )
 977 {
 978     DC_ATTR *dc_attr;
 979
 980     if (is_meta_dc( hdc )) return METADC_ExtTextOut( hdc, x, y, flags, rect, str, count, dx );
 981     if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
 982     if (dc_attr->emf && !EMFDC_ExtTextOut( dc_attr, x, y, flags, rect, str, count, dx ))
 983         return FALSE;
 984     return NtGdiExtTextOutW( hdc, x, y, flags, rect, str, count, dx, 0 );
 985 }
 986
 987 /***********************************************************************
 988  *           PatBlt    (GDI32.@)
 989  */
 990 BOOL WINAPI PatBlt( HDC hdc, INT left, INT top, INT width, INT height, DWORD rop )
 991 {
 992     DC_ATTR *dc_attr;
 993
 994     if (is_meta_dc( hdc )) return METADC_PatBlt( hdc, left, top, width, height, rop );
 995     if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
 996     if (dc_attr->emf && !EMFDC_PatBlt( dc_attr, left, top, width, height, rop ))
 997         return FALSE;
 998     return NtGdiPatBlt( hdc, left, top, width, height, rop );
 999 }
1000
1001 /***********************************************************************
1002  *           BeginPath    (GDI32.@)
1003  */
1004 BOOL WINAPI BeginPath(HDC hdc)
1005 {
1006     DC_ATTR *dc_attr;
1007
1008     if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
1009     if (dc_attr->emf && !EMFDC_BeginPath( dc_attr )) return FALSE;
1010     return NtGdiBeginPath( hdc );
1011 }
1012
1013 /***********************************************************************
1014  *           EndPath    (GDI32.@)
1015  */
1016 BOOL WINAPI EndPath(HDC hdc)
1017 {
1018     DC_ATTR *dc_attr;
1019
1020     if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
1021     if (dc_attr->emf && !EMFDC_EndPath( dc_attr )) return FALSE;
1022     return NtGdiEndPath( hdc );
1023 }
1024
1025 /***********************************************************************
1026  *           AbortPath  (GDI32.@)
1027  */
1028 BOOL WINAPI AbortPath( HDC hdc )
1029 {
1030     DC_ATTR *dc_attr;
1031
1032     if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
1033     if (dc_attr->emf && !EMFDC_AbortPath( dc_attr )) return FALSE;
1034     return NtGdiAbortPath( hdc );
1035 }
1036
1037 /***********************************************************************
1038  *           CloseFigure    (GDI32.@)
1039  */
1040 BOOL WINAPI CloseFigure( HDC hdc )
1041 {
1042     DC_ATTR *dc_attr;
1043
1044     if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
1045     if (dc_attr->emf && !EMFDC_CloseFigure( dc_attr )) return FALSE;
1046     return NtGdiCloseFigure( hdc );
1047 }
1048
1049 /***********************************************************************
1050  *           IntersectClipRect    (GDI32.@)
1051  */
1052 INT WINAPI IntersectClipRect( HDC hdc, INT left, INT top, INT right, INT bottom )
1053 {
1054     DC_ATTR *dc_attr;
1055
1056     TRACE("%p %d,%d - %d,%d\n", hdc, left, top, right, bottom );
1057
1058     if (is_meta_dc( hdc )) return METADC_IntersectClipRect( hdc, left, top, right, bottom );
1059     if (!(dc_attr = get_dc_attr( hdc ))) return FALSE;
1060     if (dc_attr->emf && !EMFDC_IntersectClipRect( dc_attr, left, top, right, bottom ))
1061         return FALSE;
1062     return NtGdiIntersectClipRect( hdc, left, top, right, bottom );
1063 }
1064
1065 /***********************************************************************
1066  *           GdiSetPixelFormat   (GDI32.@)
1067  */
1068 BOOL WINAPI GdiSetPixelFormat( HDC hdc, INT format, const PIXELFORMATDESCRIPTOR *descr )
1069 {
1070     TRACE( "(%p,%d,%p)\n", hdc, format, descr );
1071     return NtGdiSetPixelFormat( hdc, format );
1072 }
1073
1074 /***********************************************************************
1075  *           CancelDC    (GDI32.@)
1076  */
1077 BOOL WINAPI CancelDC(HDC hdc)
1078 {
1079     FIXME( "stub\n" );
1080     return TRUE;
1081 }
1082
1083 /***********************************************************************
1084  *           SetICMMode    (GDI32.@)
1085  */
1086 INT WINAPI SetICMMode( HDC hdc, INT mode )
1087 {
1088     /* FIXME: Assume that ICM is always off, and cannot be turned on */
1089     switch (mode)
1090     {
1091     case ICM_OFF:   return ICM_OFF;
1092     case ICM_ON:    return 0;
1093     case ICM_QUERY: return ICM_OFF;
1094     }
1095     return 0;
1096 }
1097
1098 /***********************************************************************
1099  *           GdiIsMetaPrintDC  (GDI32.@)
1100  */
1101 BOOL WINAPI GdiIsMetaPrintDC( HDC hdc )
1102 {
1103     FIXME( "%p\n", hdc );
1104     return FALSE;
1105 }
1106
1107 /***********************************************************************
1108  *           GdiIsMetaFileDC  (GDI32.@)
1109  */
1110 BOOL WINAPI GdiIsMetaFileDC( HDC hdc )
1111 {
1112     TRACE( "%p\n", hdc );
1113
1114     switch (GetObjectType( hdc ))
1115     {
1116     case OBJ_METADC:
1117     case OBJ_ENHMETADC:
1118         return TRUE;
1119     }
1120     return FALSE;
1121 }
1122
1123 /***********************************************************************
1124  *           GdiIsPlayMetafileDC  (GDI32.@)
1125  */
1126 BOOL WINAPI GdiIsPlayMetafileDC( HDC hdc )
1127 {
1128     FIXME( "%p\n", hdc );
1129     return FALSE;
1130 }