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