dlls/gdi32/dc.c

   1 /*
   2  * GDI Device Context functions
   3  *
   4  * Copyright 1993 Alexandre Julliard
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "config.h"
  22
  23 #include <assert.h>
  24 #include <stdarg.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include "windef.h"
  28 #include "winbase.h"
  29 #include "wingdi.h"
  30 #include "winreg.h"
  31 #include "winternl.h"
  32 #include "winerror.h"
  33 #include "gdi_private.h"
  34 #include "wine/unicode.h"
  35 #include "wine/debug.h"
  36
  37 WINE_DEFAULT_DEBUG_CHANNEL(dc);
  38
  39 static const WCHAR displayW[] = { 'd','i','s','p','l','a','y',0 };
  40
  41 static BOOL DC_DeleteObject( HGDIOBJ handle );
  42
  43 static const struct gdi_obj_funcs dc_funcs =
  44 {
  45     NULL,             /* pSelectObject */
  46     NULL,             /* pGetObjectA */
  47     NULL,             /* pGetObjectW */
  48     NULL,             /* pUnrealizeObject */
  49     DC_DeleteObject   /* pDeleteObject */
  50 };
  51
  52
  53 static inline DC *get_dc_obj( HDC hdc )
  54 {
  55     WORD type;
  56     DC *dc = get_any_obj_ptr( hdc, &type );
  57     if (!dc) return NULL;
  58
  59     switch (type)
  60     {
  61     case OBJ_DC:
  62     case OBJ_MEMDC:
  63     case OBJ_METADC:
  64     case OBJ_ENHMETADC:
  65         return dc;
  66     default:
  67         GDI_ReleaseObj( hdc );
  68         SetLastError( ERROR_INVALID_HANDLE );
  69         return NULL;
  70     }
  71 }
  72
  73
  74 /***********************************************************************
  75  *           set_initial_dc_state
  76  */
  77 static void set_initial_dc_state( DC *dc )
  78 {
  79     dc->wnd_org.x           = 0;
  80     dc->wnd_org.y           = 0;
  81     dc->wnd_ext.cx          = 1;
  82     dc->wnd_ext.cy          = 1;
  83     dc->vport_org.x         = 0;
  84     dc->vport_org.y         = 0;
  85     dc->vport_ext.cx        = 1;
  86     dc->vport_ext.cy        = 1;
  87     dc->miterLimit          = 10.0f; /* 10.0 is the default, from MSDN */
  88     dc->layout              = 0;
  89     dc->font_code_page      = CP_ACP;
  90     dc->ROPmode             = R2_COPYPEN;
  91     dc->polyFillMode        = ALTERNATE;
  92     dc->stretchBltMode      = BLACKONWHITE;
  93     dc->relAbsMode          = ABSOLUTE;
  94     dc->backgroundMode      = OPAQUE;
  95     dc->backgroundColor     = RGB( 255, 255, 255 );
  96     dc->dcBrushColor        = RGB( 255, 255, 255 );
  97     dc->dcPenColor          = RGB( 0, 0, 0 );
  98     dc->textColor           = RGB( 0, 0, 0 );
  99     dc->brush_org.x         = 0;
 100     dc->brush_org.y         = 0;
 101     dc->mapperFlags         = 0;
 102     dc->textAlign           = TA_LEFT | TA_TOP | TA_NOUPDATECP;
 103     dc->charExtra           = 0;
 104     dc->breakExtra          = 0;
 105     dc->breakRem            = 0;
 106     dc->MapMode             = MM_TEXT;
 107     dc->GraphicsMode        = GM_COMPATIBLE;
 108     dc->cur_pos.x           = 0;
 109     dc->cur_pos.y           = 0;
 110     dc->ArcDirection        = AD_COUNTERCLOCKWISE;
 111     dc->xformWorld2Wnd.eM11 = 1.0f;
 112     dc->xformWorld2Wnd.eM12 = 0.0f;
 113     dc->xformWorld2Wnd.eM21 = 0.0f;
 114     dc->xformWorld2Wnd.eM22 = 1.0f;
 115     dc->xformWorld2Wnd.eDx  = 0.0f;
 116     dc->xformWorld2Wnd.eDy  = 0.0f;
 117     dc->xformWorld2Vport    = dc->xformWorld2Wnd;
 118     dc->xformVport2World    = dc->xformWorld2Wnd;
 119     dc->vport2WorldValid    = TRUE;
 120
 121     reset_bounds( &dc->bounds );
 122 }
 123
 124 /***********************************************************************
 125  *           alloc_dc_ptr
 126  */
 127 DC *alloc_dc_ptr( WORD magic )
 128 {
 129     DC *dc;
 130
 131     if (!(dc = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*dc) ))) return NULL;
 132
 133     dc->nulldrv.funcs       = &null_driver;
 134     dc->physDev             = &dc->nulldrv;
 135     dc->thread              = GetCurrentThreadId();
 136     dc->refcount            = 1;
 137     dc->hPen                = GDI_inc_ref_count( GetStockObject( BLACK_PEN ));
 138     dc->hBrush              = GDI_inc_ref_count( GetStockObject( WHITE_BRUSH ));
 139     dc->hFont               = GDI_inc_ref_count( GetStockObject( SYSTEM_FONT ));
 140     dc->hPalette            = GetStockObject( DEFAULT_PALETTE );
 141
 142     set_initial_dc_state( dc );
 143
 144     if (!(dc->hSelf = alloc_gdi_handle( dc, magic, &dc_funcs )))
 145     {
 146         HeapFree( GetProcessHeap(), 0, dc );
 147         return NULL;
 148     }
 149     dc->nulldrv.hdc = dc->hSelf;
 150
 151     if (font_driver && !font_driver->pCreateDC( &dc->physDev, NULL, NULL, NULL, NULL ))
 152     {
 153         free_dc_ptr( dc );
 154         return NULL;
 155     }
 156     return dc;
 157 }
 158
 159
 160
 161 /***********************************************************************
 162  *           free_dc_state
 163  */
 164 static void free_dc_state( DC *dc )
 165 {
 166     if (dc->hClipRgn) DeleteObject( dc->hClipRgn );
 167     if (dc->hMetaRgn) DeleteObject( dc->hMetaRgn );
 168     if (dc->hVisRgn) DeleteObject( dc->hVisRgn );
 169     if (dc->region) DeleteObject( dc->region );
 170     if (dc->path) free_gdi_path( dc->path );
 171     HeapFree( GetProcessHeap(), 0, dc->font_gamma_ramp );
 172     HeapFree( GetProcessHeap(), 0, dc );
 173 }
 174
 175
 176 /***********************************************************************
 177  *           free_dc_ptr
 178  */
 179 void free_dc_ptr( DC *dc )
 180 {
 181     assert( dc->refcount == 1 );
 182
 183     while (dc->physDev != &dc->nulldrv)
 184     {
 185         PHYSDEV physdev = dc->physDev;
 186         dc->physDev = physdev->next;
 187         physdev->funcs->pDeleteDC( physdev );
 188     }
 189     GDI_dec_ref_count( dc->hPen );
 190     GDI_dec_ref_count( dc->hBrush );
 191     GDI_dec_ref_count( dc->hFont );
 192     if (dc->hBitmap) GDI_dec_ref_count( dc->hBitmap );
 193     free_gdi_handle( dc->hSelf );
 194     free_dc_state( dc );
 195 }
 196
 197
 198 /***********************************************************************
 199  *           get_dc_ptr
 200  *
 201  * Retrieve a DC pointer but release the GDI lock.
 202  */
 203 DC *get_dc_ptr( HDC hdc )
 204 {
 205     DC *dc = get_dc_obj( hdc );
 206     if (!dc) return NULL;
 207     if (dc->disabled)
 208     {
 209         GDI_ReleaseObj( hdc );
 210         return NULL;
 211     }
 212
 213     if (!InterlockedCompareExchange( &dc->refcount, 1, 0 ))
 214     {
 215         dc->thread = GetCurrentThreadId();
 216     }
 217     else if (dc->thread != GetCurrentThreadId())
 218     {
 219         WARN( "dc %p belongs to thread %04x\n", hdc, dc->thread );
 220         GDI_ReleaseObj( hdc );
 221         return NULL;
 222     }
 223     else InterlockedIncrement( &dc->refcount );
 224
 225     GDI_ReleaseObj( hdc );
 226     return dc;
 227 }
 228
 229
 230 /***********************************************************************
 231  *           release_dc_ptr
 232  */
 233 void release_dc_ptr( DC *dc )
 234 {
 235     LONG ref;
 236
 237     dc->thread = 0;
 238     ref = InterlockedDecrement( &dc->refcount );
 239     assert( ref >= 0 );
 240     if (ref) dc->thread = GetCurrentThreadId();  /* we still own it */
 241 }
 242
 243
 244 /***********************************************************************
 245  *           update_dc
 246  *
 247  * Make sure the DC vis region is up to date.
 248  * This function may call up to USER so the GDI lock should _not_
 249  * be held when calling it.
 250  */
 251 void update_dc( DC *dc )
 252 {
 253     if (InterlockedExchange( &dc->dirty, 0 ) && dc->hookProc)
 254         dc->hookProc( dc->hSelf, DCHC_INVALIDVISRGN, dc->dwHookData, 0 );
 255 }
 256
 257
 258 /***********************************************************************
 259  *           DC_DeleteObject
 260  */
 261 static BOOL DC_DeleteObject( HGDIOBJ handle )
 262 {
 263     return DeleteDC( handle );
 264 }
 265
 266
 267 /***********************************************************************
 268  *           DC_InitDC
 269  *
 270  * Setup device-specific DC values for a newly created DC.
 271  */
 272 void DC_InitDC( DC* dc )
 273 {
 274     PHYSDEV physdev = GET_DC_PHYSDEV( dc, pRealizeDefaultPalette );
 275     physdev->funcs->pRealizeDefaultPalette( physdev );
 276     SetTextColor( dc->hSelf, dc->textColor );
 277     SetBkColor( dc->hSelf, dc->backgroundColor );
 278     SelectObject( dc->hSelf, dc->hPen );
 279     SelectObject( dc->hSelf, dc->hBrush );
 280     SelectObject( dc->hSelf, dc->hFont );
 281     update_dc_clipping( dc );
 282     SetVirtualResolution( dc->hSelf, 0, 0, 0, 0 );
 283     physdev = GET_DC_PHYSDEV( dc, pSetBoundsRect );
 284     physdev->funcs->pSetBoundsRect( physdev, &dc->bounds, dc->bounds_enabled ? DCB_ENABLE : DCB_DISABLE );
 285 }
 286
 287
 288 /***********************************************************************
 289  *           DC_InvertXform
 290  *
 291  * Computes the inverse of the transformation xformSrc and stores it to
 292  * xformDest. Returns TRUE if successful or FALSE if the xformSrc matrix
 293  * is singular.
 294  */
 295 static BOOL DC_InvertXform( const XFORM *xformSrc, XFORM *xformDest )
 296 {
 297     double determinant;
 298
 299     determinant = xformSrc->eM11*xformSrc->eM22 -
 300         xformSrc->eM12*xformSrc->eM21;
 301     if (determinant > -1e-12 && determinant < 1e-12)
 302         return FALSE;
 303
 304     xformDest->eM11 =  xformSrc->eM22 / determinant;
 305     xformDest->eM12 = -xformSrc->eM12 / determinant;
 306     xformDest->eM21 = -xformSrc->eM21 / determinant;
 307     xformDest->eM22 =  xformSrc->eM11 / determinant;
 308     xformDest->eDx  = -xformSrc->eDx * xformDest->eM11 -
 309                        xformSrc->eDy * xformDest->eM21;
 310     xformDest->eDy  = -xformSrc->eDx * xformDest->eM12 -
 311                        xformSrc->eDy * xformDest->eM22;
 312
 313     return TRUE;
 314 }
 315
 316 /* Construct a transformation to do the window-to-viewport conversion */
 317 static void construct_window_to_viewport(DC *dc, XFORM *xform)
 318 {
 319     double scaleX, scaleY;
 320     scaleX = (double)dc->vport_ext.cx / (double)dc->wnd_ext.cx;
 321     scaleY = (double)dc->vport_ext.cy / (double)dc->wnd_ext.cy;
 322
 323     if (dc->layout & LAYOUT_RTL) scaleX = -scaleX;
 324     xform->eM11 = scaleX;
 325     xform->eM12 = 0.0;
 326     xform->eM21 = 0.0;
 327     xform->eM22 = scaleY;
 328     xform->eDx  = (double)dc->vport_org.x - scaleX * (double)dc->wnd_org.x;
 329     xform->eDy  = (double)dc->vport_org.y - scaleY * (double)dc->wnd_org.y;
 330     if (dc->layout & LAYOUT_RTL) xform->eDx = dc->vis_rect.right - dc->vis_rect.left - 1 - xform->eDx;
 331 }
 332
 333 /***********************************************************************
 334  *        linear_xform_cmp
 335  *
 336  * Compares the linear transform portion of two XFORMs (i.e. the 2x2 submatrix).
 337  * Returns 0 if they match.
 338  */
 339 static inline int linear_xform_cmp( const XFORM *a, const XFORM *b )
 340 {
 341     return memcmp( a, b, FIELD_OFFSET( XFORM, eDx ) );
 342 }
 343
 344 /***********************************************************************
 345  *           DC_UpdateXforms
 346  *
 347  * Updates the xformWorld2Vport, xformVport2World and vport2WorldValid
 348  * fields of the specified DC by creating a transformation that
 349  * represents the current mapping mode and combining it with the DC's
 350  * world transform. This function should be called whenever the
 351  * parameters associated with the mapping mode (window and viewport
 352  * extents and origins) or the world transform change.
 353  */
 354 void DC_UpdateXforms( DC *dc )
 355 {
 356     XFORM xformWnd2Vport, oldworld2vport;
 357
 358     construct_window_to_viewport(dc, &xformWnd2Vport);
 359
 360     oldworld2vport = dc->xformWorld2Vport;
 361     /* Combine with the world transformation */
 362     CombineTransform( &dc->xformWorld2Vport, &dc->xformWorld2Wnd,
 363         &xformWnd2Vport );
 364
 365     /* Create inverse of world-to-viewport transformation */
 366     dc->vport2WorldValid = DC_InvertXform( &dc->xformWorld2Vport,
 367         &dc->xformVport2World );
 368
 369     /* Reselect the font and pen back into the dc so that the size
 370        gets updated. */
 371     if (linear_xform_cmp( &oldworld2vport, &dc->xformWorld2Vport ) &&
 372         !GdiIsMetaFileDC(dc->hSelf))
 373     {
 374         SelectObject(dc->hSelf, dc->hFont);
 375         SelectObject(dc->hSelf, dc->hPen);
 376     }
 377 }
 378
 379
 380 /***********************************************************************
 381  *           nulldrv_SaveDC
 382  */
 383 INT nulldrv_SaveDC( PHYSDEV dev )
 384 {
 385     DC *newdc, *dc = get_nulldrv_dc( dev );
 386
 387     if (!(newdc = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*newdc )))) return 0;
 388     newdc->layout           = dc->layout;
 389     newdc->hPen             = dc->hPen;
 390     newdc->hBrush           = dc->hBrush;
 391     newdc->hFont            = dc->hFont;
 392     newdc->hBitmap          = dc->hBitmap;
 393     newdc->hPalette         = dc->hPalette;
 394     newdc->ROPmode          = dc->ROPmode;
 395     newdc->polyFillMode     = dc->polyFillMode;
 396     newdc->stretchBltMode   = dc->stretchBltMode;
 397     newdc->relAbsMode       = dc->relAbsMode;
 398     newdc->backgroundMode   = dc->backgroundMode;
 399     newdc->backgroundColor  = dc->backgroundColor;
 400     newdc->textColor        = dc->textColor;
 401     newdc->dcBrushColor     = dc->dcBrushColor;
 402     newdc->dcPenColor       = dc->dcPenColor;
 403     newdc->brush_org        = dc->brush_org;
 404     newdc->mapperFlags      = dc->mapperFlags;
 405     newdc->textAlign        = dc->textAlign;
 406     newdc->charExtra        = dc->charExtra;
 407     newdc->breakExtra       = dc->breakExtra;
 408     newdc->breakRem         = dc->breakRem;
 409     newdc->MapMode          = dc->MapMode;
 410     newdc->GraphicsMode     = dc->GraphicsMode;
 411     newdc->cur_pos          = dc->cur_pos;
 412     newdc->ArcDirection     = dc->ArcDirection;
 413     newdc->xformWorld2Wnd   = dc->xformWorld2Wnd;
 414     newdc->xformWorld2Vport = dc->xformWorld2Vport;
 415     newdc->xformVport2World = dc->xformVport2World;
 416     newdc->vport2WorldValid = dc->vport2WorldValid;
 417     newdc->wnd_org          = dc->wnd_org;
 418     newdc->wnd_ext          = dc->wnd_ext;
 419     newdc->vport_org        = dc->vport_org;
 420     newdc->vport_ext        = dc->vport_ext;
 421     newdc->virtual_res      = dc->virtual_res;
 422     newdc->virtual_size     = dc->virtual_size;
 423
 424     /* Get/SetDCState() don't change hVisRgn field ("Undoc. Windows" p.559). */
 425
 426     if (dc->hClipRgn)
 427     {
 428         newdc->hClipRgn = CreateRectRgn( 0, 0, 0, 0 );
 429         CombineRgn( newdc->hClipRgn, dc->hClipRgn, 0, RGN_COPY );
 430     }
 431     if (dc->hMetaRgn)
 432     {
 433         newdc->hMetaRgn = CreateRectRgn( 0, 0, 0, 0 );
 434         CombineRgn( newdc->hMetaRgn, dc->hMetaRgn, 0, RGN_COPY );
 435     }
 436
 437     if (!PATH_SavePath( newdc, dc ))
 438     {
 439         release_dc_ptr( dc );
 440         free_dc_state( newdc );
 441         return 0;
 442     }
 443
 444     newdc->saved_dc = dc->saved_dc;
 445     dc->saved_dc = newdc;
 446     return ++dc->saveLevel;
 447 }
 448
 449
 450 /***********************************************************************
 451  *           nulldrv_RestoreDC
 452  */
 453 BOOL nulldrv_RestoreDC( PHYSDEV dev, INT level )
 454 {
 455     DC *dcs, *first_dcs, *dc = get_nulldrv_dc( dev );
 456     INT save_level;
 457
 458     /* find the state level to restore */
 459
 460     if (abs(level) > dc->saveLevel || level == 0) return FALSE;
 461     if (level < 0) level = dc->saveLevel + level + 1;
 462     first_dcs = dc->saved_dc;
 463     for (dcs = first_dcs, save_level = dc->saveLevel; save_level > level; save_level--)
 464         dcs = dcs->saved_dc;
 465
 466     /* restore the state */
 467
 468     if (!PATH_RestorePath( dc, dcs )) return FALSE;
 469
 470     dc->layout           = dcs->layout;
 471     dc->ROPmode          = dcs->ROPmode;
 472     dc->polyFillMode     = dcs->polyFillMode;
 473     dc->stretchBltMode   = dcs->stretchBltMode;
 474     dc->relAbsMode       = dcs->relAbsMode;
 475     dc->backgroundMode   = dcs->backgroundMode;
 476     dc->backgroundColor  = dcs->backgroundColor;
 477     dc->textColor        = dcs->textColor;
 478     dc->dcBrushColor     = dcs->dcBrushColor;
 479     dc->dcPenColor       = dcs->dcPenColor;
 480     dc->brush_org        = dcs->brush_org;
 481     dc->mapperFlags      = dcs->mapperFlags;
 482     dc->textAlign        = dcs->textAlign;
 483     dc->charExtra        = dcs->charExtra;
 484     dc->breakExtra       = dcs->breakExtra;
 485     dc->breakRem         = dcs->breakRem;
 486     dc->MapMode          = dcs->MapMode;
 487     dc->GraphicsMode     = dcs->GraphicsMode;
 488     dc->cur_pos          = dcs->cur_pos;
 489     dc->ArcDirection     = dcs->ArcDirection;
 490     dc->xformWorld2Wnd   = dcs->xformWorld2Wnd;
 491     dc->xformWorld2Vport = dcs->xformWorld2Vport;
 492     dc->xformVport2World = dcs->xformVport2World;
 493     dc->vport2WorldValid = dcs->vport2WorldValid;
 494     dc->wnd_org          = dcs->wnd_org;
 495     dc->wnd_ext          = dcs->wnd_ext;
 496     dc->vport_org        = dcs->vport_org;
 497     dc->vport_ext        = dcs->vport_ext;
 498     dc->virtual_res      = dcs->virtual_res;
 499     dc->virtual_size     = dcs->virtual_size;
 500
 501     if (dcs->hClipRgn)
 502     {
 503         if (!dc->hClipRgn) dc->hClipRgn = CreateRectRgn( 0, 0, 0, 0 );
 504         CombineRgn( dc->hClipRgn, dcs->hClipRgn, 0, RGN_COPY );
 505     }
 506     else
 507     {
 508         if (dc->hClipRgn) DeleteObject( dc->hClipRgn );
 509         dc->hClipRgn = 0;
 510     }
 511     if (dcs->hMetaRgn)
 512     {
 513         if (!dc->hMetaRgn) dc->hMetaRgn = CreateRectRgn( 0, 0, 0, 0 );
 514         CombineRgn( dc->hMetaRgn, dcs->hMetaRgn, 0, RGN_COPY );
 515     }
 516     else
 517     {
 518         if (dc->hMetaRgn) DeleteObject( dc->hMetaRgn );
 519         dc->hMetaRgn = 0;
 520     }
 521     DC_UpdateXforms( dc );
 522     update_dc_clipping( dc );
 523
 524     SelectObject( dev->hdc, dcs->hBitmap );
 525     SelectObject( dev->hdc, dcs->hBrush );
 526     SelectObject( dev->hdc, dcs->hFont );
 527     SelectObject( dev->hdc, dcs->hPen );
 528     SetBkColor( dev->hdc, dcs->backgroundColor);
 529     SetTextColor( dev->hdc, dcs->textColor);
 530     GDISelectPalette( dev->hdc, dcs->hPalette, FALSE );
 531
 532     dc->saved_dc  = dcs->saved_dc;
 533     dcs->saved_dc = 0;
 534     dc->saveLevel = save_level - 1;
 535
 536     /* now destroy all the saved DCs */
 537
 538     while (first_dcs)
 539     {
 540         DC *next = first_dcs->saved_dc;
 541         free_dc_state( first_dcs );
 542         first_dcs = next;
 543     }
 544     return TRUE;
 545 }
 546
 547
 548 /***********************************************************************
 549  *           reset_dc_state
 550  */
 551 static BOOL reset_dc_state( HDC hdc )
 552 {
 553     DC *dc, *dcs, *next;
 554
 555     if (!(dc = get_dc_ptr( hdc ))) return FALSE;
 556
 557     set_initial_dc_state( dc );
 558     SetBkColor( hdc, RGB( 255, 255, 255 ));
 559     SetTextColor( hdc, RGB( 0, 0, 0 ));
 560     SelectObject( hdc, GetStockObject( WHITE_BRUSH ));
 561     SelectObject( hdc, GetStockObject( SYSTEM_FONT ));
 562     SelectObject( hdc, GetStockObject( BLACK_PEN ));
 563     SetVirtualResolution( hdc, 0, 0, 0, 0 );
 564     GDISelectPalette( hdc, GetStockObject( DEFAULT_PALETTE ), FALSE );
 565     SetBoundsRect( hdc, NULL, DCB_DISABLE );
 566     AbortPath( hdc );
 567
 568     if (dc->hClipRgn) DeleteObject( dc->hClipRgn );
 569     if (dc->hMetaRgn) DeleteObject( dc->hMetaRgn );
 570     dc->hClipRgn = 0;
 571     dc->hMetaRgn = 0;
 572     update_dc_clipping( dc );
 573
 574     for (dcs = dc->saved_dc; dcs; dcs = next)
 575     {
 576         next = dcs->saved_dc;
 577         free_dc_state( dcs );
 578     }
 579     dc->saved_dc = NULL;
 580     dc->saveLevel = 0;
 581     release_dc_ptr( dc );
 582     return TRUE;
 583 }
 584
 585
 586 /***********************************************************************
 587  *           SaveDC    (GDI32.@)
 588  */
 589 INT WINAPI SaveDC( HDC hdc )
 590 {
 591     DC * dc;
 592     INT ret = 0;
 593
 594     if ((dc = get_dc_ptr( hdc )))
 595     {
 596         PHYSDEV physdev = GET_DC_PHYSDEV( dc, pSaveDC );
 597         ret = physdev->funcs->pSaveDC( physdev );
 598         release_dc_ptr( dc );
 599     }
 600     return ret;
 601 }
 602
 603
 604 /***********************************************************************
 605  *           RestoreDC    (GDI32.@)
 606  */
 607 BOOL WINAPI RestoreDC( HDC hdc, INT level )
 608 {
 609     PHYSDEV physdev;
 610     DC *dc;
 611     BOOL success = FALSE;
 612
 613     TRACE("%p %d\n", hdc, level );
 614     if ((dc = get_dc_ptr( hdc )))
 615     {
 616         update_dc( dc );
 617         physdev = GET_DC_PHYSDEV( dc, pRestoreDC );
 618         success = physdev->funcs->pRestoreDC( physdev, level );
 619         release_dc_ptr( dc );
 620     }
 621     return success;
 622 }
 623
 624
 625 /***********************************************************************
 626  *           CreateDCW    (GDI32.@)
 627  */
 628 HDC WINAPI CreateDCW( LPCWSTR driver, LPCWSTR device, LPCWSTR output,
 629                       const DEVMODEW *initData )
 630 {
 631     HDC hdc;
 632     DC * dc;
 633     const struct gdi_dc_funcs *funcs;
 634     WCHAR buf[300];
 635
 636     GDI_CheckNotLock();
 637
 638     if (!device || !DRIVER_GetDriverName( device, buf, 300 ))
 639     {
 640         if (!driver)
 641         {
 642             ERR( "no device found for %s\n", debugstr_w(device) );
 643             return 0;
 644         }
 645         strcpyW(buf, driver);
 646     }
 647
 648     if (!(funcs = DRIVER_load_driver( buf )))
 649     {
 650         ERR( "no driver found for %s\n", debugstr_w(buf) );
 651         return 0;
 652     }
 653     if (!(dc = alloc_dc_ptr( OBJ_DC ))) return 0;
 654     hdc = dc->hSelf;
 655
 656     dc->hBitmap = GDI_inc_ref_count( GetStockObject( DEFAULT_BITMAP ));
 657
 658     TRACE("(driver=%s, device=%s, output=%s): returning %p\n",
 659           debugstr_w(driver), debugstr_w(device), debugstr_w(output), dc->hSelf );
 660
 661     if (funcs->pCreateDC)
 662     {
 663         if (!funcs->pCreateDC( &dc->physDev, buf, device, output, initData ))
 664         {
 665             WARN("creation aborted by device\n" );
 666             free_dc_ptr( dc );
 667             return 0;
 668         }
 669     }
 670
 671     dc->vis_rect.left   = 0;
 672     dc->vis_rect.top    = 0;
 673     dc->vis_rect.right  = GetDeviceCaps( hdc, DESKTOPHORZRES );
 674     dc->vis_rect.bottom = GetDeviceCaps( hdc, DESKTOPVERTRES );
 675
 676     DC_InitDC( dc );
 677     release_dc_ptr( dc );
 678     return hdc;
 679 }
 680
 681
 682 /***********************************************************************
 683  *           CreateDCA    (GDI32.@)
 684  */
 685 HDC WINAPI CreateDCA( LPCSTR driver, LPCSTR device, LPCSTR output,
 686                       const DEVMODEA *initData )
 687 {
 688     UNICODE_STRING driverW, deviceW, outputW;
 689     DEVMODEW *initDataW;
 690     HDC ret;
 691
 692     if (driver) RtlCreateUnicodeStringFromAsciiz(&driverW, driver);
 693     else driverW.Buffer = NULL;
 694
 695     if (device) RtlCreateUnicodeStringFromAsciiz(&deviceW, device);
 696     else deviceW.Buffer = NULL;
 697
 698     if (output) RtlCreateUnicodeStringFromAsciiz(&outputW, output);
 699     else outputW.Buffer = NULL;
 700
 701     initDataW = NULL;
 702     if (initData)
 703     {
 704         /* don't convert initData for DISPLAY driver, it's not used */
 705         if (!driverW.Buffer || strcmpiW( driverW.Buffer, displayW ))
 706             initDataW = GdiConvertToDevmodeW(initData);
 707     }
 708
 709     ret = CreateDCW( driverW.Buffer, deviceW.Buffer, outputW.Buffer, initDataW );
 710
 711     RtlFreeUnicodeString(&driverW);
 712     RtlFreeUnicodeString(&deviceW);
 713     RtlFreeUnicodeString(&outputW);
 714     HeapFree(GetProcessHeap(), 0, initDataW);
 715     return ret;
 716 }
 717
 718
 719 /***********************************************************************
 720  *           CreateICA    (GDI32.@)
 721  */
 722 HDC WINAPI CreateICA( LPCSTR driver, LPCSTR device, LPCSTR output,
 723                           const DEVMODEA* initData )
 724 {
 725       /* Nothing special yet for ICs */
 726     return CreateDCA( driver, device, output, initData );
 727 }
 728
 729
 730 /***********************************************************************
 731  *           CreateICW    (GDI32.@)
 732  */
 733 HDC WINAPI CreateICW( LPCWSTR driver, LPCWSTR device, LPCWSTR output,
 734                           const DEVMODEW* initData )
 735 {
 736       /* Nothing special yet for ICs */
 737     return CreateDCW( driver, device, output, initData );
 738 }
 739
 740
 741 /***********************************************************************
 742  *           CreateCompatibleDC   (GDI32.@)
 743  */
 744 HDC WINAPI CreateCompatibleDC( HDC hdc )
 745 {
 746     DC *dc, *origDC;
 747     HDC ret;
 748     const struct gdi_dc_funcs *funcs;
 749     PHYSDEV physDev = NULL;
 750
 751     GDI_CheckNotLock();
 752
 753     if (hdc)
 754     {
 755         if (!(origDC = get_dc_ptr( hdc ))) return 0;
 756         physDev = GET_DC_PHYSDEV( origDC, pCreateCompatibleDC );
 757         funcs = physDev->funcs;
 758         release_dc_ptr( origDC );
 759     }
 760     else funcs = DRIVER_load_driver( displayW );
 761
 762     if (!(dc = alloc_dc_ptr( OBJ_MEMDC ))) return 0;
 763
 764     TRACE("(%p): returning %p\n", hdc, dc->hSelf );
 765
 766     dc->hBitmap = GDI_inc_ref_count( GetStockObject( DEFAULT_BITMAP ));
 767     dc->vis_rect.left   = 0;
 768     dc->vis_rect.top    = 0;
 769     dc->vis_rect.right  = 1;
 770     dc->vis_rect.bottom = 1;
 771     dc->device_rect = dc->vis_rect;
 772
 773     ret = dc->hSelf;
 774
 775     if (funcs->pCreateCompatibleDC && !funcs->pCreateCompatibleDC( physDev, &dc->physDev ))
 776     {
 777         WARN("creation aborted by device\n");
 778         free_dc_ptr( dc );
 779         return 0;
 780     }
 781
 782     if (!dib_driver.pCreateDC( &dc->physDev, NULL, NULL, NULL, NULL ))
 783     {
 784         free_dc_ptr( dc );
 785         return 0;
 786     }
 787     physDev = GET_DC_PHYSDEV( dc, pSelectBitmap );
 788     physDev->funcs->pSelectBitmap( physDev, dc->hBitmap );
 789
 790     DC_InitDC( dc );
 791     release_dc_ptr( dc );
 792     return ret;
 793 }
 794
 795
 796 /***********************************************************************
 797  *           DeleteDC    (GDI32.@)
 798  */
 799 BOOL WINAPI DeleteDC( HDC hdc )
 800 {
 801     DC * dc;
 802
 803     TRACE("%p\n", hdc );
 804
 805     GDI_CheckNotLock();
 806
 807     if (!(dc = get_dc_ptr( hdc ))) return FALSE;
 808     if (dc->refcount != 1)
 809     {
 810         FIXME( "not deleting busy DC %p refcount %u\n", dc->hSelf, dc->refcount );
 811         release_dc_ptr( dc );
 812         return FALSE;
 813     }
 814
 815     /* Call hook procedure to check whether is it OK to delete this DC */
 816     if (dc->hookProc && !dc->hookProc( dc->hSelf, DCHC_DELETEDC, dc->dwHookData, 0 ))
 817     {
 818         release_dc_ptr( dc );
 819         return TRUE;
 820     }
 821     reset_dc_state( hdc );
 822     free_dc_ptr( dc );
 823     return TRUE;
 824 }
 825
 826
 827 /***********************************************************************
 828  *           ResetDCW    (GDI32.@)
 829  */
 830 HDC WINAPI ResetDCW( HDC hdc, const DEVMODEW *devmode )
 831 {
 832     DC *dc;
 833     HDC ret = 0;
 834
 835     if ((dc = get_dc_ptr( hdc )))
 836     {
 837         PHYSDEV physdev = GET_DC_PHYSDEV( dc, pResetDC );
 838         ret = physdev->funcs->pResetDC( physdev, devmode );
 839         if (ret)  /* reset the visible region */
 840         {
 841             dc->dirty = 0;
 842             dc->vis_rect.left   = 0;
 843             dc->vis_rect.top    = 0;
 844             dc->vis_rect.right  = GetDeviceCaps( hdc, DESKTOPHORZRES );
 845             dc->vis_rect.bottom = GetDeviceCaps( hdc, DESKTOPVERTRES );
 846             if (dc->hVisRgn) DeleteObject( dc->hVisRgn );
 847             dc->hVisRgn = 0;
 848             update_dc_clipping( dc );
 849         }
 850         release_dc_ptr( dc );
 851     }
 852     return ret;
 853 }
 854
 855
 856 /***********************************************************************
 857  *           ResetDCA    (GDI32.@)
 858  */
 859 HDC WINAPI ResetDCA( HDC hdc, const DEVMODEA *devmode )
 860 {
 861     DEVMODEW *devmodeW;
 862     HDC ret;
 863
 864     if (devmode) devmodeW = GdiConvertToDevmodeW(devmode);
 865     else devmodeW = NULL;
 866
 867     ret = ResetDCW(hdc, devmodeW);
 868
 869     HeapFree(GetProcessHeap(), 0, devmodeW);
 870     return ret;
 871 }
 872
 873
 874 /***********************************************************************
 875  *           GetDeviceCaps    (GDI32.@)
 876  */
 877 INT WINAPI GetDeviceCaps( HDC hdc, INT cap )
 878 {
 879     DC *dc;
 880     INT ret = 0;
 881
 882     if ((dc = get_dc_ptr( hdc )))
 883     {
 884         PHYSDEV physdev = GET_DC_PHYSDEV( dc, pGetDeviceCaps );
 885         ret = physdev->funcs->pGetDeviceCaps( physdev, cap );
 886         release_dc_ptr( dc );
 887     }
 888     return ret;
 889 }
 890
 891
 892 /***********************************************************************
 893  *              GetBkColor (GDI32.@)
 894  */
 895 COLORREF WINAPI GetBkColor( HDC hdc )
 896 {
 897     COLORREF ret = 0;
 898     DC * dc = get_dc_ptr( hdc );
 899     if (dc)
 900     {
 901         ret = dc->backgroundColor;
 902         release_dc_ptr( dc );
 903     }
 904     return ret;
 905 }
 906
 907
 908 /***********************************************************************
 909  *           SetBkColor    (GDI32.@)
 910  */
 911 COLORREF WINAPI SetBkColor( HDC hdc, COLORREF color )
 912 {
 913     COLORREF ret = CLR_INVALID;
 914     DC * dc = get_dc_ptr( hdc );
 915
 916     TRACE("hdc=%p color=0x%08x\n", hdc, color);
 917
 918     if (dc)
 919     {
 920         PHYSDEV physdev = GET_DC_PHYSDEV( dc, pSetBkColor );
 921         ret = dc->backgroundColor;
 922         dc->backgroundColor = physdev->funcs->pSetBkColor( physdev, color );
 923         release_dc_ptr( dc );
 924     }
 925     return ret;
 926 }
 927
 928
 929 /***********************************************************************
 930  *              GetTextColor (GDI32.@)
 931  */
 932 COLORREF WINAPI GetTextColor( HDC hdc )
 933 {
 934     COLORREF ret = 0;
 935     DC * dc = get_dc_ptr( hdc );
 936     if (dc)
 937     {
 938         ret = dc->textColor;
 939         release_dc_ptr( dc );
 940     }
 941     return ret;
 942 }
 943
 944
 945 /***********************************************************************
 946  *           SetTextColor    (GDI32.@)
 947  */
 948 COLORREF WINAPI SetTextColor( HDC hdc, COLORREF color )
 949 {
 950     COLORREF ret = CLR_INVALID;
 951     DC * dc = get_dc_ptr( hdc );
 952
 953     TRACE(" hdc=%p color=0x%08x\n", hdc, color);
 954
 955     if (dc)
 956     {
 957         PHYSDEV physdev = GET_DC_PHYSDEV( dc, pSetTextColor );
 958         ret = dc->textColor;
 959         dc->textColor = physdev->funcs->pSetTextColor( physdev, color );
 960         release_dc_ptr( dc );
 961     }
 962     return ret;
 963 }
 964
 965
 966 /***********************************************************************
 967  *              GetTextAlign (GDI32.@)
 968  */
 969 UINT WINAPI GetTextAlign( HDC hdc )
 970 {
 971     UINT ret = 0;
 972     DC * dc = get_dc_ptr( hdc );
 973     if (dc)
 974     {
 975         ret = dc->textAlign;
 976         release_dc_ptr( dc );
 977     }
 978     return ret;
 979 }
 980
 981
 982 /***********************************************************************
 983  *           SetTextAlign    (GDI32.@)
 984  */
 985 UINT WINAPI SetTextAlign( HDC hdc, UINT align )
 986 {
 987     UINT ret = GDI_ERROR;
 988     DC *dc = get_dc_ptr( hdc );
 989
 990     TRACE("hdc=%p align=%d\n", hdc, align);
 991
 992     if (dc)
 993     {
 994         PHYSDEV physdev = GET_DC_PHYSDEV( dc, pSetTextAlign );
 995         align = physdev->funcs->pSetTextAlign( physdev, align );
 996         if (align != GDI_ERROR)
 997         {
 998             ret = dc->textAlign;
 999             dc->textAlign = align;
1000         }
1001         release_dc_ptr( dc );
1002     }
1003     return ret;
1004 }
1005
1006 /***********************************************************************
1007  *           GetDCOrgEx  (GDI32.@)
1008  */
1009 BOOL WINAPI GetDCOrgEx( HDC hDC, LPPOINT lpp )
1010 {
1011     DC * dc;
1012
1013     if (!lpp) return FALSE;
1014     if (!(dc = get_dc_ptr( hDC ))) return FALSE;
1015     lpp->x = dc->vis_rect.left;
1016     lpp->y = dc->vis_rect.top;
1017     release_dc_ptr( dc );
1018     return TRUE;
1019 }
1020
1021
1022 /***********************************************************************
1023  *              GetGraphicsMode (GDI32.@)
1024  */
1025 INT WINAPI GetGraphicsMode( HDC hdc )
1026 {
1027     INT ret = 0;
1028     DC * dc = get_dc_ptr( hdc );
1029     if (dc)
1030     {
1031         ret = dc->GraphicsMode;
1032         release_dc_ptr( dc );
1033     }
1034     return ret;
1035 }
1036
1037
1038 /***********************************************************************
1039  *           SetGraphicsMode    (GDI32.@)
1040  */
1041 INT WINAPI SetGraphicsMode( HDC hdc, INT mode )
1042 {
1043     INT ret = 0;
1044     DC *dc = get_dc_ptr( hdc );
1045
1046     /* One would think that setting the graphics mode to GM_COMPATIBLE
1047      * would also reset the world transformation matrix to the unity
1048      * matrix. However, in Windows, this is not the case. This doesn't
1049      * make a lot of sense to me, but that's the way it is.
1050      */
1051     if (!dc) return 0;
1052     if ((mode > 0) && (mode <= GM_LAST))
1053     {
1054         ret = dc->GraphicsMode;
1055         dc->GraphicsMode = mode;
1056     }
1057     /* font metrics depend on the graphics mode */
1058     if (ret != mode) SelectObject(dc->hSelf, dc->hFont);
1059     release_dc_ptr( dc );
1060     return ret;
1061 }
1062
1063
1064 /***********************************************************************
1065  *              GetArcDirection (GDI32.@)
1066  */
1067 INT WINAPI GetArcDirection( HDC hdc )
1068 {
1069     INT ret = 0;
1070     DC * dc = get_dc_ptr( hdc );
1071     if (dc)
1072     {
1073         ret = dc->ArcDirection;
1074         release_dc_ptr( dc );
1075     }
1076     return ret;
1077 }
1078
1079
1080 /***********************************************************************
1081  *           SetArcDirection    (GDI32.@)
1082  */
1083 INT WINAPI SetArcDirection( HDC hdc, INT dir )
1084 {
1085     DC * dc;
1086     INT ret = 0;
1087
1088     if (dir != AD_COUNTERCLOCKWISE && dir != AD_CLOCKWISE)
1089     {
1090         SetLastError(ERROR_INVALID_PARAMETER);
1091         return 0;
1092     }
1093
1094     if ((dc = get_dc_ptr( hdc )))
1095     {
1096         PHYSDEV physdev = GET_DC_PHYSDEV( dc, pSetArcDirection );
1097         dir = physdev->funcs->pSetArcDirection( physdev, dir );
1098         if (dir)
1099         {
1100             ret = dc->ArcDirection;
1101             dc->ArcDirection = dir;
1102         }
1103         release_dc_ptr( dc );
1104     }
1105     return ret;
1106 }
1107
1108
1109 /***********************************************************************
1110  *           GetWorldTransform    (GDI32.@)
1111  */
1112 BOOL WINAPI GetWorldTransform( HDC hdc, LPXFORM xform )
1113 {
1114     DC * dc;
1115     if (!xform) return FALSE;
1116     if (!(dc = get_dc_ptr( hdc ))) return FALSE;
1117     *xform = dc->xformWorld2Wnd;
1118     release_dc_ptr( dc );
1119     return TRUE;
1120 }
1121
1122
1123 /***********************************************************************
1124  *           GetTransform    (GDI32.@)
1125  *
1126  * Undocumented
1127  *
1128  * Returns one of the co-ordinate space transforms
1129  *
1130  * PARAMS
1131  *    hdc   [I] Device context.
1132  *    which [I] Which xform to return:
1133  *                  0x203 World -> Page transform (that set by SetWorldTransform).
1134  *                  0x304 Page -> Device transform (the mapping mode transform).
1135  *                  0x204 World -> Device transform (the combination of the above two).
1136  *                  0x402 Device -> World transform (the inversion of the above).
1137  *    xform [O] The xform.
1138  *
1139  */
1140 BOOL WINAPI GetTransform( HDC hdc, DWORD which, XFORM *xform )
1141 {
1142     BOOL ret = TRUE;
1143     DC *dc = get_dc_ptr( hdc );
1144     if (!dc) return FALSE;
1145
1146     switch(which)
1147     {
1148     case 0x203:
1149         *xform = dc->xformWorld2Wnd;
1150         break;
1151
1152     case 0x304:
1153         construct_window_to_viewport(dc, xform);
1154         break;
1155
1156     case 0x204:
1157         *xform = dc->xformWorld2Vport;
1158         break;
1159
1160     case 0x402:
1161         *xform = dc->xformVport2World;
1162         break;
1163
1164     default:
1165         FIXME("Unknown code %x\n", which);
1166         ret = FALSE;
1167     }
1168
1169     release_dc_ptr( dc );
1170     return ret;
1171 }
1172
1173
1174 /****************************************************************************
1175  * CombineTransform [GDI32.@]
1176  * Combines two transformation matrices.
1177  *
1178  * PARAMS
1179  *    xformResult [O] Stores the result of combining the two matrices
1180  *    xform1      [I] Specifies the first matrix to apply
1181  *    xform2      [I] Specifies the second matrix to apply
1182  *
1183  * REMARKS
1184  *    The same matrix can be passed in for more than one of the parameters.
1185  *
1186  * RETURNS
1187  *  Success: TRUE.
1188  *  Failure: FALSE. Use GetLastError() to determine the cause.
1189  */
1190 BOOL WINAPI CombineTransform( LPXFORM xformResult, const XFORM *xform1,
1191     const XFORM *xform2 )
1192 {
1193     XFORM xformTemp;
1194
1195     /* Check for illegal parameters */
1196     if (!xformResult || !xform1 || !xform2)
1197         return FALSE;
1198
1199     /* Create the result in a temporary XFORM, since xformResult may be
1200      * equal to xform1 or xform2 */
1201     xformTemp.eM11 = xform1->eM11 * xform2->eM11 +
1202                      xform1->eM12 * xform2->eM21;
1203     xformTemp.eM12 = xform1->eM11 * xform2->eM12 +
1204                      xform1->eM12 * xform2->eM22;
1205     xformTemp.eM21 = xform1->eM21 * xform2->eM11 +
1206                      xform1->eM22 * xform2->eM21;
1207     xformTemp.eM22 = xform1->eM21 * xform2->eM12 +
1208                      xform1->eM22 * xform2->eM22;
1209     xformTemp.eDx  = xform1->eDx  * xform2->eM11 +
1210                      xform1->eDy  * xform2->eM21 +
1211                      xform2->eDx;
1212     xformTemp.eDy  = xform1->eDx  * xform2->eM12 +
1213                      xform1->eDy  * xform2->eM22 +
1214                      xform2->eDy;
1215
1216     /* Copy the result to xformResult */
1217     *xformResult = xformTemp;
1218
1219     return TRUE;
1220 }
1221
1222
1223 /***********************************************************************
1224  *           SetDCHook   (GDI32.@)
1225  *
1226  * Note: this doesn't exist in Win32, we add it here because user32 needs it.
1227  */
1228 BOOL WINAPI SetDCHook( HDC hdc, DCHOOKPROC hookProc, DWORD_PTR dwHookData )
1229 {
1230     DC *dc = get_dc_ptr( hdc );
1231
1232     if (!dc) return FALSE;
1233
1234     dc->dwHookData = dwHookData;
1235     dc->hookProc = hookProc;
1236     release_dc_ptr( dc );
1237     return TRUE;
1238 }
1239
1240
1241 /***********************************************************************
1242  *           GetDCHook   (GDI32.@)
1243  *
1244  * Note: this doesn't exist in Win32, we add it here because user32 needs it.
1245  */
1246 DWORD_PTR WINAPI GetDCHook( HDC hdc, DCHOOKPROC *proc )
1247 {
1248     DC *dc = get_dc_ptr( hdc );
1249     DWORD_PTR ret;
1250
1251     if (!dc) return 0;
1252     if (proc) *proc = dc->hookProc;
1253     ret = dc->dwHookData;
1254     release_dc_ptr( dc );
1255     return ret;
1256 }
1257
1258
1259 /***********************************************************************
1260  *           SetHookFlags   (GDI32.@)
1261  *
1262  * Note: this doesn't exist in Win32, we add it here because user32 needs it.
1263  */
1264 WORD WINAPI SetHookFlags( HDC hdc, WORD flags )
1265 {
1266     DC *dc = get_dc_obj( hdc );  /* not get_dc_ptr, this needs to work from any thread */
1267     LONG ret = 0;
1268
1269     if (!dc) return 0;
1270
1271     TRACE("hDC %p, flags %04x\n",hdc,flags);
1272
1273     if (flags & DCHF_INVALIDATEVISRGN)
1274         ret = InterlockedExchange( &dc->dirty, 1 );
1275     else if (flags & DCHF_VALIDATEVISRGN || !flags)
1276         ret = InterlockedExchange( &dc->dirty, 0 );
1277
1278     if (flags & DCHF_DISABLEDC)
1279         ret = InterlockedExchange( &dc->disabled, 1 );
1280     else if (flags & DCHF_ENABLEDC)
1281         ret = InterlockedExchange( &dc->disabled, 0 );
1282
1283     GDI_ReleaseObj( hdc );
1284
1285     if (flags & DCHF_RESETDC) ret = reset_dc_state( hdc );
1286     return ret;
1287 }
1288
1289 /***********************************************************************
1290  *           SetICMMode    (GDI32.@)
1291  */
1292 INT WINAPI SetICMMode(HDC hdc, INT iEnableICM)
1293 {
1294 /*FIXME:  Assume that ICM is always off, and cannot be turned on */
1295     if (iEnableICM == ICM_OFF) return ICM_OFF;
1296     if (iEnableICM == ICM_ON) return 0;
1297     if (iEnableICM == ICM_QUERY) return ICM_OFF;
1298     return 0;
1299 }
1300
1301 /***********************************************************************
1302  *           GetDeviceGammaRamp    (GDI32.@)
1303  */
1304 BOOL WINAPI GetDeviceGammaRamp(HDC hDC, LPVOID ptr)
1305 {
1306     BOOL ret = FALSE;
1307     DC *dc = get_dc_ptr( hDC );
1308
1309     TRACE("%p, %p\n", hDC, ptr);
1310     if( dc )
1311     {
1312         if (GetObjectType( hDC ) != OBJ_MEMDC)
1313         {
1314             PHYSDEV physdev = GET_DC_PHYSDEV( dc, pGetDeviceGammaRamp );
1315             ret = physdev->funcs->pGetDeviceGammaRamp( physdev, ptr );
1316         }
1317         else SetLastError( ERROR_INVALID_PARAMETER );
1318         release_dc_ptr( dc );
1319     }
1320     return ret;
1321 }
1322
1323 static BOOL check_gamma_ramps(void *ptr)
1324 {
1325     WORD *ramp = ptr;
1326
1327     while (ramp < (WORD*)ptr + 3 * 256)
1328     {
1329         float r_x, r_y, r_lx, r_ly, r_d, r_v, r_e, g_avg, g_min, g_max;
1330         unsigned i, f, l, g_n, c;
1331
1332         f = ramp[0];
1333         l = ramp[255];
1334         if (f >= l)
1335         {
1336             TRACE("inverted or flat gamma ramp (%d->%d), rejected\n", f, l);
1337             return FALSE;
1338         }
1339         r_d = l - f;
1340         g_min = g_max = g_avg = 0.0;
1341
1342         /* check gamma ramp entries to estimate the gamma */
1343         TRACE("analyzing gamma ramp (%d->%d)\n", f, l);
1344         for (i=1, g_n=0; i<255; i++)
1345         {
1346             if (ramp[i] < f || ramp[i] > l)
1347             {
1348                 TRACE("strange gamma ramp ([%d]=%d for %d->%d), rejected\n", i, ramp[i], f, l);
1349                 return FALSE;
1350             }
1351             c = ramp[i] - f;
1352             if (!c) continue; /* avoid log(0) */
1353
1354             /* normalize entry values into 0..1 range */
1355             r_x = i/255.0; r_y = c / r_d;
1356             /* compute logarithms of values */
1357             r_lx = log(r_x); r_ly = log(r_y);
1358             /* compute gamma for this entry */
1359             r_v = r_ly / r_lx;
1360             /* compute differential (error estimate) for this entry */
1361             /* some games use table-based logarithms that magnifies the error by 128 */
1362             r_e = -r_lx * 128 / (c * r_lx * r_lx);
1363
1364             /* compute min & max while compensating for estimated error */
1365             if (!g_n || g_min > (r_v + r_e)) g_min = r_v + r_e;
1366             if (!g_n || g_max < (r_v - r_e)) g_max = r_v - r_e;
1367
1368             /* add to average */
1369             g_avg += r_v;
1370             g_n++;
1371         }
1372
1373         if (!g_n)
1374         {
1375             TRACE("no gamma data, shouldn't happen\n");
1376             return FALSE;
1377         }
1378         g_avg /= g_n;
1379         TRACE("low bias is %d, high is %d, gamma is %5.3f\n", f, 65535-l, g_avg);
1380
1381         /* check that the gamma is reasonably uniform across the ramp */
1382         if (g_max - g_min > 12.8)
1383         {
1384             TRACE("ramp not uniform (max=%f, min=%f, avg=%f), rejected\n", g_max, g_min, g_avg);
1385             return FALSE;
1386         }
1387
1388         /* check that the gamma is not too bright */
1389         if (g_avg < 0.2)
1390         {
1391             TRACE("too bright gamma ( %5.3f), rejected\n", g_avg);
1392             return FALSE;
1393         }
1394
1395         ramp += 256;
1396     }
1397
1398     return TRUE;
1399 }
1400
1401 /***********************************************************************
1402  *           SetDeviceGammaRamp    (GDI32.@)
1403  */
1404 BOOL WINAPI SetDeviceGammaRamp(HDC hDC, LPVOID ptr)
1405 {
1406     BOOL ret = FALSE;
1407     DC *dc = get_dc_ptr( hDC );
1408
1409     TRACE("%p, %p\n", hDC, ptr);
1410     if( dc )
1411     {
1412         if (GetObjectType( hDC ) != OBJ_MEMDC)
1413         {
1414             PHYSDEV physdev = GET_DC_PHYSDEV( dc, pSetDeviceGammaRamp );
1415
1416             if (check_gamma_ramps(ptr))
1417                 ret = physdev->funcs->pSetDeviceGammaRamp( physdev, ptr );
1418         }
1419         else SetLastError( ERROR_INVALID_PARAMETER );
1420         release_dc_ptr( dc );
1421     }
1422     return ret;
1423 }
1424
1425 /***********************************************************************
1426  *           GetColorSpace    (GDI32.@)
1427  */
1428 HCOLORSPACE WINAPI GetColorSpace(HDC hdc)
1429 {
1430 /*FIXME    Need to do whatever GetColorSpace actually does */
1431     return 0;
1432 }
1433
1434 /***********************************************************************
1435  *           CreateColorSpaceA    (GDI32.@)
1436  */
1437 HCOLORSPACE WINAPI CreateColorSpaceA( LPLOGCOLORSPACEA lpLogColorSpace )
1438 {
1439   FIXME( "stub\n" );
1440   return 0;
1441 }
1442
1443 /***********************************************************************
1444  *           CreateColorSpaceW    (GDI32.@)
1445  */
1446 HCOLORSPACE WINAPI CreateColorSpaceW( LPLOGCOLORSPACEW lpLogColorSpace )
1447 {
1448   FIXME( "stub\n" );
1449   return 0;
1450 }
1451
1452 /***********************************************************************
1453  *           DeleteColorSpace     (GDI32.@)
1454  */
1455 BOOL WINAPI DeleteColorSpace( HCOLORSPACE hColorSpace )
1456 {
1457   FIXME( "stub\n" );
1458
1459   return TRUE;
1460 }
1461
1462 /***********************************************************************
1463  *           SetColorSpace     (GDI32.@)
1464  */
1465 HCOLORSPACE WINAPI SetColorSpace( HDC hDC, HCOLORSPACE hColorSpace )
1466 {
1467   FIXME( "stub\n" );
1468
1469   return hColorSpace;
1470 }
1471
1472 /***********************************************************************
1473  *           GetBoundsRect    (GDI32.@)
1474  */
1475 UINT WINAPI GetBoundsRect(HDC hdc, LPRECT rect, UINT flags)
1476 {
1477     PHYSDEV physdev;
1478     RECT device_rect;
1479     UINT ret;
1480     DC *dc = get_dc_ptr( hdc );
1481
1482     if ( !dc ) return 0;
1483
1484     physdev = GET_DC_PHYSDEV( dc, pGetBoundsRect );
1485     ret = physdev->funcs->pGetBoundsRect( physdev, &device_rect, DCB_RESET );
1486     if (!ret)
1487     {
1488         release_dc_ptr( dc );
1489         return 0;
1490     }
1491     if (dc->bounds_enabled && ret == DCB_SET) add_bounds_rect( &dc->bounds, &device_rect );
1492
1493     if (rect)
1494     {
1495         if (is_rect_empty( &dc->bounds ))
1496         {
1497             rect->left = rect->top = rect->right = rect->bottom = 0;
1498             ret = DCB_RESET;
1499         }
1500         else
1501         {
1502             *rect = dc->bounds;
1503             rect->left   = max( rect->left, 0 );
1504             rect->top    = max( rect->top, 0 );
1505             rect->right  = min( rect->right, dc->vis_rect.right - dc->vis_rect.left );
1506             rect->bottom = min( rect->bottom, dc->vis_rect.bottom - dc->vis_rect.top );
1507             ret = DCB_SET;
1508         }
1509         dp_to_lp( dc, (POINT *)rect, 2 );
1510     }
1511     else ret = 0;
1512
1513     if (flags & DCB_RESET) reset_bounds( &dc->bounds );
1514     release_dc_ptr( dc );
1515     return ret;
1516 }
1517
1518
1519 /***********************************************************************
1520  *           SetBoundsRect    (GDI32.@)
1521  */
1522 UINT WINAPI SetBoundsRect(HDC hdc, const RECT* rect, UINT flags)
1523 {
1524     PHYSDEV physdev;
1525     UINT ret;
1526     DC *dc;
1527
1528     if ((flags & DCB_ENABLE) && (flags & DCB_DISABLE)) return 0;
1529     if (!(dc = get_dc_ptr( hdc ))) return 0;
1530
1531     physdev = GET_DC_PHYSDEV( dc, pSetBoundsRect );
1532     ret = physdev->funcs->pSetBoundsRect( physdev, &dc->bounds, flags );
1533     if (!ret)
1534     {
1535         release_dc_ptr( dc );
1536         return 0;
1537     }
1538
1539     ret = (dc->bounds_enabled ? DCB_ENABLE : DCB_DISABLE) |
1540           (is_rect_empty( &dc->bounds ) ? ret & DCB_SET : DCB_SET);
1541
1542     if (flags & DCB_RESET) reset_bounds( &dc->bounds );
1543
1544     if ((flags & DCB_ACCUMULATE) && rect)
1545     {
1546         RECT rc = *rect;
1547
1548         lp_to_dp( dc, (POINT *)&rc, 2 );
1549         add_bounds_rect( &dc->bounds, &rc );
1550     }
1551
1552     if (flags & DCB_ENABLE) dc->bounds_enabled = TRUE;
1553     if (flags & DCB_DISABLE) dc->bounds_enabled = FALSE;
1554
1555     release_dc_ptr( dc );
1556     return ret;
1557 }
1558
1559
1560 /***********************************************************************
1561  *              GetRelAbs               (GDI32.@)
1562  */
1563 INT WINAPI GetRelAbs( HDC hdc, DWORD dwIgnore )
1564 {
1565     INT ret = 0;
1566     DC *dc = get_dc_ptr( hdc );
1567     if (dc)
1568     {
1569         ret = dc->relAbsMode;
1570         release_dc_ptr( dc );
1571     }
1572     return ret;
1573 }
1574
1575
1576
1577
1578 /***********************************************************************
1579  *              GetBkMode (GDI32.@)
1580  */
1581 INT WINAPI GetBkMode( HDC hdc )
1582 {
1583     INT ret = 0;
1584     DC * dc = get_dc_ptr( hdc );
1585     if (dc)
1586     {
1587         ret = dc->backgroundMode;
1588         release_dc_ptr( dc );
1589     }
1590     return ret;
1591 }
1592
1593
1594 /***********************************************************************
1595  *              SetBkMode (GDI32.@)
1596  */
1597 INT WINAPI SetBkMode( HDC hdc, INT mode )
1598 {
1599     INT ret = 0;
1600     DC *dc;
1601
1602     if ((mode <= 0) || (mode > BKMODE_LAST))
1603     {
1604         SetLastError(ERROR_INVALID_PARAMETER);
1605         return 0;
1606     }
1607     if ((dc = get_dc_ptr( hdc )))
1608     {
1609         PHYSDEV physdev = GET_DC_PHYSDEV( dc, pSetBkMode );
1610         mode = physdev->funcs->pSetBkMode( physdev, mode );
1611         if (mode)
1612         {
1613             ret = dc->backgroundMode;
1614             dc->backgroundMode = mode;
1615         }
1616         release_dc_ptr( dc );
1617     }
1618     return ret;
1619 }
1620
1621
1622 /***********************************************************************
1623  *              GetROP2 (GDI32.@)
1624  */
1625 INT WINAPI GetROP2( HDC hdc )
1626 {
1627     INT ret = 0;
1628     DC * dc = get_dc_ptr( hdc );
1629     if (dc)
1630     {
1631         ret = dc->ROPmode;
1632         release_dc_ptr( dc );
1633     }
1634     return ret;
1635 }
1636
1637
1638 /***********************************************************************
1639  *              SetROP2 (GDI32.@)
1640  */
1641 INT WINAPI SetROP2( HDC hdc, INT mode )
1642 {
1643     INT ret = 0;
1644     DC *dc;
1645
1646     if ((mode < R2_BLACK) || (mode > R2_WHITE))
1647     {
1648         SetLastError(ERROR_INVALID_PARAMETER);
1649         return 0;
1650     }
1651     if ((dc = get_dc_ptr( hdc )))
1652     {
1653         PHYSDEV physdev = GET_DC_PHYSDEV( dc, pSetROP2 );
1654         mode = physdev->funcs->pSetROP2( physdev, mode );
1655         if (mode)
1656         {
1657             ret = dc->ROPmode;
1658             dc->ROPmode = mode;
1659         }
1660         release_dc_ptr( dc );
1661     }
1662     return ret;
1663 }
1664
1665
1666 /***********************************************************************
1667  *              SetRelAbs (GDI32.@)
1668  */
1669 INT WINAPI SetRelAbs( HDC hdc, INT mode )
1670 {
1671     INT ret = 0;
1672     DC *dc;
1673
1674     if ((mode != ABSOLUTE) && (mode != RELATIVE))
1675     {
1676         SetLastError(ERROR_INVALID_PARAMETER);
1677         return 0;
1678     }
1679     if ((dc = get_dc_ptr( hdc )))
1680     {
1681         PHYSDEV physdev = GET_DC_PHYSDEV( dc, pSetRelAbs );
1682         mode = physdev->funcs->pSetRelAbs( physdev, mode );
1683         if (mode)
1684         {
1685             ret = dc->relAbsMode;
1686             dc->relAbsMode = mode;
1687         }
1688         release_dc_ptr( dc );
1689     }
1690     return ret;
1691 }
1692
1693
1694 /***********************************************************************
1695  *              GetPolyFillMode (GDI32.@)
1696  */
1697 INT WINAPI GetPolyFillMode( HDC hdc )
1698 {
1699     INT ret = 0;
1700     DC * dc = get_dc_ptr( hdc );
1701     if (dc)
1702     {
1703         ret = dc->polyFillMode;
1704         release_dc_ptr( dc );
1705     }
1706     return ret;
1707 }
1708
1709
1710 /***********************************************************************
1711  *              SetPolyFillMode (GDI32.@)
1712  */
1713 INT WINAPI SetPolyFillMode( HDC hdc, INT mode )
1714 {
1715     INT ret = 0;
1716     DC *dc;
1717
1718     if ((mode <= 0) || (mode > POLYFILL_LAST))
1719     {
1720         SetLastError(ERROR_INVALID_PARAMETER);
1721         return 0;
1722     }
1723     if ((dc = get_dc_ptr( hdc )))
1724     {
1725         PHYSDEV physdev = GET_DC_PHYSDEV( dc, pSetPolyFillMode );
1726         mode = physdev->funcs->pSetPolyFillMode( physdev, mode );
1727         if (mode)
1728         {
1729             ret = dc->polyFillMode;
1730             dc->polyFillMode = mode;
1731         }
1732         release_dc_ptr( dc );
1733     }
1734     return ret;
1735 }
1736
1737
1738 /***********************************************************************
1739  *              GetStretchBltMode (GDI32.@)
1740  */
1741 INT WINAPI GetStretchBltMode( HDC hdc )
1742 {
1743     INT ret = 0;
1744     DC * dc = get_dc_ptr( hdc );
1745     if (dc)
1746     {
1747         ret = dc->stretchBltMode;
1748         release_dc_ptr( dc );
1749     }
1750     return ret;
1751 }
1752
1753
1754 /***********************************************************************
1755  *              SetStretchBltMode (GDI32.@)
1756  */
1757 INT WINAPI SetStretchBltMode( HDC hdc, INT mode )
1758 {
1759     INT ret = 0;
1760     DC *dc;
1761
1762     if ((mode <= 0) || (mode > MAXSTRETCHBLTMODE))
1763     {
1764         SetLastError(ERROR_INVALID_PARAMETER);
1765         return 0;
1766     }
1767     if ((dc = get_dc_ptr( hdc )))
1768     {
1769         PHYSDEV physdev = GET_DC_PHYSDEV( dc, pSetStretchBltMode );
1770         mode = physdev->funcs->pSetStretchBltMode( physdev, mode );
1771         if (mode)
1772         {
1773             ret = dc->stretchBltMode;
1774             dc->stretchBltMode = mode;
1775         }
1776         release_dc_ptr( dc );
1777     }
1778     return ret;
1779 }
1780
1781
1782 /***********************************************************************
1783  *              GetMapMode (GDI32.@)
1784  */
1785 INT WINAPI GetMapMode( HDC hdc )
1786 {
1787     INT ret = 0;
1788     DC * dc = get_dc_ptr( hdc );
1789     if (dc)
1790     {
1791         ret = dc->MapMode;
1792         release_dc_ptr( dc );
1793     }
1794     return ret;
1795 }
1796
1797
1798 /***********************************************************************
1799  *              GetBrushOrgEx (GDI32.@)
1800  */
1801 BOOL WINAPI GetBrushOrgEx( HDC hdc, LPPOINT pt )
1802 {
1803     DC * dc = get_dc_ptr( hdc );
1804     if (!dc) return FALSE;
1805     *pt = dc->brush_org;
1806     release_dc_ptr( dc );
1807     return TRUE;
1808 }
1809
1810
1811 /***********************************************************************
1812  *              GetCurrentPositionEx (GDI32.@)
1813  */
1814 BOOL WINAPI GetCurrentPositionEx( HDC hdc, LPPOINT pt )
1815 {
1816     DC * dc = get_dc_ptr( hdc );
1817     if (!dc) return FALSE;
1818     *pt = dc->cur_pos;
1819     release_dc_ptr( dc );
1820     return TRUE;
1821 }
1822
1823
1824 /***********************************************************************
1825  *              GetViewportExtEx (GDI32.@)
1826  */
1827 BOOL WINAPI GetViewportExtEx( HDC hdc, LPSIZE size )
1828 {
1829     DC * dc = get_dc_ptr( hdc );
1830     if (!dc) return FALSE;
1831     *size = dc->vport_ext;
1832     release_dc_ptr( dc );
1833     return TRUE;
1834 }
1835
1836
1837 /***********************************************************************
1838  *              GetViewportOrgEx (GDI32.@)
1839  */
1840 BOOL WINAPI GetViewportOrgEx( HDC hdc, LPPOINT pt )
1841 {
1842     DC * dc = get_dc_ptr( hdc );
1843     if (!dc) return FALSE;
1844     *pt = dc->vport_org;
1845     release_dc_ptr( dc );
1846     return TRUE;
1847 }
1848
1849
1850 /***********************************************************************
1851  *              GetWindowExtEx (GDI32.@)
1852  */
1853 BOOL WINAPI GetWindowExtEx( HDC hdc, LPSIZE size )
1854 {
1855     DC * dc = get_dc_ptr( hdc );
1856     if (!dc) return FALSE;
1857     *size = dc->wnd_ext;
1858     release_dc_ptr( dc );
1859     return TRUE;
1860 }
1861
1862
1863 /***********************************************************************
1864  *              GetWindowOrgEx (GDI32.@)
1865  */
1866 BOOL WINAPI GetWindowOrgEx( HDC hdc, LPPOINT pt )
1867 {
1868     DC * dc = get_dc_ptr( hdc );
1869     if (!dc) return FALSE;
1870     *pt = dc->wnd_org;
1871     release_dc_ptr( dc );
1872     return TRUE;
1873 }
1874
1875
1876 /***********************************************************************
1877  *           GetLayout    (GDI32.@)
1878  *
1879  * Gets left->right or right->left text layout flags of a dc.
1880  *
1881  */
1882 DWORD WINAPI GetLayout(HDC hdc)
1883 {
1884     DWORD layout = GDI_ERROR;
1885
1886     DC * dc = get_dc_ptr( hdc );
1887     if (dc)
1888     {
1889         layout = dc->layout;
1890         release_dc_ptr( dc );
1891     }
1892
1893     TRACE("hdc : %p, layout : %08x\n", hdc, layout);
1894
1895     return layout;
1896 }
1897
1898 /***********************************************************************
1899  *           SetLayout    (GDI32.@)
1900  *
1901  * Sets left->right or right->left text layout flags of a dc.
1902  *
1903  */
1904 DWORD WINAPI SetLayout(HDC hdc, DWORD layout)
1905 {
1906     DWORD oldlayout = GDI_ERROR;
1907
1908     DC * dc = get_dc_ptr( hdc );
1909     if (dc)
1910     {
1911         PHYSDEV physdev = GET_DC_PHYSDEV( dc, pSetLayout );
1912         layout = physdev->funcs->pSetLayout( physdev, layout );
1913         if (layout != GDI_ERROR)
1914         {
1915             oldlayout = dc->layout;
1916             dc->layout = layout;
1917             if (layout != oldlayout)
1918             {
1919                 if (layout & LAYOUT_RTL) dc->MapMode = MM_ANISOTROPIC;
1920                 DC_UpdateXforms( dc );
1921             }
1922         }
1923         release_dc_ptr( dc );
1924     }
1925
1926     TRACE("hdc : %p, old layout : %08x, new layout : %08x\n", hdc, oldlayout, layout);
1927
1928     return oldlayout;
1929 }
1930
1931 /***********************************************************************
1932  *           GetDCBrushColor    (GDI32.@)
1933  */
1934 COLORREF WINAPI GetDCBrushColor(HDC hdc)
1935 {
1936     DC *dc;
1937     COLORREF dcBrushColor = CLR_INVALID;
1938
1939     TRACE("hdc(%p)\n", hdc);
1940
1941     dc = get_dc_ptr( hdc );
1942     if (dc)
1943     {
1944         dcBrushColor = dc->dcBrushColor;
1945         release_dc_ptr( dc );
1946     }
1947
1948     return dcBrushColor;
1949 }
1950
1951 /***********************************************************************
1952  *           SetDCBrushColor    (GDI32.@)
1953  */
1954 COLORREF WINAPI SetDCBrushColor(HDC hdc, COLORREF crColor)
1955 {
1956     DC *dc;
1957     COLORREF oldClr = CLR_INVALID;
1958
1959     TRACE("hdc(%p) crColor(%08x)\n", hdc, crColor);
1960
1961     dc = get_dc_ptr( hdc );
1962     if (dc)
1963     {
1964         PHYSDEV physdev = GET_DC_PHYSDEV( dc, pSetDCBrushColor );
1965         crColor = physdev->funcs->pSetDCBrushColor( physdev, crColor );
1966         if (crColor != CLR_INVALID)
1967         {
1968             oldClr = dc->dcBrushColor;
1969             dc->dcBrushColor = crColor;
1970         }
1971         release_dc_ptr( dc );
1972     }
1973
1974     return oldClr;
1975 }
1976
1977 /***********************************************************************
1978  *           GetDCPenColor    (GDI32.@)
1979  */
1980 COLORREF WINAPI GetDCPenColor(HDC hdc)
1981 {
1982     DC *dc;
1983     COLORREF dcPenColor = CLR_INVALID;
1984
1985     TRACE("hdc(%p)\n", hdc);
1986
1987     dc = get_dc_ptr( hdc );
1988     if (dc)
1989     {
1990         dcPenColor = dc->dcPenColor;
1991         release_dc_ptr( dc );
1992     }
1993
1994     return dcPenColor;
1995 }
1996
1997 /***********************************************************************
1998  *           SetDCPenColor    (GDI32.@)
1999  */
2000 COLORREF WINAPI SetDCPenColor(HDC hdc, COLORREF crColor)
2001 {
2002     DC *dc;
2003     COLORREF oldClr = CLR_INVALID;
2004
2005     TRACE("hdc(%p) crColor(%08x)\n", hdc, crColor);
2006
2007     dc = get_dc_ptr( hdc );
2008     if (dc)
2009     {
2010         PHYSDEV physdev = GET_DC_PHYSDEV( dc, pSetDCPenColor );
2011         crColor = physdev->funcs->pSetDCPenColor( physdev, crColor );
2012         if (crColor != CLR_INVALID)
2013         {
2014             oldClr = dc->dcPenColor;
2015             dc->dcPenColor = crColor;
2016         }
2017         release_dc_ptr( dc );
2018     }
2019
2020     return oldClr;
2021 }
2022
2023 /***********************************************************************
2024  *           CancelDC    (GDI32.@)
2025  */
2026 BOOL WINAPI CancelDC(HDC hdc)
2027 {
2028     FIXME("stub\n");
2029     return TRUE;
2030 }
2031
2032 /*******************************************************************
2033  *      GetMiterLimit [GDI32.@]
2034  *
2035  *
2036  */
2037 BOOL WINAPI GetMiterLimit(HDC hdc, PFLOAT peLimit)
2038 {
2039     BOOL bRet = FALSE;
2040     DC *dc;
2041
2042     TRACE("(%p,%p)\n", hdc, peLimit);
2043
2044     dc = get_dc_ptr( hdc );
2045     if (dc)
2046     {
2047         if (peLimit)
2048             *peLimit = dc->miterLimit;
2049
2050         release_dc_ptr( dc );
2051         bRet = TRUE;
2052     }
2053     return bRet;
2054 }
2055
2056 /*******************************************************************
2057  *      SetMiterLimit [GDI32.@]
2058  *
2059  *
2060  */
2061 BOOL WINAPI SetMiterLimit(HDC hdc, FLOAT eNewLimit, PFLOAT peOldLimit)
2062 {
2063     BOOL bRet = FALSE;
2064     DC *dc;
2065
2066     TRACE("(%p,%f,%p)\n", hdc, eNewLimit, peOldLimit);
2067
2068     dc = get_dc_ptr( hdc );
2069     if (dc)
2070     {
2071         if (peOldLimit)
2072             *peOldLimit = dc->miterLimit;
2073         dc->miterLimit = eNewLimit;
2074         release_dc_ptr( dc );
2075         bRet = TRUE;
2076     }
2077     return bRet;
2078 }
2079
2080 /*******************************************************************
2081  *      GdiIsMetaPrintDC [GDI32.@]
2082  */
2083 BOOL WINAPI GdiIsMetaPrintDC(HDC hdc)
2084 {
2085     FIXME("%p\n", hdc);
2086     return FALSE;
2087 }
2088
2089 /*******************************************************************
2090  *      GdiIsMetaFileDC [GDI32.@]
2091  */
2092 BOOL WINAPI GdiIsMetaFileDC(HDC hdc)
2093 {
2094     TRACE("%p\n", hdc);
2095
2096     switch( GetObjectType( hdc ) )
2097     {
2098     case OBJ_METADC:
2099     case OBJ_ENHMETADC:
2100         return TRUE;
2101     }
2102     return FALSE;
2103 }
2104
2105 /*******************************************************************
2106  *      GdiIsPlayMetafileDC [GDI32.@]
2107  */
2108 BOOL WINAPI GdiIsPlayMetafileDC(HDC hdc)
2109 {
2110     FIXME("%p\n", hdc);
2111     return FALSE;
2112 }