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