2 * GDI Device Context functions
4 * Copyright 1993 Alexandre Julliard
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.
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.
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
33 #include "gdi_private.h"
34 #include "wine/unicode.h"
35 #include "wine/debug.h"
37 WINE_DEFAULT_DEBUG_CHANNEL(dc);
39 static const WCHAR displayW[] = { 'd','i','s','p','l','a','y',0 };
41 static BOOL DC_DeleteObject( HGDIOBJ handle );
43 static const struct gdi_obj_funcs dc_funcs =
45 NULL, /* pSelectObject */
46 NULL, /* pGetObjectA */
47 NULL, /* pGetObjectW */
48 NULL, /* pUnrealizeObject */
49 DC_DeleteObject /* pDeleteObject */
53 static inline DC *get_dc_obj( HDC hdc )
55 DC *dc = GDI_GetObjPtr( hdc, 0 );
58 switch (GetObjectType( hdc ))
66 GDI_ReleaseObj( hdc );
67 SetLastError( ERROR_INVALID_HANDLE );
73 /***********************************************************************
74 * set_initial_dc_state
76 static void set_initial_dc_state( DC *dc )
86 dc->miterLimit = 10.0f; /* 10.0 is the default, from MSDN */
88 dc->font_code_page = CP_ACP;
89 dc->ROPmode = R2_COPYPEN;
90 dc->polyFillMode = ALTERNATE;
91 dc->stretchBltMode = BLACKONWHITE;
92 dc->relAbsMode = ABSOLUTE;
93 dc->backgroundMode = OPAQUE;
94 dc->backgroundColor = RGB( 255, 255, 255 );
95 dc->dcBrushColor = RGB( 255, 255, 255 );
96 dc->dcPenColor = RGB( 0, 0, 0 );
97 dc->textColor = RGB( 0, 0, 0 );
101 dc->textAlign = TA_LEFT | TA_TOP | TA_NOUPDATECP;
105 dc->MapMode = MM_TEXT;
106 dc->GraphicsMode = GM_COMPATIBLE;
109 dc->ArcDirection = AD_COUNTERCLOCKWISE;
110 dc->xformWorld2Wnd.eM11 = 1.0f;
111 dc->xformWorld2Wnd.eM12 = 0.0f;
112 dc->xformWorld2Wnd.eM21 = 0.0f;
113 dc->xformWorld2Wnd.eM22 = 1.0f;
114 dc->xformWorld2Wnd.eDx = 0.0f;
115 dc->xformWorld2Wnd.eDy = 0.0f;
116 dc->xformWorld2Vport = dc->xformWorld2Wnd;
117 dc->xformVport2World = dc->xformWorld2Wnd;
118 dc->vport2WorldValid = TRUE;
120 reset_bounds( &dc->bounds );
123 /***********************************************************************
126 DC *alloc_dc_ptr( WORD magic )
130 if (!(dc = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*dc) ))) return NULL;
132 dc->nulldrv.funcs = &null_driver;
133 dc->physDev = &dc->nulldrv;
134 dc->module = gdi32_module;
135 dc->thread = GetCurrentThreadId();
137 dc->hPen = GDI_inc_ref_count( GetStockObject( BLACK_PEN ));
138 dc->hBrush = GDI_inc_ref_count( GetStockObject( WHITE_BRUSH ));
139 dc->hFont = GDI_inc_ref_count( GetStockObject( SYSTEM_FONT ));
140 dc->hPalette = GetStockObject( DEFAULT_PALETTE );
142 set_initial_dc_state( dc );
144 if (!(dc->hSelf = alloc_gdi_handle( dc, magic, &dc_funcs )))
146 HeapFree( GetProcessHeap(), 0, dc );
149 dc->nulldrv.hdc = dc->hSelf;
151 if (font_driver && !font_driver->pCreateDC( &dc->physDev, NULL, NULL, NULL, NULL ))
161 /***********************************************************************
164 static void free_dc_state( DC *dc )
166 if (dc->hClipRgn) DeleteObject( dc->hClipRgn );
167 if (dc->hMetaRgn) DeleteObject( dc->hMetaRgn );
168 if (dc->hVisRgn) DeleteObject( dc->hVisRgn );
169 if (dc->region) DeleteObject( dc->region );
170 if (dc->path) free_gdi_path( dc->path );
171 HeapFree( GetProcessHeap(), 0, dc );
175 /***********************************************************************
178 void free_dc_ptr( DC *dc )
180 assert( dc->refcount == 1 );
182 while (dc->physDev != &dc->nulldrv)
184 PHYSDEV physdev = dc->physDev;
185 dc->physDev = physdev->next;
186 physdev->funcs->pDeleteDC( physdev );
188 GDI_dec_ref_count( dc->hPen );
189 GDI_dec_ref_count( dc->hBrush );
190 GDI_dec_ref_count( dc->hFont );
191 if (dc->hBitmap) GDI_dec_ref_count( dc->hBitmap );
192 free_gdi_handle( dc->hSelf );
197 /***********************************************************************
200 * Retrieve a DC pointer but release the GDI lock.
202 DC *get_dc_ptr( HDC hdc )
204 DC *dc = get_dc_obj( hdc );
205 if (!dc) return NULL;
207 if (!InterlockedCompareExchange( &dc->refcount, 1, 0 ))
209 dc->thread = GetCurrentThreadId();
211 else if (dc->thread != GetCurrentThreadId())
213 WARN( "dc %p belongs to thread %04x\n", hdc, dc->thread );
214 GDI_ReleaseObj( hdc );
217 else InterlockedIncrement( &dc->refcount );
219 GDI_ReleaseObj( hdc );
224 /***********************************************************************
227 void release_dc_ptr( DC *dc )
232 ref = InterlockedDecrement( &dc->refcount );
234 if (ref) dc->thread = GetCurrentThreadId(); /* we still own it */
238 /***********************************************************************
241 * Make sure the DC vis region is up to date.
242 * This function may call up to USER so the GDI lock should _not_
243 * be held when calling it.
245 void update_dc( DC *dc )
247 if (InterlockedExchange( &dc->dirty, 0 ) && dc->hookProc)
248 dc->hookProc( dc->hSelf, DCHC_INVALIDVISRGN, dc->dwHookData, 0 );
252 /***********************************************************************
255 static BOOL DC_DeleteObject( HGDIOBJ handle )
257 return DeleteDC( handle );
261 /***********************************************************************
264 * Setup device-specific DC values for a newly created DC.
266 void DC_InitDC( DC* dc )
268 PHYSDEV physdev = GET_DC_PHYSDEV( dc, pRealizeDefaultPalette );
269 physdev->funcs->pRealizeDefaultPalette( physdev );
270 SetTextColor( dc->hSelf, dc->textColor );
271 SetBkColor( dc->hSelf, dc->backgroundColor );
272 SelectObject( dc->hSelf, dc->hPen );
273 SelectObject( dc->hSelf, dc->hBrush );
274 SelectObject( dc->hSelf, dc->hFont );
275 update_dc_clipping( dc );
276 SetVirtualResolution( dc->hSelf, 0, 0, 0, 0 );
277 physdev = GET_DC_PHYSDEV( dc, pSetBoundsRect );
278 physdev->funcs->pSetBoundsRect( physdev, &dc->bounds, dc->bounds_enabled ? DCB_ENABLE : DCB_DISABLE );
282 /***********************************************************************
285 * Computes the inverse of the transformation xformSrc and stores it to
286 * xformDest. Returns TRUE if successful or FALSE if the xformSrc matrix
289 static BOOL DC_InvertXform( const XFORM *xformSrc, XFORM *xformDest )
293 determinant = xformSrc->eM11*xformSrc->eM22 -
294 xformSrc->eM12*xformSrc->eM21;
295 if (determinant > -1e-12 && determinant < 1e-12)
298 xformDest->eM11 = xformSrc->eM22 / determinant;
299 xformDest->eM12 = -xformSrc->eM12 / determinant;
300 xformDest->eM21 = -xformSrc->eM21 / determinant;
301 xformDest->eM22 = xformSrc->eM11 / determinant;
302 xformDest->eDx = -xformSrc->eDx * xformDest->eM11 -
303 xformSrc->eDy * xformDest->eM21;
304 xformDest->eDy = -xformSrc->eDx * xformDest->eM12 -
305 xformSrc->eDy * xformDest->eM22;
310 /* Construct a transformation to do the window-to-viewport conversion */
311 static void construct_window_to_viewport(DC *dc, XFORM *xform)
313 double scaleX, scaleY;
314 scaleX = (double)dc->vportExtX / (double)dc->wndExtX;
315 scaleY = (double)dc->vportExtY / (double)dc->wndExtY;
317 if (dc->layout & LAYOUT_RTL) scaleX = -scaleX;
318 xform->eM11 = scaleX;
321 xform->eM22 = scaleY;
322 xform->eDx = (double)dc->vportOrgX - scaleX * (double)dc->wndOrgX;
323 xform->eDy = (double)dc->vportOrgY - scaleY * (double)dc->wndOrgY;
324 if (dc->layout & LAYOUT_RTL) xform->eDx = dc->vis_rect.right - dc->vis_rect.left - 1 - xform->eDx;
327 /***********************************************************************
330 * Updates the xformWorld2Vport, xformVport2World and vport2WorldValid
331 * fields of the specified DC by creating a transformation that
332 * represents the current mapping mode and combining it with the DC's
333 * world transform. This function should be called whenever the
334 * parameters associated with the mapping mode (window and viewport
335 * extents and origins) or the world transform change.
337 void DC_UpdateXforms( DC *dc )
339 XFORM xformWnd2Vport, oldworld2vport;
341 construct_window_to_viewport(dc, &xformWnd2Vport);
343 oldworld2vport = dc->xformWorld2Vport;
344 /* Combine with the world transformation */
345 CombineTransform( &dc->xformWorld2Vport, &dc->xformWorld2Wnd,
348 /* Create inverse of world-to-viewport transformation */
349 dc->vport2WorldValid = DC_InvertXform( &dc->xformWorld2Vport,
350 &dc->xformVport2World );
352 /* Reselect the font and pen back into the dc so that the size
354 if (memcmp(&oldworld2vport, &dc->xformWorld2Vport, sizeof(oldworld2vport)) &&
355 !GdiIsMetaFileDC(dc->hSelf))
357 SelectObject(dc->hSelf, GetCurrentObject(dc->hSelf, OBJ_FONT));
358 SelectObject(dc->hSelf, GetCurrentObject(dc->hSelf, OBJ_PEN));
363 /***********************************************************************
366 INT nulldrv_SaveDC( PHYSDEV dev )
368 DC *newdc, *dc = get_nulldrv_dc( dev );
370 if (!(newdc = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*newdc )))) return 0;
371 newdc->layout = dc->layout;
372 newdc->hPen = dc->hPen;
373 newdc->hBrush = dc->hBrush;
374 newdc->hFont = dc->hFont;
375 newdc->hBitmap = dc->hBitmap;
376 newdc->hPalette = dc->hPalette;
377 newdc->ROPmode = dc->ROPmode;
378 newdc->polyFillMode = dc->polyFillMode;
379 newdc->stretchBltMode = dc->stretchBltMode;
380 newdc->relAbsMode = dc->relAbsMode;
381 newdc->backgroundMode = dc->backgroundMode;
382 newdc->backgroundColor = dc->backgroundColor;
383 newdc->textColor = dc->textColor;
384 newdc->dcBrushColor = dc->dcBrushColor;
385 newdc->dcPenColor = dc->dcPenColor;
386 newdc->brushOrgX = dc->brushOrgX;
387 newdc->brushOrgY = dc->brushOrgY;
388 newdc->mapperFlags = dc->mapperFlags;
389 newdc->textAlign = dc->textAlign;
390 newdc->charExtra = dc->charExtra;
391 newdc->breakExtra = dc->breakExtra;
392 newdc->breakRem = dc->breakRem;
393 newdc->MapMode = dc->MapMode;
394 newdc->GraphicsMode = dc->GraphicsMode;
395 newdc->CursPosX = dc->CursPosX;
396 newdc->CursPosY = dc->CursPosY;
397 newdc->ArcDirection = dc->ArcDirection;
398 newdc->xformWorld2Wnd = dc->xformWorld2Wnd;
399 newdc->xformWorld2Vport = dc->xformWorld2Vport;
400 newdc->xformVport2World = dc->xformVport2World;
401 newdc->vport2WorldValid = dc->vport2WorldValid;
402 newdc->wndOrgX = dc->wndOrgX;
403 newdc->wndOrgY = dc->wndOrgY;
404 newdc->wndExtX = dc->wndExtX;
405 newdc->wndExtY = dc->wndExtY;
406 newdc->vportOrgX = dc->vportOrgX;
407 newdc->vportOrgY = dc->vportOrgY;
408 newdc->vportExtX = dc->vportExtX;
409 newdc->vportExtY = dc->vportExtY;
410 newdc->virtual_res = dc->virtual_res;
411 newdc->virtual_size = dc->virtual_size;
413 /* Get/SetDCState() don't change hVisRgn field ("Undoc. Windows" p.559). */
417 newdc->hClipRgn = CreateRectRgn( 0, 0, 0, 0 );
418 CombineRgn( newdc->hClipRgn, dc->hClipRgn, 0, RGN_COPY );
422 newdc->hMetaRgn = CreateRectRgn( 0, 0, 0, 0 );
423 CombineRgn( newdc->hMetaRgn, dc->hMetaRgn, 0, RGN_COPY );
426 if (!PATH_SavePath( newdc, dc ))
428 release_dc_ptr( dc );
429 free_dc_state( newdc );
433 newdc->saved_dc = dc->saved_dc;
434 dc->saved_dc = newdc;
435 return ++dc->saveLevel;
439 /***********************************************************************
442 BOOL nulldrv_RestoreDC( PHYSDEV dev, INT level )
444 DC *dcs, *first_dcs, *dc = get_nulldrv_dc( dev );
447 /* find the state level to restore */
449 if (abs(level) > dc->saveLevel || level == 0) return FALSE;
450 if (level < 0) level = dc->saveLevel + level + 1;
451 first_dcs = dc->saved_dc;
452 for (dcs = first_dcs, save_level = dc->saveLevel; save_level > level; save_level--)
455 /* restore the state */
457 if (!PATH_RestorePath( dc, dcs )) return FALSE;
459 dc->layout = dcs->layout;
460 dc->ROPmode = dcs->ROPmode;
461 dc->polyFillMode = dcs->polyFillMode;
462 dc->stretchBltMode = dcs->stretchBltMode;
463 dc->relAbsMode = dcs->relAbsMode;
464 dc->backgroundMode = dcs->backgroundMode;
465 dc->backgroundColor = dcs->backgroundColor;
466 dc->textColor = dcs->textColor;
467 dc->dcBrushColor = dcs->dcBrushColor;
468 dc->dcPenColor = dcs->dcPenColor;
469 dc->brushOrgX = dcs->brushOrgX;
470 dc->brushOrgY = dcs->brushOrgY;
471 dc->mapperFlags = dcs->mapperFlags;
472 dc->textAlign = dcs->textAlign;
473 dc->charExtra = dcs->charExtra;
474 dc->breakExtra = dcs->breakExtra;
475 dc->breakRem = dcs->breakRem;
476 dc->MapMode = dcs->MapMode;
477 dc->GraphicsMode = dcs->GraphicsMode;
478 dc->CursPosX = dcs->CursPosX;
479 dc->CursPosY = dcs->CursPosY;
480 dc->ArcDirection = dcs->ArcDirection;
481 dc->xformWorld2Wnd = dcs->xformWorld2Wnd;
482 dc->xformWorld2Vport = dcs->xformWorld2Vport;
483 dc->xformVport2World = dcs->xformVport2World;
484 dc->vport2WorldValid = dcs->vport2WorldValid;
485 dc->wndOrgX = dcs->wndOrgX;
486 dc->wndOrgY = dcs->wndOrgY;
487 dc->wndExtX = dcs->wndExtX;
488 dc->wndExtY = dcs->wndExtY;
489 dc->vportOrgX = dcs->vportOrgX;
490 dc->vportOrgY = dcs->vportOrgY;
491 dc->vportExtX = dcs->vportExtX;
492 dc->vportExtY = dcs->vportExtY;
493 dc->virtual_res = dcs->virtual_res;
494 dc->virtual_size = dcs->virtual_size;
498 if (!dc->hClipRgn) dc->hClipRgn = CreateRectRgn( 0, 0, 0, 0 );
499 CombineRgn( dc->hClipRgn, dcs->hClipRgn, 0, RGN_COPY );
503 if (dc->hClipRgn) DeleteObject( dc->hClipRgn );
508 if (!dc->hMetaRgn) dc->hMetaRgn = CreateRectRgn( 0, 0, 0, 0 );
509 CombineRgn( dc->hMetaRgn, dcs->hMetaRgn, 0, RGN_COPY );
513 if (dc->hMetaRgn) DeleteObject( dc->hMetaRgn );
516 DC_UpdateXforms( dc );
517 update_dc_clipping( dc );
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 );
527 dc->saved_dc = dcs->saved_dc;
529 dc->saveLevel = save_level - 1;
531 /* now destroy all the saved DCs */
535 DC *next = first_dcs->saved_dc;
536 free_dc_state( first_dcs );
543 /***********************************************************************
546 static BOOL reset_dc_state( HDC hdc )
550 if (!(dc = get_dc_ptr( hdc ))) return FALSE;
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 );
563 if (dc->hClipRgn) DeleteObject( dc->hClipRgn );
564 if (dc->hMetaRgn) DeleteObject( dc->hMetaRgn );
567 update_dc_clipping( dc );
569 for (dcs = dc->saved_dc; dcs; dcs = next)
571 next = dcs->saved_dc;
572 free_dc_state( dcs );
576 release_dc_ptr( dc );
581 /***********************************************************************
584 INT WINAPI SaveDC( HDC hdc )
589 if ((dc = get_dc_ptr( hdc )))
591 PHYSDEV physdev = GET_DC_PHYSDEV( dc, pSaveDC );
592 ret = physdev->funcs->pSaveDC( physdev );
593 release_dc_ptr( dc );
599 /***********************************************************************
600 * RestoreDC (GDI32.@)
602 BOOL WINAPI RestoreDC( HDC hdc, INT level )
606 BOOL success = FALSE;
608 TRACE("%p %d\n", hdc, level );
609 if ((dc = get_dc_ptr( hdc )))
612 physdev = GET_DC_PHYSDEV( dc, pRestoreDC );
613 success = physdev->funcs->pRestoreDC( physdev, level );
614 release_dc_ptr( dc );
620 /***********************************************************************
621 * CreateDCW (GDI32.@)
623 HDC WINAPI CreateDCW( LPCWSTR driver, LPCWSTR device, LPCWSTR output,
624 const DEVMODEW *initData )
628 const struct gdi_dc_funcs *funcs;
634 if (!device || !DRIVER_GetDriverName( device, buf, 300 ))
638 ERR( "no device found for %s\n", debugstr_w(device) );
641 strcpyW(buf, driver);
644 if (!(funcs = DRIVER_load_driver( buf, &module )))
646 ERR( "no driver found for %s\n", debugstr_w(buf) );
649 if (!(dc = alloc_dc_ptr( OBJ_DC ))) return 0;
653 dc->hBitmap = GDI_inc_ref_count( GetStockObject( DEFAULT_BITMAP ));
655 TRACE("(driver=%s, device=%s, output=%s): returning %p\n",
656 debugstr_w(driver), debugstr_w(device), debugstr_w(output), dc->hSelf );
658 if (funcs->pCreateDC)
660 if (!funcs->pCreateDC( &dc->physDev, buf, device, output, initData ))
662 WARN("creation aborted by device\n" );
668 dc->vis_rect.left = 0;
669 dc->vis_rect.top = 0;
670 dc->vis_rect.right = GetDeviceCaps( hdc, DESKTOPHORZRES );
671 dc->vis_rect.bottom = GetDeviceCaps( hdc, DESKTOPVERTRES );
674 release_dc_ptr( dc );
679 /***********************************************************************
680 * CreateDCA (GDI32.@)
682 HDC WINAPI CreateDCA( LPCSTR driver, LPCSTR device, LPCSTR output,
683 const DEVMODEA *initData )
685 UNICODE_STRING driverW, deviceW, outputW;
689 if (driver) RtlCreateUnicodeStringFromAsciiz(&driverW, driver);
690 else driverW.Buffer = NULL;
692 if (device) RtlCreateUnicodeStringFromAsciiz(&deviceW, device);
693 else deviceW.Buffer = NULL;
695 if (output) RtlCreateUnicodeStringFromAsciiz(&outputW, output);
696 else outputW.Buffer = NULL;
701 /* don't convert initData for DISPLAY driver, it's not used */
702 if (!driverW.Buffer || strcmpiW( driverW.Buffer, displayW ))
703 initDataW = GdiConvertToDevmodeW(initData);
706 ret = CreateDCW( driverW.Buffer, deviceW.Buffer, outputW.Buffer, initDataW );
708 RtlFreeUnicodeString(&driverW);
709 RtlFreeUnicodeString(&deviceW);
710 RtlFreeUnicodeString(&outputW);
711 HeapFree(GetProcessHeap(), 0, initDataW);
716 /***********************************************************************
717 * CreateICA (GDI32.@)
719 HDC WINAPI CreateICA( LPCSTR driver, LPCSTR device, LPCSTR output,
720 const DEVMODEA* initData )
722 /* Nothing special yet for ICs */
723 return CreateDCA( driver, device, output, initData );
727 /***********************************************************************
728 * CreateICW (GDI32.@)
730 HDC WINAPI CreateICW( LPCWSTR driver, LPCWSTR device, LPCWSTR output,
731 const DEVMODEW* initData )
733 /* Nothing special yet for ICs */
734 return CreateDCW( driver, device, output, initData );
738 /***********************************************************************
739 * CreateCompatibleDC (GDI32.@)
741 HDC WINAPI CreateCompatibleDC( HDC hdc )
745 const struct gdi_dc_funcs *funcs = &null_driver;
746 PHYSDEV physDev = NULL;
752 if (!(origDC = get_dc_ptr( hdc ))) return 0;
753 physDev = GET_DC_PHYSDEV( origDC, pCreateCompatibleDC );
754 funcs = physDev->funcs;
755 release_dc_ptr( origDC );
758 if (!(dc = alloc_dc_ptr( OBJ_MEMDC ))) return 0;
760 TRACE("(%p): returning %p\n", hdc, dc->hSelf );
762 dc->hBitmap = GDI_inc_ref_count( GetStockObject( DEFAULT_BITMAP ));
763 dc->vis_rect.left = 0;
764 dc->vis_rect.top = 0;
765 dc->vis_rect.right = 1;
766 dc->vis_rect.bottom = 1;
767 dc->device_rect = dc->vis_rect;
771 if (!funcs->pCreateCompatibleDC( physDev, &dc->physDev ))
773 WARN("creation aborted by device\n");
778 if (!dib_driver.pCreateDC( &dc->physDev, NULL, NULL, NULL, NULL ))
783 physDev = GET_DC_PHYSDEV( dc, pSelectBitmap );
784 physDev->funcs->pSelectBitmap( physDev, dc->hBitmap );
787 release_dc_ptr( dc );
792 /***********************************************************************
795 BOOL WINAPI DeleteDC( HDC hdc )
803 if (!(dc = get_dc_ptr( hdc ))) return FALSE;
804 if (dc->refcount != 1)
806 FIXME( "not deleting busy DC %p refcount %u\n", dc->hSelf, dc->refcount );
807 release_dc_ptr( dc );
811 /* Call hook procedure to check whether is it OK to delete this DC */
812 if (dc->hookProc && !dc->hookProc( hdc, DCHC_DELETEDC, dc->dwHookData, 0 ))
814 release_dc_ptr( dc );
817 reset_dc_state( hdc );
823 /***********************************************************************
826 HDC WINAPI ResetDCW( HDC hdc, const DEVMODEW *devmode )
831 if ((dc = get_dc_ptr( hdc )))
833 PHYSDEV physdev = GET_DC_PHYSDEV( dc, pResetDC );
834 ret = physdev->funcs->pResetDC( physdev, devmode );
835 if (ret) /* reset the visible region */
838 dc->vis_rect.left = 0;
839 dc->vis_rect.top = 0;
840 dc->vis_rect.right = GetDeviceCaps( hdc, DESKTOPHORZRES );
841 dc->vis_rect.bottom = GetDeviceCaps( hdc, DESKTOPVERTRES );
842 if (dc->hVisRgn) DeleteObject( dc->hVisRgn );
844 update_dc_clipping( dc );
846 release_dc_ptr( dc );
852 /***********************************************************************
855 HDC WINAPI ResetDCA( HDC hdc, const DEVMODEA *devmode )
860 if (devmode) devmodeW = GdiConvertToDevmodeW(devmode);
861 else devmodeW = NULL;
863 ret = ResetDCW(hdc, devmodeW);
865 HeapFree(GetProcessHeap(), 0, devmodeW);
870 /***********************************************************************
871 * GetDeviceCaps (GDI32.@)
873 INT WINAPI GetDeviceCaps( HDC hdc, INT cap )
878 if ((dc = get_dc_ptr( hdc )))
880 PHYSDEV physdev = GET_DC_PHYSDEV( dc, pGetDeviceCaps );
881 ret = physdev->funcs->pGetDeviceCaps( physdev, cap );
882 release_dc_ptr( dc );
888 /***********************************************************************
889 * GetBkColor (GDI32.@)
891 COLORREF WINAPI GetBkColor( HDC hdc )
894 DC * dc = get_dc_ptr( hdc );
897 ret = dc->backgroundColor;
898 release_dc_ptr( dc );
904 /***********************************************************************
905 * SetBkColor (GDI32.@)
907 COLORREF WINAPI SetBkColor( HDC hdc, COLORREF color )
909 COLORREF ret = CLR_INVALID;
910 DC * dc = get_dc_ptr( hdc );
912 TRACE("hdc=%p color=0x%08x\n", hdc, color);
916 PHYSDEV physdev = GET_DC_PHYSDEV( dc, pSetBkColor );
917 ret = dc->backgroundColor;
918 dc->backgroundColor = physdev->funcs->pSetBkColor( physdev, color );
919 release_dc_ptr( dc );
925 /***********************************************************************
926 * GetTextColor (GDI32.@)
928 COLORREF WINAPI GetTextColor( HDC hdc )
931 DC * dc = get_dc_ptr( hdc );
935 release_dc_ptr( dc );
941 /***********************************************************************
942 * SetTextColor (GDI32.@)
944 COLORREF WINAPI SetTextColor( HDC hdc, COLORREF color )
946 COLORREF ret = CLR_INVALID;
947 DC * dc = get_dc_ptr( hdc );
949 TRACE(" hdc=%p color=0x%08x\n", hdc, color);
953 PHYSDEV physdev = GET_DC_PHYSDEV( dc, pSetTextColor );
955 dc->textColor = physdev->funcs->pSetTextColor( physdev, color );
956 release_dc_ptr( dc );
962 /***********************************************************************
963 * GetTextAlign (GDI32.@)
965 UINT WINAPI GetTextAlign( HDC hdc )
968 DC * dc = get_dc_ptr( hdc );
972 release_dc_ptr( dc );
978 /***********************************************************************
979 * SetTextAlign (GDI32.@)
981 UINT WINAPI SetTextAlign( HDC hdc, UINT align )
983 UINT ret = GDI_ERROR;
984 DC *dc = get_dc_ptr( hdc );
986 TRACE("hdc=%p align=%d\n", hdc, align);
990 PHYSDEV physdev = GET_DC_PHYSDEV( dc, pSetTextAlign );
991 align = physdev->funcs->pSetTextAlign( physdev, align );
992 if (align != GDI_ERROR)
995 dc->textAlign = align;
997 release_dc_ptr( dc );
1002 /***********************************************************************
1003 * GetDCOrgEx (GDI32.@)
1005 BOOL WINAPI GetDCOrgEx( HDC hDC, LPPOINT lpp )
1009 if (!lpp) return FALSE;
1010 if (!(dc = get_dc_ptr( hDC ))) return FALSE;
1011 lpp->x = dc->vis_rect.left;
1012 lpp->y = dc->vis_rect.top;
1013 release_dc_ptr( dc );
1018 /***********************************************************************
1019 * GetGraphicsMode (GDI32.@)
1021 INT WINAPI GetGraphicsMode( HDC hdc )
1024 DC * dc = get_dc_ptr( hdc );
1027 ret = dc->GraphicsMode;
1028 release_dc_ptr( dc );
1034 /***********************************************************************
1035 * SetGraphicsMode (GDI32.@)
1037 INT WINAPI SetGraphicsMode( HDC hdc, INT mode )
1040 DC *dc = get_dc_ptr( hdc );
1042 /* One would think that setting the graphics mode to GM_COMPATIBLE
1043 * would also reset the world transformation matrix to the unity
1044 * matrix. However, in Windows, this is not the case. This doesn't
1045 * make a lot of sense to me, but that's the way it is.
1048 if ((mode > 0) && (mode <= GM_LAST))
1050 ret = dc->GraphicsMode;
1051 dc->GraphicsMode = mode;
1053 release_dc_ptr( dc );
1054 /* font metrics depend on the graphics mode */
1055 if (ret) SelectObject(dc->hSelf, GetCurrentObject(dc->hSelf, OBJ_FONT));
1060 /***********************************************************************
1061 * GetArcDirection (GDI32.@)
1063 INT WINAPI GetArcDirection( HDC hdc )
1066 DC * dc = get_dc_ptr( hdc );
1069 ret = dc->ArcDirection;
1070 release_dc_ptr( dc );
1076 /***********************************************************************
1077 * SetArcDirection (GDI32.@)
1079 INT WINAPI SetArcDirection( HDC hdc, INT dir )
1084 if (dir != AD_COUNTERCLOCKWISE && dir != AD_CLOCKWISE)
1086 SetLastError(ERROR_INVALID_PARAMETER);
1090 if ((dc = get_dc_ptr( hdc )))
1092 PHYSDEV physdev = GET_DC_PHYSDEV( dc, pSetArcDirection );
1093 dir = physdev->funcs->pSetArcDirection( physdev, dir );
1096 ret = dc->ArcDirection;
1097 dc->ArcDirection = dir;
1099 release_dc_ptr( dc );
1105 /***********************************************************************
1106 * GetWorldTransform (GDI32.@)
1108 BOOL WINAPI GetWorldTransform( HDC hdc, LPXFORM xform )
1111 if (!xform) return FALSE;
1112 if (!(dc = get_dc_ptr( hdc ))) return FALSE;
1113 *xform = dc->xformWorld2Wnd;
1114 release_dc_ptr( dc );
1119 /***********************************************************************
1120 * GetTransform (GDI32.@)
1124 * Returns one of the co-ordinate space transforms
1127 * hdc [I] Device context.
1128 * which [I] Which xform to return:
1129 * 0x203 World -> Page transform (that set by SetWorldTransform).
1130 * 0x304 Page -> Device transform (the mapping mode transform).
1131 * 0x204 World -> Device transform (the combination of the above two).
1132 * 0x402 Device -> World transform (the inversion of the above).
1133 * xform [O] The xform.
1136 BOOL WINAPI GetTransform( HDC hdc, DWORD which, XFORM *xform )
1139 DC *dc = get_dc_ptr( hdc );
1140 if (!dc) return FALSE;
1145 *xform = dc->xformWorld2Wnd;
1149 construct_window_to_viewport(dc, xform);
1153 *xform = dc->xformWorld2Vport;
1157 *xform = dc->xformVport2World;
1161 FIXME("Unknown code %x\n", which);
1165 release_dc_ptr( dc );
1170 /****************************************************************************
1171 * CombineTransform [GDI32.@]
1172 * Combines two transformation matrices.
1175 * xformResult [O] Stores the result of combining the two matrices
1176 * xform1 [I] Specifies the first matrix to apply
1177 * xform2 [I] Specifies the second matrix to apply
1180 * The same matrix can be passed in for more than one of the parameters.
1184 * Failure: FALSE. Use GetLastError() to determine the cause.
1186 BOOL WINAPI CombineTransform( LPXFORM xformResult, const XFORM *xform1,
1187 const XFORM *xform2 )
1191 /* Check for illegal parameters */
1192 if (!xformResult || !xform1 || !xform2)
1195 /* Create the result in a temporary XFORM, since xformResult may be
1196 * equal to xform1 or xform2 */
1197 xformTemp.eM11 = xform1->eM11 * xform2->eM11 +
1198 xform1->eM12 * xform2->eM21;
1199 xformTemp.eM12 = xform1->eM11 * xform2->eM12 +
1200 xform1->eM12 * xform2->eM22;
1201 xformTemp.eM21 = xform1->eM21 * xform2->eM11 +
1202 xform1->eM22 * xform2->eM21;
1203 xformTemp.eM22 = xform1->eM21 * xform2->eM12 +
1204 xform1->eM22 * xform2->eM22;
1205 xformTemp.eDx = xform1->eDx * xform2->eM11 +
1206 xform1->eDy * xform2->eM21 +
1208 xformTemp.eDy = xform1->eDx * xform2->eM12 +
1209 xform1->eDy * xform2->eM22 +
1212 /* Copy the result to xformResult */
1213 *xformResult = xformTemp;
1219 /***********************************************************************
1220 * SetDCHook (GDI32.@)
1222 * Note: this doesn't exist in Win32, we add it here because user32 needs it.
1224 BOOL WINAPI SetDCHook( HDC hdc, DCHOOKPROC hookProc, DWORD_PTR dwHookData )
1226 DC *dc = get_dc_ptr( hdc );
1228 if (!dc) return FALSE;
1230 dc->dwHookData = dwHookData;
1231 dc->hookProc = hookProc;
1232 release_dc_ptr( dc );
1237 /***********************************************************************
1238 * GetDCHook (GDI32.@)
1240 * Note: this doesn't exist in Win32, we add it here because user32 needs it.
1242 DWORD_PTR WINAPI GetDCHook( HDC hdc, DCHOOKPROC *proc )
1244 DC *dc = get_dc_ptr( hdc );
1248 if (proc) *proc = dc->hookProc;
1249 ret = dc->dwHookData;
1250 release_dc_ptr( dc );
1255 /***********************************************************************
1256 * SetHookFlags (GDI32.@)
1258 * Note: this doesn't exist in Win32, we add it here because user32 needs it.
1260 WORD WINAPI SetHookFlags( HDC hdc, WORD flags )
1262 DC *dc = get_dc_obj( hdc ); /* not get_dc_ptr, this needs to work from any thread */
1267 TRACE("hDC %p, flags %04x\n",hdc,flags);
1269 if (flags & DCHF_INVALIDATEVISRGN)
1270 ret = InterlockedExchange( &dc->dirty, 1 );
1271 else if (flags & DCHF_VALIDATEVISRGN || !flags)
1272 ret = InterlockedExchange( &dc->dirty, 0 );
1274 GDI_ReleaseObj( hdc );
1276 if (flags & DCHF_RESETDC) ret = reset_dc_state( hdc );
1280 /***********************************************************************
1281 * SetICMMode (GDI32.@)
1283 INT WINAPI SetICMMode(HDC hdc, INT iEnableICM)
1285 /*FIXME: Assume that ICM is always off, and cannot be turned on */
1286 if (iEnableICM == ICM_OFF) return ICM_OFF;
1287 if (iEnableICM == ICM_ON) return 0;
1288 if (iEnableICM == ICM_QUERY) return ICM_OFF;
1292 /***********************************************************************
1293 * GetDeviceGammaRamp (GDI32.@)
1295 BOOL WINAPI GetDeviceGammaRamp(HDC hDC, LPVOID ptr)
1298 DC *dc = get_dc_ptr( hDC );
1300 TRACE("%p, %p\n", hDC, ptr);
1303 if (GetObjectType( hDC ) != OBJ_MEMDC)
1305 PHYSDEV physdev = GET_DC_PHYSDEV( dc, pGetDeviceGammaRamp );
1306 ret = physdev->funcs->pGetDeviceGammaRamp( physdev, ptr );
1308 else SetLastError( ERROR_INVALID_PARAMETER );
1309 release_dc_ptr( dc );
1314 /***********************************************************************
1315 * SetDeviceGammaRamp (GDI32.@)
1317 BOOL WINAPI SetDeviceGammaRamp(HDC hDC, LPVOID ptr)
1320 DC *dc = get_dc_ptr( hDC );
1322 TRACE("%p, %p\n", hDC, ptr);
1325 if (GetObjectType( hDC ) != OBJ_MEMDC)
1327 PHYSDEV physdev = GET_DC_PHYSDEV( dc, pSetDeviceGammaRamp );
1328 ret = physdev->funcs->pSetDeviceGammaRamp( physdev, ptr );
1330 else SetLastError( ERROR_INVALID_PARAMETER );
1331 release_dc_ptr( dc );
1336 /***********************************************************************
1337 * GetColorSpace (GDI32.@)
1339 HCOLORSPACE WINAPI GetColorSpace(HDC hdc)
1341 /*FIXME Need to do whatever GetColorSpace actually does */
1345 /***********************************************************************
1346 * CreateColorSpaceA (GDI32.@)
1348 HCOLORSPACE WINAPI CreateColorSpaceA( LPLOGCOLORSPACEA lpLogColorSpace )
1354 /***********************************************************************
1355 * CreateColorSpaceW (GDI32.@)
1357 HCOLORSPACE WINAPI CreateColorSpaceW( LPLOGCOLORSPACEW lpLogColorSpace )
1363 /***********************************************************************
1364 * DeleteColorSpace (GDI32.@)
1366 BOOL WINAPI DeleteColorSpace( HCOLORSPACE hColorSpace )
1373 /***********************************************************************
1374 * SetColorSpace (GDI32.@)
1376 HCOLORSPACE WINAPI SetColorSpace( HDC hDC, HCOLORSPACE hColorSpace )
1383 /***********************************************************************
1384 * GetBoundsRect (GDI32.@)
1386 UINT WINAPI GetBoundsRect(HDC hdc, LPRECT rect, UINT flags)
1391 DC *dc = get_dc_ptr( hdc );
1393 if ( !dc ) return 0;
1395 physdev = GET_DC_PHYSDEV( dc, pGetBoundsRect );
1396 ret = physdev->funcs->pGetBoundsRect( physdev, &device_rect, DCB_RESET );
1399 release_dc_ptr( dc );
1402 if (dc->bounds_enabled && ret == DCB_SET) add_bounds_rect( &dc->bounds, &device_rect );
1406 if (is_rect_empty( &dc->bounds ))
1408 rect->left = rect->top = rect->right = rect->bottom = 0;
1414 rect->left = max( rect->left, 0 );
1415 rect->top = max( rect->top, 0 );
1416 rect->right = min( rect->right, dc->vis_rect.right - dc->vis_rect.left );
1417 rect->bottom = min( rect->bottom, dc->vis_rect.bottom - dc->vis_rect.top );
1420 DPtoLP( hdc, (POINT *)rect, 2 );
1424 if (flags & DCB_RESET) reset_bounds( &dc->bounds );
1425 release_dc_ptr( dc );
1430 /***********************************************************************
1431 * SetBoundsRect (GDI32.@)
1433 UINT WINAPI SetBoundsRect(HDC hdc, const RECT* rect, UINT flags)
1439 if ((flags & DCB_ENABLE) && (flags & DCB_DISABLE)) return 0;
1440 if (!(dc = get_dc_ptr( hdc ))) return 0;
1442 physdev = GET_DC_PHYSDEV( dc, pSetBoundsRect );
1443 ret = physdev->funcs->pSetBoundsRect( physdev, &dc->bounds, flags );
1446 release_dc_ptr( dc );
1450 ret = (dc->bounds_enabled ? DCB_ENABLE : DCB_DISABLE) |
1451 (is_rect_empty( &dc->bounds ) ? ret & DCB_SET : DCB_SET);
1453 if (flags & DCB_RESET) reset_bounds( &dc->bounds );
1455 if ((flags & DCB_ACCUMULATE) && rect)
1459 LPtoDP( hdc, (POINT *)&rc, 2 );
1460 add_bounds_rect( &dc->bounds, &rc );
1463 if (flags & DCB_ENABLE) dc->bounds_enabled = TRUE;
1464 if (flags & DCB_DISABLE) dc->bounds_enabled = FALSE;
1466 release_dc_ptr( dc );
1471 /***********************************************************************
1472 * GetRelAbs (GDI32.@)
1474 INT WINAPI GetRelAbs( HDC hdc, DWORD dwIgnore )
1477 DC *dc = get_dc_ptr( hdc );
1480 ret = dc->relAbsMode;
1481 release_dc_ptr( dc );
1489 /***********************************************************************
1490 * GetBkMode (GDI32.@)
1492 INT WINAPI GetBkMode( HDC hdc )
1495 DC * dc = get_dc_ptr( hdc );
1498 ret = dc->backgroundMode;
1499 release_dc_ptr( dc );
1505 /***********************************************************************
1506 * SetBkMode (GDI32.@)
1508 INT WINAPI SetBkMode( HDC hdc, INT mode )
1513 if ((mode <= 0) || (mode > BKMODE_LAST))
1515 SetLastError(ERROR_INVALID_PARAMETER);
1518 if ((dc = get_dc_ptr( hdc )))
1520 PHYSDEV physdev = GET_DC_PHYSDEV( dc, pSetBkMode );
1521 mode = physdev->funcs->pSetBkMode( physdev, mode );
1524 ret = dc->backgroundMode;
1525 dc->backgroundMode = mode;
1527 release_dc_ptr( dc );
1533 /***********************************************************************
1536 INT WINAPI GetROP2( HDC hdc )
1539 DC * dc = get_dc_ptr( hdc );
1543 release_dc_ptr( dc );
1549 /***********************************************************************
1552 INT WINAPI SetROP2( HDC hdc, INT mode )
1557 if ((mode < R2_BLACK) || (mode > R2_WHITE))
1559 SetLastError(ERROR_INVALID_PARAMETER);
1562 if ((dc = get_dc_ptr( hdc )))
1564 PHYSDEV physdev = GET_DC_PHYSDEV( dc, pSetROP2 );
1565 mode = physdev->funcs->pSetROP2( physdev, mode );
1571 release_dc_ptr( dc );
1577 /***********************************************************************
1578 * SetRelAbs (GDI32.@)
1580 INT WINAPI SetRelAbs( HDC hdc, INT mode )
1585 if ((mode != ABSOLUTE) && (mode != RELATIVE))
1587 SetLastError(ERROR_INVALID_PARAMETER);
1590 if ((dc = get_dc_ptr( hdc )))
1592 PHYSDEV physdev = GET_DC_PHYSDEV( dc, pSetRelAbs );
1593 mode = physdev->funcs->pSetRelAbs( physdev, mode );
1596 ret = dc->relAbsMode;
1597 dc->relAbsMode = mode;
1599 release_dc_ptr( dc );
1605 /***********************************************************************
1606 * GetPolyFillMode (GDI32.@)
1608 INT WINAPI GetPolyFillMode( HDC hdc )
1611 DC * dc = get_dc_ptr( hdc );
1614 ret = dc->polyFillMode;
1615 release_dc_ptr( dc );
1621 /***********************************************************************
1622 * SetPolyFillMode (GDI32.@)
1624 INT WINAPI SetPolyFillMode( HDC hdc, INT mode )
1629 if ((mode <= 0) || (mode > POLYFILL_LAST))
1631 SetLastError(ERROR_INVALID_PARAMETER);
1634 if ((dc = get_dc_ptr( hdc )))
1636 PHYSDEV physdev = GET_DC_PHYSDEV( dc, pSetPolyFillMode );
1637 mode = physdev->funcs->pSetPolyFillMode( physdev, mode );
1640 ret = dc->polyFillMode;
1641 dc->polyFillMode = mode;
1643 release_dc_ptr( dc );
1649 /***********************************************************************
1650 * GetStretchBltMode (GDI32.@)
1652 INT WINAPI GetStretchBltMode( HDC hdc )
1655 DC * dc = get_dc_ptr( hdc );
1658 ret = dc->stretchBltMode;
1659 release_dc_ptr( dc );
1665 /***********************************************************************
1666 * SetStretchBltMode (GDI32.@)
1668 INT WINAPI SetStretchBltMode( HDC hdc, INT mode )
1673 if ((mode <= 0) || (mode > MAXSTRETCHBLTMODE))
1675 SetLastError(ERROR_INVALID_PARAMETER);
1678 if ((dc = get_dc_ptr( hdc )))
1680 PHYSDEV physdev = GET_DC_PHYSDEV( dc, pSetStretchBltMode );
1681 mode = physdev->funcs->pSetStretchBltMode( physdev, mode );
1684 ret = dc->stretchBltMode;
1685 dc->stretchBltMode = mode;
1687 release_dc_ptr( dc );
1693 /***********************************************************************
1694 * GetMapMode (GDI32.@)
1696 INT WINAPI GetMapMode( HDC hdc )
1699 DC * dc = get_dc_ptr( hdc );
1703 release_dc_ptr( dc );
1709 /***********************************************************************
1710 * GetBrushOrgEx (GDI32.@)
1712 BOOL WINAPI GetBrushOrgEx( HDC hdc, LPPOINT pt )
1714 DC * dc = get_dc_ptr( hdc );
1715 if (!dc) return FALSE;
1716 pt->x = dc->brushOrgX;
1717 pt->y = dc->brushOrgY;
1718 release_dc_ptr( dc );
1723 /***********************************************************************
1724 * GetCurrentPositionEx (GDI32.@)
1726 BOOL WINAPI GetCurrentPositionEx( HDC hdc, LPPOINT pt )
1728 DC * dc = get_dc_ptr( hdc );
1729 if (!dc) return FALSE;
1730 pt->x = dc->CursPosX;
1731 pt->y = dc->CursPosY;
1732 release_dc_ptr( dc );
1737 /***********************************************************************
1738 * GetViewportExtEx (GDI32.@)
1740 BOOL WINAPI GetViewportExtEx( HDC hdc, LPSIZE size )
1742 DC * dc = get_dc_ptr( hdc );
1743 if (!dc) return FALSE;
1744 size->cx = dc->vportExtX;
1745 size->cy = dc->vportExtY;
1746 release_dc_ptr( dc );
1751 /***********************************************************************
1752 * GetViewportOrgEx (GDI32.@)
1754 BOOL WINAPI GetViewportOrgEx( HDC hdc, LPPOINT pt )
1756 DC * dc = get_dc_ptr( hdc );
1757 if (!dc) return FALSE;
1758 pt->x = dc->vportOrgX;
1759 pt->y = dc->vportOrgY;
1760 release_dc_ptr( dc );
1765 /***********************************************************************
1766 * GetWindowExtEx (GDI32.@)
1768 BOOL WINAPI GetWindowExtEx( HDC hdc, LPSIZE size )
1770 DC * dc = get_dc_ptr( hdc );
1771 if (!dc) return FALSE;
1772 size->cx = dc->wndExtX;
1773 size->cy = dc->wndExtY;
1774 release_dc_ptr( dc );
1779 /***********************************************************************
1780 * GetWindowOrgEx (GDI32.@)
1782 BOOL WINAPI GetWindowOrgEx( HDC hdc, LPPOINT pt )
1784 DC * dc = get_dc_ptr( hdc );
1785 if (!dc) return FALSE;
1786 pt->x = dc->wndOrgX;
1787 pt->y = dc->wndOrgY;
1788 release_dc_ptr( dc );
1793 /***********************************************************************
1794 * GetLayout (GDI32.@)
1796 * Gets left->right or right->left text layout flags of a dc.
1799 DWORD WINAPI GetLayout(HDC hdc)
1801 DWORD layout = GDI_ERROR;
1803 DC * dc = get_dc_ptr( hdc );
1806 layout = dc->layout;
1807 release_dc_ptr( dc );
1810 TRACE("hdc : %p, layout : %08x\n", hdc, layout);
1815 /***********************************************************************
1816 * SetLayout (GDI32.@)
1818 * Sets left->right or right->left text layout flags of a dc.
1821 DWORD WINAPI SetLayout(HDC hdc, DWORD layout)
1823 DWORD oldlayout = GDI_ERROR;
1825 DC * dc = get_dc_ptr( hdc );
1828 PHYSDEV physdev = GET_DC_PHYSDEV( dc, pSetLayout );
1829 layout = physdev->funcs->pSetLayout( physdev, layout );
1830 if (layout != GDI_ERROR)
1832 oldlayout = dc->layout;
1833 dc->layout = layout;
1834 if (layout != oldlayout)
1836 if (layout & LAYOUT_RTL) dc->MapMode = MM_ANISOTROPIC;
1837 DC_UpdateXforms( dc );
1840 release_dc_ptr( dc );
1843 TRACE("hdc : %p, old layout : %08x, new layout : %08x\n", hdc, oldlayout, layout);
1848 /***********************************************************************
1849 * GetDCBrushColor (GDI32.@)
1851 COLORREF WINAPI GetDCBrushColor(HDC hdc)
1854 COLORREF dcBrushColor = CLR_INVALID;
1856 TRACE("hdc(%p)\n", hdc);
1858 dc = get_dc_ptr( hdc );
1861 dcBrushColor = dc->dcBrushColor;
1862 release_dc_ptr( dc );
1865 return dcBrushColor;
1868 /***********************************************************************
1869 * SetDCBrushColor (GDI32.@)
1871 COLORREF WINAPI SetDCBrushColor(HDC hdc, COLORREF crColor)
1874 COLORREF oldClr = CLR_INVALID;
1876 TRACE("hdc(%p) crColor(%08x)\n", hdc, crColor);
1878 dc = get_dc_ptr( hdc );
1881 PHYSDEV physdev = GET_DC_PHYSDEV( dc, pSetDCBrushColor );
1882 crColor = physdev->funcs->pSetDCBrushColor( physdev, crColor );
1883 if (crColor != CLR_INVALID)
1885 oldClr = dc->dcBrushColor;
1886 dc->dcBrushColor = crColor;
1888 release_dc_ptr( dc );
1894 /***********************************************************************
1895 * GetDCPenColor (GDI32.@)
1897 COLORREF WINAPI GetDCPenColor(HDC hdc)
1900 COLORREF dcPenColor = CLR_INVALID;
1902 TRACE("hdc(%p)\n", hdc);
1904 dc = get_dc_ptr( hdc );
1907 dcPenColor = dc->dcPenColor;
1908 release_dc_ptr( dc );
1914 /***********************************************************************
1915 * SetDCPenColor (GDI32.@)
1917 COLORREF WINAPI SetDCPenColor(HDC hdc, COLORREF crColor)
1920 COLORREF oldClr = CLR_INVALID;
1922 TRACE("hdc(%p) crColor(%08x)\n", hdc, crColor);
1924 dc = get_dc_ptr( hdc );
1927 PHYSDEV physdev = GET_DC_PHYSDEV( dc, pSetDCPenColor );
1928 crColor = physdev->funcs->pSetDCPenColor( physdev, crColor );
1929 if (crColor != CLR_INVALID)
1931 oldClr = dc->dcPenColor;
1932 dc->dcPenColor = crColor;
1934 release_dc_ptr( dc );
1940 /***********************************************************************
1941 * CancelDC (GDI32.@)
1943 BOOL WINAPI CancelDC(HDC hdc)
1949 /*******************************************************************
1950 * GetMiterLimit [GDI32.@]
1954 BOOL WINAPI GetMiterLimit(HDC hdc, PFLOAT peLimit)
1959 TRACE("(%p,%p)\n", hdc, peLimit);
1961 dc = get_dc_ptr( hdc );
1965 *peLimit = dc->miterLimit;
1967 release_dc_ptr( dc );
1973 /*******************************************************************
1974 * SetMiterLimit [GDI32.@]
1978 BOOL WINAPI SetMiterLimit(HDC hdc, FLOAT eNewLimit, PFLOAT peOldLimit)
1983 TRACE("(%p,%f,%p)\n", hdc, eNewLimit, peOldLimit);
1985 dc = get_dc_ptr( hdc );
1989 *peOldLimit = dc->miterLimit;
1990 dc->miterLimit = eNewLimit;
1991 release_dc_ptr( dc );
1997 /*******************************************************************
1998 * GdiIsMetaPrintDC [GDI32.@]
2000 BOOL WINAPI GdiIsMetaPrintDC(HDC hdc)
2006 /*******************************************************************
2007 * GdiIsMetaFileDC [GDI32.@]
2009 BOOL WINAPI GdiIsMetaFileDC(HDC hdc)
2013 switch( GetObjectType( hdc ) )
2022 /*******************************************************************
2023 * GdiIsPlayMetafileDC [GDI32.@]
2025 BOOL WINAPI GdiIsPlayMetafileDC(HDC hdc)