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
)
56 DC
*dc
= get_any_obj_ptr( hdc
, &type
);
67 GDI_ReleaseObj( hdc
);
68 SetLastError( ERROR_INVALID_HANDLE
);
74 /***********************************************************************
75 * set_initial_dc_state
77 static void set_initial_dc_state( DC
*dc
)
87 dc
->miterLimit
= 10.0f
; /* 10.0 is the default, from MSDN */
89 dc
->font_code_page
= CP_ACP
;
90 dc
->ROPmode
= R2_COPYPEN
;
91 dc
->polyFillMode
= ALTERNATE
;
92 dc
->stretchBltMode
= BLACKONWHITE
;
93 dc
->relAbsMode
= ABSOLUTE
;
94 dc
->backgroundMode
= OPAQUE
;
95 dc
->backgroundColor
= RGB( 255, 255, 255 );
96 dc
->dcBrushColor
= RGB( 255, 255, 255 );
97 dc
->dcPenColor
= RGB( 0, 0, 0 );
98 dc
->textColor
= RGB( 0, 0, 0 );
102 dc
->textAlign
= TA_LEFT
| TA_TOP
| TA_NOUPDATECP
;
106 dc
->MapMode
= MM_TEXT
;
107 dc
->GraphicsMode
= GM_COMPATIBLE
;
110 dc
->ArcDirection
= AD_COUNTERCLOCKWISE
;
111 dc
->xformWorld2Wnd
.eM11
= 1.0f
;
112 dc
->xformWorld2Wnd
.eM12
= 0.0f
;
113 dc
->xformWorld2Wnd
.eM21
= 0.0f
;
114 dc
->xformWorld2Wnd
.eM22
= 1.0f
;
115 dc
->xformWorld2Wnd
.eDx
= 0.0f
;
116 dc
->xformWorld2Wnd
.eDy
= 0.0f
;
117 dc
->xformWorld2Vport
= dc
->xformWorld2Wnd
;
118 dc
->xformVport2World
= dc
->xformWorld2Wnd
;
119 dc
->vport2WorldValid
= TRUE
;
121 reset_bounds( &dc
->bounds
);
124 /***********************************************************************
127 DC
*alloc_dc_ptr( WORD magic
)
131 if (!(dc
= HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*dc
) ))) return NULL
;
133 dc
->nulldrv
.funcs
= &null_driver
;
134 dc
->physDev
= &dc
->nulldrv
;
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
->font_gamma_ramp
);
172 HeapFree( GetProcessHeap(), 0, dc
);
176 /***********************************************************************
179 void free_dc_ptr( DC
*dc
)
181 assert( dc
->refcount
== 1 );
183 while (dc
->physDev
!= &dc
->nulldrv
)
185 PHYSDEV physdev
= dc
->physDev
;
186 dc
->physDev
= physdev
->next
;
187 physdev
->funcs
->pDeleteDC( physdev
);
189 GDI_dec_ref_count( dc
->hPen
);
190 GDI_dec_ref_count( dc
->hBrush
);
191 GDI_dec_ref_count( dc
->hFont
);
192 if (dc
->hBitmap
) GDI_dec_ref_count( dc
->hBitmap
);
193 free_gdi_handle( dc
->hSelf
);
198 /***********************************************************************
201 * Retrieve a DC pointer but release the GDI lock.
203 DC
*get_dc_ptr( HDC hdc
)
205 DC
*dc
= get_dc_obj( hdc
);
206 if (!dc
) return NULL
;
209 GDI_ReleaseObj( hdc
);
213 if (!InterlockedCompareExchange( &dc
->refcount
, 1, 0 ))
215 dc
->thread
= GetCurrentThreadId();
217 else if (dc
->thread
!= GetCurrentThreadId())
219 WARN( "dc %p belongs to thread %04x\n", hdc
, dc
->thread
);
220 GDI_ReleaseObj( hdc
);
223 else InterlockedIncrement( &dc
->refcount
);
225 GDI_ReleaseObj( hdc
);
230 /***********************************************************************
233 void release_dc_ptr( DC
*dc
)
238 ref
= InterlockedDecrement( &dc
->refcount
);
240 if (ref
) dc
->thread
= GetCurrentThreadId(); /* we still own it */
244 /***********************************************************************
247 * Make sure the DC vis region is up to date.
248 * This function may call up to USER so the GDI lock should _not_
249 * be held when calling it.
251 void update_dc( DC
*dc
)
253 if (InterlockedExchange( &dc
->dirty
, 0 ) && dc
->hookProc
)
254 dc
->hookProc( dc
->hSelf
, DCHC_INVALIDVISRGN
, dc
->dwHookData
, 0 );
258 /***********************************************************************
261 static BOOL
DC_DeleteObject( HGDIOBJ handle
)
263 return DeleteDC( handle
);
267 /***********************************************************************
270 * Setup device-specific DC values for a newly created DC.
272 void DC_InitDC( DC
* dc
)
274 PHYSDEV physdev
= GET_DC_PHYSDEV( dc
, pRealizeDefaultPalette
);
275 physdev
->funcs
->pRealizeDefaultPalette( physdev
);
276 SetTextColor( dc
->hSelf
, dc
->textColor
);
277 SetBkColor( dc
->hSelf
, dc
->backgroundColor
);
278 SelectObject( dc
->hSelf
, dc
->hPen
);
279 SelectObject( dc
->hSelf
, dc
->hBrush
);
280 SelectObject( dc
->hSelf
, dc
->hFont
);
281 update_dc_clipping( dc
);
282 SetVirtualResolution( dc
->hSelf
, 0, 0, 0, 0 );
283 physdev
= GET_DC_PHYSDEV( dc
, pSetBoundsRect
);
284 physdev
->funcs
->pSetBoundsRect( physdev
, &dc
->bounds
, dc
->bounds_enabled
? DCB_ENABLE
: DCB_DISABLE
);
288 /***********************************************************************
291 * Computes the inverse of the transformation xformSrc and stores it to
292 * xformDest. Returns TRUE if successful or FALSE if the xformSrc matrix
295 static BOOL
DC_InvertXform( const XFORM
*xformSrc
, XFORM
*xformDest
)
299 determinant
= xformSrc
->eM11
*xformSrc
->eM22
-
300 xformSrc
->eM12
*xformSrc
->eM21
;
301 if (determinant
> -1e-12 && determinant
< 1e-12)
304 xformDest
->eM11
= xformSrc
->eM22
/ determinant
;
305 xformDest
->eM12
= -xformSrc
->eM12
/ determinant
;
306 xformDest
->eM21
= -xformSrc
->eM21
/ determinant
;
307 xformDest
->eM22
= xformSrc
->eM11
/ determinant
;
308 xformDest
->eDx
= -xformSrc
->eDx
* xformDest
->eM11
-
309 xformSrc
->eDy
* xformDest
->eM21
;
310 xformDest
->eDy
= -xformSrc
->eDx
* xformDest
->eM12
-
311 xformSrc
->eDy
* xformDest
->eM22
;
316 /* Construct a transformation to do the window-to-viewport conversion */
317 static void construct_window_to_viewport(DC
*dc
, XFORM
*xform
)
319 double scaleX
, scaleY
;
320 scaleX
= (double)dc
->vport_ext
.cx
/ (double)dc
->wnd_ext
.cx
;
321 scaleY
= (double)dc
->vport_ext
.cy
/ (double)dc
->wnd_ext
.cy
;
323 if (dc
->layout
& LAYOUT_RTL
) scaleX
= -scaleX
;
324 xform
->eM11
= scaleX
;
327 xform
->eM22
= scaleY
;
328 xform
->eDx
= (double)dc
->vport_org
.x
- scaleX
* (double)dc
->wnd_org
.x
;
329 xform
->eDy
= (double)dc
->vport_org
.y
- scaleY
* (double)dc
->wnd_org
.y
;
330 if (dc
->layout
& LAYOUT_RTL
) xform
->eDx
= dc
->vis_rect
.right
- dc
->vis_rect
.left
- 1 - xform
->eDx
;
333 /***********************************************************************
336 * Compares the linear transform portion of two XFORMs (i.e. the 2x2 submatrix).
337 * Returns 0 if they match.
339 static inline int linear_xform_cmp( const XFORM
*a
, const XFORM
*b
)
341 return memcmp( a
, b
, FIELD_OFFSET( XFORM
, eDx
) );
344 /***********************************************************************
347 * Updates the xformWorld2Vport, xformVport2World and vport2WorldValid
348 * fields of the specified DC by creating a transformation that
349 * represents the current mapping mode and combining it with the DC's
350 * world transform. This function should be called whenever the
351 * parameters associated with the mapping mode (window and viewport
352 * extents and origins) or the world transform change.
354 void DC_UpdateXforms( DC
*dc
)
356 XFORM xformWnd2Vport
, oldworld2vport
;
358 construct_window_to_viewport(dc
, &xformWnd2Vport
);
360 oldworld2vport
= dc
->xformWorld2Vport
;
361 /* Combine with the world transformation */
362 CombineTransform( &dc
->xformWorld2Vport
, &dc
->xformWorld2Wnd
,
365 /* Create inverse of world-to-viewport transformation */
366 dc
->vport2WorldValid
= DC_InvertXform( &dc
->xformWorld2Vport
,
367 &dc
->xformVport2World
);
369 /* Reselect the font and pen back into the dc so that the size
371 if (linear_xform_cmp( &oldworld2vport
, &dc
->xformWorld2Vport
) &&
372 !GdiIsMetaFileDC(dc
->hSelf
))
374 SelectObject(dc
->hSelf
, dc
->hFont
);
375 SelectObject(dc
->hSelf
, dc
->hPen
);
380 /***********************************************************************
383 INT CDECL
nulldrv_SaveDC( PHYSDEV dev
)
385 DC
*newdc
, *dc
= get_nulldrv_dc( dev
);
387 if (!(newdc
= HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*newdc
)))) return 0;
388 newdc
->layout
= dc
->layout
;
389 newdc
->hPen
= dc
->hPen
;
390 newdc
->hBrush
= dc
->hBrush
;
391 newdc
->hFont
= dc
->hFont
;
392 newdc
->hBitmap
= dc
->hBitmap
;
393 newdc
->hPalette
= dc
->hPalette
;
394 newdc
->ROPmode
= dc
->ROPmode
;
395 newdc
->polyFillMode
= dc
->polyFillMode
;
396 newdc
->stretchBltMode
= dc
->stretchBltMode
;
397 newdc
->relAbsMode
= dc
->relAbsMode
;
398 newdc
->backgroundMode
= dc
->backgroundMode
;
399 newdc
->backgroundColor
= dc
->backgroundColor
;
400 newdc
->textColor
= dc
->textColor
;
401 newdc
->dcBrushColor
= dc
->dcBrushColor
;
402 newdc
->dcPenColor
= dc
->dcPenColor
;
403 newdc
->brush_org
= dc
->brush_org
;
404 newdc
->mapperFlags
= dc
->mapperFlags
;
405 newdc
->textAlign
= dc
->textAlign
;
406 newdc
->charExtra
= dc
->charExtra
;
407 newdc
->breakExtra
= dc
->breakExtra
;
408 newdc
->breakRem
= dc
->breakRem
;
409 newdc
->MapMode
= dc
->MapMode
;
410 newdc
->GraphicsMode
= dc
->GraphicsMode
;
411 newdc
->cur_pos
= dc
->cur_pos
;
412 newdc
->ArcDirection
= dc
->ArcDirection
;
413 newdc
->xformWorld2Wnd
= dc
->xformWorld2Wnd
;
414 newdc
->xformWorld2Vport
= dc
->xformWorld2Vport
;
415 newdc
->xformVport2World
= dc
->xformVport2World
;
416 newdc
->vport2WorldValid
= dc
->vport2WorldValid
;
417 newdc
->wnd_org
= dc
->wnd_org
;
418 newdc
->wnd_ext
= dc
->wnd_ext
;
419 newdc
->vport_org
= dc
->vport_org
;
420 newdc
->vport_ext
= dc
->vport_ext
;
421 newdc
->virtual_res
= dc
->virtual_res
;
422 newdc
->virtual_size
= dc
->virtual_size
;
424 /* Get/SetDCState() don't change hVisRgn field ("Undoc. Windows" p.559). */
428 newdc
->hClipRgn
= CreateRectRgn( 0, 0, 0, 0 );
429 CombineRgn( newdc
->hClipRgn
, dc
->hClipRgn
, 0, RGN_COPY
);
433 newdc
->hMetaRgn
= CreateRectRgn( 0, 0, 0, 0 );
434 CombineRgn( newdc
->hMetaRgn
, dc
->hMetaRgn
, 0, RGN_COPY
);
437 if (!PATH_SavePath( newdc
, dc
))
439 release_dc_ptr( dc
);
440 free_dc_state( newdc
);
444 newdc
->saved_dc
= dc
->saved_dc
;
445 dc
->saved_dc
= newdc
;
446 return ++dc
->saveLevel
;
450 /***********************************************************************
453 BOOL CDECL
nulldrv_RestoreDC( PHYSDEV dev
, INT level
)
455 DC
*dcs
, *first_dcs
, *dc
= get_nulldrv_dc( dev
);
458 /* find the state level to restore */
460 if (abs(level
) > dc
->saveLevel
|| level
== 0) return FALSE
;
461 if (level
< 0) level
= dc
->saveLevel
+ level
+ 1;
462 first_dcs
= dc
->saved_dc
;
463 for (dcs
= first_dcs
, save_level
= dc
->saveLevel
; save_level
> level
; save_level
--)
466 /* restore the state */
468 if (!PATH_RestorePath( dc
, dcs
)) return FALSE
;
470 dc
->layout
= dcs
->layout
;
471 dc
->ROPmode
= dcs
->ROPmode
;
472 dc
->polyFillMode
= dcs
->polyFillMode
;
473 dc
->stretchBltMode
= dcs
->stretchBltMode
;
474 dc
->relAbsMode
= dcs
->relAbsMode
;
475 dc
->backgroundMode
= dcs
->backgroundMode
;
476 dc
->backgroundColor
= dcs
->backgroundColor
;
477 dc
->textColor
= dcs
->textColor
;
478 dc
->dcBrushColor
= dcs
->dcBrushColor
;
479 dc
->dcPenColor
= dcs
->dcPenColor
;
480 dc
->brush_org
= dcs
->brush_org
;
481 dc
->mapperFlags
= dcs
->mapperFlags
;
482 dc
->textAlign
= dcs
->textAlign
;
483 dc
->charExtra
= dcs
->charExtra
;
484 dc
->breakExtra
= dcs
->breakExtra
;
485 dc
->breakRem
= dcs
->breakRem
;
486 dc
->MapMode
= dcs
->MapMode
;
487 dc
->GraphicsMode
= dcs
->GraphicsMode
;
488 dc
->cur_pos
= dcs
->cur_pos
;
489 dc
->ArcDirection
= dcs
->ArcDirection
;
490 dc
->xformWorld2Wnd
= dcs
->xformWorld2Wnd
;
491 dc
->xformWorld2Vport
= dcs
->xformWorld2Vport
;
492 dc
->xformVport2World
= dcs
->xformVport2World
;
493 dc
->vport2WorldValid
= dcs
->vport2WorldValid
;
494 dc
->wnd_org
= dcs
->wnd_org
;
495 dc
->wnd_ext
= dcs
->wnd_ext
;
496 dc
->vport_org
= dcs
->vport_org
;
497 dc
->vport_ext
= dcs
->vport_ext
;
498 dc
->virtual_res
= dcs
->virtual_res
;
499 dc
->virtual_size
= dcs
->virtual_size
;
503 if (!dc
->hClipRgn
) dc
->hClipRgn
= CreateRectRgn( 0, 0, 0, 0 );
504 CombineRgn( dc
->hClipRgn
, dcs
->hClipRgn
, 0, RGN_COPY
);
508 if (dc
->hClipRgn
) DeleteObject( dc
->hClipRgn
);
513 if (!dc
->hMetaRgn
) dc
->hMetaRgn
= CreateRectRgn( 0, 0, 0, 0 );
514 CombineRgn( dc
->hMetaRgn
, dcs
->hMetaRgn
, 0, RGN_COPY
);
518 if (dc
->hMetaRgn
) DeleteObject( dc
->hMetaRgn
);
521 DC_UpdateXforms( dc
);
522 update_dc_clipping( dc
);
524 SelectObject( dev
->hdc
, dcs
->hBitmap
);
525 SelectObject( dev
->hdc
, dcs
->hBrush
);
526 SelectObject( dev
->hdc
, dcs
->hFont
);
527 SelectObject( dev
->hdc
, dcs
->hPen
);
528 SetBkColor( dev
->hdc
, dcs
->backgroundColor
);
529 SetTextColor( dev
->hdc
, dcs
->textColor
);
530 GDISelectPalette( dev
->hdc
, dcs
->hPalette
, FALSE
);
532 dc
->saved_dc
= dcs
->saved_dc
;
534 dc
->saveLevel
= save_level
- 1;
536 /* now destroy all the saved DCs */
540 DC
*next
= first_dcs
->saved_dc
;
541 free_dc_state( first_dcs
);
548 /***********************************************************************
551 static BOOL
reset_dc_state( HDC hdc
)
555 if (!(dc
= get_dc_ptr( hdc
))) return FALSE
;
557 set_initial_dc_state( dc
);
558 SetBkColor( hdc
, RGB( 255, 255, 255 ));
559 SetTextColor( hdc
, RGB( 0, 0, 0 ));
560 SelectObject( hdc
, GetStockObject( WHITE_BRUSH
));
561 SelectObject( hdc
, GetStockObject( SYSTEM_FONT
));
562 SelectObject( hdc
, GetStockObject( BLACK_PEN
));
563 SetVirtualResolution( hdc
, 0, 0, 0, 0 );
564 GDISelectPalette( hdc
, GetStockObject( DEFAULT_PALETTE
), FALSE
);
565 SetBoundsRect( hdc
, NULL
, DCB_DISABLE
);
568 if (dc
->hClipRgn
) DeleteObject( dc
->hClipRgn
);
569 if (dc
->hMetaRgn
) DeleteObject( dc
->hMetaRgn
);
572 update_dc_clipping( dc
);
574 for (dcs
= dc
->saved_dc
; dcs
; dcs
= next
)
576 next
= dcs
->saved_dc
;
577 free_dc_state( dcs
);
581 release_dc_ptr( dc
);
586 /***********************************************************************
589 INT WINAPI
SaveDC( HDC hdc
)
594 if ((dc
= get_dc_ptr( hdc
)))
596 PHYSDEV physdev
= GET_DC_PHYSDEV( dc
, pSaveDC
);
597 ret
= physdev
->funcs
->pSaveDC( physdev
);
598 release_dc_ptr( dc
);
604 /***********************************************************************
605 * RestoreDC (GDI32.@)
607 BOOL WINAPI
RestoreDC( HDC hdc
, INT level
)
611 BOOL success
= FALSE
;
613 TRACE("%p %d\n", hdc
, level
);
614 if ((dc
= get_dc_ptr( hdc
)))
617 physdev
= GET_DC_PHYSDEV( dc
, pRestoreDC
);
618 success
= physdev
->funcs
->pRestoreDC( physdev
, level
);
619 release_dc_ptr( dc
);
625 /***********************************************************************
626 * CreateDCW (GDI32.@)
628 HDC WINAPI
CreateDCW( LPCWSTR driver
, LPCWSTR device
, LPCWSTR output
,
629 const DEVMODEW
*initData
)
633 const struct gdi_dc_funcs
*funcs
;
638 if (!device
|| !DRIVER_GetDriverName( device
, buf
, 300 ))
642 ERR( "no device found for %s\n", debugstr_w(device
) );
645 strcpyW(buf
, driver
);
648 if (!(funcs
= DRIVER_load_driver( buf
)))
650 ERR( "no driver found for %s\n", debugstr_w(buf
) );
653 if (!(dc
= alloc_dc_ptr( OBJ_DC
))) return 0;
656 dc
->hBitmap
= GDI_inc_ref_count( GetStockObject( DEFAULT_BITMAP
));
658 TRACE("(driver=%s, device=%s, output=%s): returning %p\n",
659 debugstr_w(driver
), debugstr_w(device
), debugstr_w(output
), dc
->hSelf
);
661 if (funcs
->pCreateDC
)
663 if (!funcs
->pCreateDC( &dc
->physDev
, buf
, device
, output
, initData
))
665 WARN("creation aborted by device\n" );
671 dc
->vis_rect
.left
= 0;
672 dc
->vis_rect
.top
= 0;
673 dc
->vis_rect
.right
= GetDeviceCaps( hdc
, DESKTOPHORZRES
);
674 dc
->vis_rect
.bottom
= GetDeviceCaps( hdc
, DESKTOPVERTRES
);
677 release_dc_ptr( dc
);
682 /***********************************************************************
683 * CreateDCA (GDI32.@)
685 HDC WINAPI
CreateDCA( LPCSTR driver
, LPCSTR device
, LPCSTR output
,
686 const DEVMODEA
*initData
)
688 UNICODE_STRING driverW
, deviceW
, outputW
;
692 if (driver
) RtlCreateUnicodeStringFromAsciiz(&driverW
, driver
);
693 else driverW
.Buffer
= NULL
;
695 if (device
) RtlCreateUnicodeStringFromAsciiz(&deviceW
, device
);
696 else deviceW
.Buffer
= NULL
;
698 if (output
) RtlCreateUnicodeStringFromAsciiz(&outputW
, output
);
699 else outputW
.Buffer
= NULL
;
704 /* don't convert initData for DISPLAY driver, it's not used */
705 if (!driverW
.Buffer
|| strcmpiW( driverW
.Buffer
, displayW
))
706 initDataW
= GdiConvertToDevmodeW(initData
);
709 ret
= CreateDCW( driverW
.Buffer
, deviceW
.Buffer
, outputW
.Buffer
, initDataW
);
711 RtlFreeUnicodeString(&driverW
);
712 RtlFreeUnicodeString(&deviceW
);
713 RtlFreeUnicodeString(&outputW
);
714 HeapFree(GetProcessHeap(), 0, initDataW
);
719 /***********************************************************************
720 * CreateICA (GDI32.@)
722 HDC WINAPI
CreateICA( LPCSTR driver
, LPCSTR device
, LPCSTR output
,
723 const DEVMODEA
* initData
)
725 /* Nothing special yet for ICs */
726 return CreateDCA( driver
, device
, output
, initData
);
730 /***********************************************************************
731 * CreateICW (GDI32.@)
733 HDC WINAPI
CreateICW( LPCWSTR driver
, LPCWSTR device
, LPCWSTR output
,
734 const DEVMODEW
* initData
)
736 /* Nothing special yet for ICs */
737 return CreateDCW( driver
, device
, output
, initData
);
741 /***********************************************************************
742 * CreateCompatibleDC (GDI32.@)
744 HDC WINAPI
CreateCompatibleDC( HDC hdc
)
748 const struct gdi_dc_funcs
*funcs
;
749 PHYSDEV physDev
= NULL
;
755 if (!(origDC
= get_dc_ptr( hdc
))) return 0;
756 physDev
= GET_DC_PHYSDEV( origDC
, pCreateCompatibleDC
);
757 funcs
= physDev
->funcs
;
758 release_dc_ptr( origDC
);
760 else funcs
= DRIVER_load_driver( displayW
);
762 if (!(dc
= alloc_dc_ptr( OBJ_MEMDC
))) return 0;
764 TRACE("(%p): returning %p\n", hdc
, dc
->hSelf
);
766 dc
->hBitmap
= GDI_inc_ref_count( GetStockObject( DEFAULT_BITMAP
));
767 dc
->vis_rect
.left
= 0;
768 dc
->vis_rect
.top
= 0;
769 dc
->vis_rect
.right
= 1;
770 dc
->vis_rect
.bottom
= 1;
771 dc
->device_rect
= dc
->vis_rect
;
775 if (funcs
->pCreateCompatibleDC
&& !funcs
->pCreateCompatibleDC( physDev
, &dc
->physDev
))
777 WARN("creation aborted by device\n");
782 if (!dib_driver
.pCreateDC( &dc
->physDev
, NULL
, NULL
, NULL
, NULL
))
787 physDev
= GET_DC_PHYSDEV( dc
, pSelectBitmap
);
788 physDev
->funcs
->pSelectBitmap( physDev
, dc
->hBitmap
);
791 release_dc_ptr( dc
);
796 /***********************************************************************
799 BOOL WINAPI
DeleteDC( HDC hdc
)
807 if (!(dc
= get_dc_ptr( hdc
))) return FALSE
;
808 if (dc
->refcount
!= 1)
810 FIXME( "not deleting busy DC %p refcount %u\n", dc
->hSelf
, dc
->refcount
);
811 release_dc_ptr( dc
);
815 /* Call hook procedure to check whether is it OK to delete this DC */
816 if (dc
->hookProc
&& !dc
->hookProc( dc
->hSelf
, DCHC_DELETEDC
, dc
->dwHookData
, 0 ))
818 release_dc_ptr( dc
);
821 reset_dc_state( hdc
);
827 /***********************************************************************
830 HDC WINAPI
ResetDCW( HDC hdc
, const DEVMODEW
*devmode
)
835 if ((dc
= get_dc_ptr( hdc
)))
837 PHYSDEV physdev
= GET_DC_PHYSDEV( dc
, pResetDC
);
838 ret
= physdev
->funcs
->pResetDC( physdev
, devmode
);
839 if (ret
) /* reset the visible region */
842 dc
->vis_rect
.left
= 0;
843 dc
->vis_rect
.top
= 0;
844 dc
->vis_rect
.right
= GetDeviceCaps( hdc
, DESKTOPHORZRES
);
845 dc
->vis_rect
.bottom
= GetDeviceCaps( hdc
, DESKTOPVERTRES
);
846 if (dc
->hVisRgn
) DeleteObject( dc
->hVisRgn
);
848 update_dc_clipping( dc
);
850 release_dc_ptr( dc
);
856 /***********************************************************************
859 HDC WINAPI
ResetDCA( HDC hdc
, const DEVMODEA
*devmode
)
864 if (devmode
) devmodeW
= GdiConvertToDevmodeW(devmode
);
865 else devmodeW
= NULL
;
867 ret
= ResetDCW(hdc
, devmodeW
);
869 HeapFree(GetProcessHeap(), 0, devmodeW
);
874 /***********************************************************************
875 * GetDeviceCaps (GDI32.@)
877 INT WINAPI
GetDeviceCaps( HDC hdc
, INT cap
)
882 if ((dc
= get_dc_ptr( hdc
)))
884 PHYSDEV physdev
= GET_DC_PHYSDEV( dc
, pGetDeviceCaps
);
885 ret
= physdev
->funcs
->pGetDeviceCaps( physdev
, cap
);
886 release_dc_ptr( dc
);
892 /***********************************************************************
893 * GetBkColor (GDI32.@)
895 COLORREF WINAPI
GetBkColor( HDC hdc
)
898 DC
* dc
= get_dc_ptr( hdc
);
901 ret
= dc
->backgroundColor
;
902 release_dc_ptr( dc
);
908 /***********************************************************************
909 * SetBkColor (GDI32.@)
911 COLORREF WINAPI
SetBkColor( HDC hdc
, COLORREF color
)
913 COLORREF ret
= CLR_INVALID
;
914 DC
* dc
= get_dc_ptr( hdc
);
916 TRACE("hdc=%p color=0x%08x\n", hdc
, color
);
920 PHYSDEV physdev
= GET_DC_PHYSDEV( dc
, pSetBkColor
);
921 ret
= dc
->backgroundColor
;
922 dc
->backgroundColor
= physdev
->funcs
->pSetBkColor( physdev
, color
);
923 release_dc_ptr( dc
);
929 /***********************************************************************
930 * GetTextColor (GDI32.@)
932 COLORREF WINAPI
GetTextColor( HDC hdc
)
935 DC
* dc
= get_dc_ptr( hdc
);
939 release_dc_ptr( dc
);
945 /***********************************************************************
946 * SetTextColor (GDI32.@)
948 COLORREF WINAPI
SetTextColor( HDC hdc
, COLORREF color
)
950 COLORREF ret
= CLR_INVALID
;
951 DC
* dc
= get_dc_ptr( hdc
);
953 TRACE(" hdc=%p color=0x%08x\n", hdc
, color
);
957 PHYSDEV physdev
= GET_DC_PHYSDEV( dc
, pSetTextColor
);
959 dc
->textColor
= physdev
->funcs
->pSetTextColor( physdev
, color
);
960 release_dc_ptr( dc
);
966 /***********************************************************************
967 * GetTextAlign (GDI32.@)
969 UINT WINAPI
GetTextAlign( HDC hdc
)
972 DC
* dc
= get_dc_ptr( hdc
);
976 release_dc_ptr( dc
);
982 /***********************************************************************
983 * SetTextAlign (GDI32.@)
985 UINT WINAPI
SetTextAlign( HDC hdc
, UINT align
)
987 UINT ret
= GDI_ERROR
;
988 DC
*dc
= get_dc_ptr( hdc
);
990 TRACE("hdc=%p align=%d\n", hdc
, align
);
994 PHYSDEV physdev
= GET_DC_PHYSDEV( dc
, pSetTextAlign
);
995 align
= physdev
->funcs
->pSetTextAlign( physdev
, align
);
996 if (align
!= GDI_ERROR
)
999 dc
->textAlign
= align
;
1001 release_dc_ptr( dc
);
1006 /***********************************************************************
1007 * GetDCOrgEx (GDI32.@)
1009 BOOL WINAPI
GetDCOrgEx( HDC hDC
, LPPOINT lpp
)
1013 if (!lpp
) return FALSE
;
1014 if (!(dc
= get_dc_ptr( hDC
))) return FALSE
;
1015 lpp
->x
= dc
->vis_rect
.left
;
1016 lpp
->y
= dc
->vis_rect
.top
;
1017 release_dc_ptr( dc
);
1022 /***********************************************************************
1023 * GetGraphicsMode (GDI32.@)
1025 INT WINAPI
GetGraphicsMode( HDC hdc
)
1028 DC
* dc
= get_dc_ptr( hdc
);
1031 ret
= dc
->GraphicsMode
;
1032 release_dc_ptr( dc
);
1038 /***********************************************************************
1039 * SetGraphicsMode (GDI32.@)
1041 INT WINAPI
SetGraphicsMode( HDC hdc
, INT mode
)
1044 DC
*dc
= get_dc_ptr( hdc
);
1046 /* One would think that setting the graphics mode to GM_COMPATIBLE
1047 * would also reset the world transformation matrix to the unity
1048 * matrix. However, in Windows, this is not the case. This doesn't
1049 * make a lot of sense to me, but that's the way it is.
1052 if ((mode
> 0) && (mode
<= GM_LAST
))
1054 ret
= dc
->GraphicsMode
;
1055 dc
->GraphicsMode
= mode
;
1057 /* font metrics depend on the graphics mode */
1058 if (ret
!= mode
) SelectObject(dc
->hSelf
, dc
->hFont
);
1059 release_dc_ptr( dc
);
1064 /***********************************************************************
1065 * GetArcDirection (GDI32.@)
1067 INT WINAPI
GetArcDirection( HDC hdc
)
1070 DC
* dc
= get_dc_ptr( hdc
);
1073 ret
= dc
->ArcDirection
;
1074 release_dc_ptr( dc
);
1080 /***********************************************************************
1081 * SetArcDirection (GDI32.@)
1083 INT WINAPI
SetArcDirection( HDC hdc
, INT dir
)
1088 if (dir
!= AD_COUNTERCLOCKWISE
&& dir
!= AD_CLOCKWISE
)
1090 SetLastError(ERROR_INVALID_PARAMETER
);
1094 if ((dc
= get_dc_ptr( hdc
)))
1096 PHYSDEV physdev
= GET_DC_PHYSDEV( dc
, pSetArcDirection
);
1097 dir
= physdev
->funcs
->pSetArcDirection( physdev
, dir
);
1100 ret
= dc
->ArcDirection
;
1101 dc
->ArcDirection
= dir
;
1103 release_dc_ptr( dc
);
1109 /***********************************************************************
1110 * GetWorldTransform (GDI32.@)
1112 BOOL WINAPI
GetWorldTransform( HDC hdc
, LPXFORM xform
)
1115 if (!xform
) return FALSE
;
1116 if (!(dc
= get_dc_ptr( hdc
))) return FALSE
;
1117 *xform
= dc
->xformWorld2Wnd
;
1118 release_dc_ptr( dc
);
1123 /***********************************************************************
1124 * GetTransform (GDI32.@)
1128 * Returns one of the co-ordinate space transforms
1131 * hdc [I] Device context.
1132 * which [I] Which xform to return:
1133 * 0x203 World -> Page transform (that set by SetWorldTransform).
1134 * 0x304 Page -> Device transform (the mapping mode transform).
1135 * 0x204 World -> Device transform (the combination of the above two).
1136 * 0x402 Device -> World transform (the inversion of the above).
1137 * xform [O] The xform.
1140 BOOL WINAPI
GetTransform( HDC hdc
, DWORD which
, XFORM
*xform
)
1143 DC
*dc
= get_dc_ptr( hdc
);
1144 if (!dc
) return FALSE
;
1149 *xform
= dc
->xformWorld2Wnd
;
1153 construct_window_to_viewport(dc
, xform
);
1157 *xform
= dc
->xformWorld2Vport
;
1161 *xform
= dc
->xformVport2World
;
1165 FIXME("Unknown code %x\n", which
);
1169 release_dc_ptr( dc
);
1174 /****************************************************************************
1175 * CombineTransform [GDI32.@]
1176 * Combines two transformation matrices.
1179 * xformResult [O] Stores the result of combining the two matrices
1180 * xform1 [I] Specifies the first matrix to apply
1181 * xform2 [I] Specifies the second matrix to apply
1184 * The same matrix can be passed in for more than one of the parameters.
1188 * Failure: FALSE. Use GetLastError() to determine the cause.
1190 BOOL WINAPI
CombineTransform( LPXFORM xformResult
, const XFORM
*xform1
,
1191 const XFORM
*xform2
)
1195 /* Check for illegal parameters */
1196 if (!xformResult
|| !xform1
|| !xform2
)
1199 /* Create the result in a temporary XFORM, since xformResult may be
1200 * equal to xform1 or xform2 */
1201 xformTemp
.eM11
= xform1
->eM11
* xform2
->eM11
+
1202 xform1
->eM12
* xform2
->eM21
;
1203 xformTemp
.eM12
= xform1
->eM11
* xform2
->eM12
+
1204 xform1
->eM12
* xform2
->eM22
;
1205 xformTemp
.eM21
= xform1
->eM21
* xform2
->eM11
+
1206 xform1
->eM22
* xform2
->eM21
;
1207 xformTemp
.eM22
= xform1
->eM21
* xform2
->eM12
+
1208 xform1
->eM22
* xform2
->eM22
;
1209 xformTemp
.eDx
= xform1
->eDx
* xform2
->eM11
+
1210 xform1
->eDy
* xform2
->eM21
+
1212 xformTemp
.eDy
= xform1
->eDx
* xform2
->eM12
+
1213 xform1
->eDy
* xform2
->eM22
+
1216 /* Copy the result to xformResult */
1217 *xformResult
= xformTemp
;
1223 /***********************************************************************
1224 * SetDCHook (GDI32.@)
1226 * Note: this doesn't exist in Win32, we add it here because user32 needs it.
1228 BOOL WINAPI
SetDCHook( HDC hdc
, DCHOOKPROC hookProc
, DWORD_PTR dwHookData
)
1230 DC
*dc
= get_dc_ptr( hdc
);
1232 if (!dc
) return FALSE
;
1234 dc
->dwHookData
= dwHookData
;
1235 dc
->hookProc
= hookProc
;
1236 release_dc_ptr( dc
);
1241 /***********************************************************************
1242 * GetDCHook (GDI32.@)
1244 * Note: this doesn't exist in Win32, we add it here because user32 needs it.
1246 DWORD_PTR WINAPI
GetDCHook( HDC hdc
, DCHOOKPROC
*proc
)
1248 DC
*dc
= get_dc_ptr( hdc
);
1252 if (proc
) *proc
= dc
->hookProc
;
1253 ret
= dc
->dwHookData
;
1254 release_dc_ptr( dc
);
1259 /***********************************************************************
1260 * SetHookFlags (GDI32.@)
1262 * Note: this doesn't exist in Win32, we add it here because user32 needs it.
1264 WORD WINAPI
SetHookFlags( HDC hdc
, WORD flags
)
1266 DC
*dc
= get_dc_obj( hdc
); /* not get_dc_ptr, this needs to work from any thread */
1271 TRACE("hDC %p, flags %04x\n",hdc
,flags
);
1273 if (flags
& DCHF_INVALIDATEVISRGN
)
1274 ret
= InterlockedExchange( &dc
->dirty
, 1 );
1275 else if (flags
& DCHF_VALIDATEVISRGN
|| !flags
)
1276 ret
= InterlockedExchange( &dc
->dirty
, 0 );
1278 if (flags
& DCHF_DISABLEDC
)
1279 ret
= InterlockedExchange( &dc
->disabled
, 1 );
1280 else if (flags
& DCHF_ENABLEDC
)
1281 ret
= InterlockedExchange( &dc
->disabled
, 0 );
1283 GDI_ReleaseObj( hdc
);
1285 if (flags
& DCHF_RESETDC
) ret
= reset_dc_state( hdc
);
1289 /***********************************************************************
1290 * SetICMMode (GDI32.@)
1292 INT WINAPI
SetICMMode(HDC hdc
, INT iEnableICM
)
1294 /*FIXME: Assume that ICM is always off, and cannot be turned on */
1295 if (iEnableICM
== ICM_OFF
) return ICM_OFF
;
1296 if (iEnableICM
== ICM_ON
) return 0;
1297 if (iEnableICM
== ICM_QUERY
) return ICM_OFF
;
1301 /***********************************************************************
1302 * GetDeviceGammaRamp (GDI32.@)
1304 BOOL WINAPI
GetDeviceGammaRamp(HDC hDC
, LPVOID ptr
)
1307 DC
*dc
= get_dc_ptr( hDC
);
1309 TRACE("%p, %p\n", hDC
, ptr
);
1312 if (GetObjectType( hDC
) != OBJ_MEMDC
)
1314 PHYSDEV physdev
= GET_DC_PHYSDEV( dc
, pGetDeviceGammaRamp
);
1315 ret
= physdev
->funcs
->pGetDeviceGammaRamp( physdev
, ptr
);
1317 else SetLastError( ERROR_INVALID_PARAMETER
);
1318 release_dc_ptr( dc
);
1323 static BOOL
check_gamma_ramps(void *ptr
)
1327 while (ramp
< (WORD
*)ptr
+ 3 * 256)
1329 float r_x
, r_y
, r_lx
, r_ly
, r_d
, r_v
, r_e
, g_avg
, g_min
, g_max
;
1330 unsigned i
, f
, l
, g_n
, c
;
1336 TRACE("inverted or flat gamma ramp (%d->%d), rejected\n", f
, l
);
1340 g_min
= g_max
= g_avg
= 0.0;
1342 /* check gamma ramp entries to estimate the gamma */
1343 TRACE("analyzing gamma ramp (%d->%d)\n", f
, l
);
1344 for (i
=1, g_n
=0; i
<255; i
++)
1346 if (ramp
[i
] < f
|| ramp
[i
] > l
)
1348 TRACE("strange gamma ramp ([%d]=%d for %d->%d), rejected\n", i
, ramp
[i
], f
, l
);
1352 if (!c
) continue; /* avoid log(0) */
1354 /* normalize entry values into 0..1 range */
1355 r_x
= i
/255.0; r_y
= c
/ r_d
;
1356 /* compute logarithms of values */
1357 r_lx
= log(r_x
); r_ly
= log(r_y
);
1358 /* compute gamma for this entry */
1360 /* compute differential (error estimate) for this entry */
1361 /* some games use table-based logarithms that magnifies the error by 128 */
1362 r_e
= -r_lx
* 128 / (c
* r_lx
* r_lx
);
1364 /* compute min & max while compensating for estimated error */
1365 if (!g_n
|| g_min
> (r_v
+ r_e
)) g_min
= r_v
+ r_e
;
1366 if (!g_n
|| g_max
< (r_v
- r_e
)) g_max
= r_v
- r_e
;
1368 /* add to average */
1375 TRACE("no gamma data, shouldn't happen\n");
1379 TRACE("low bias is %d, high is %d, gamma is %5.3f\n", f
, 65535-l
, g_avg
);
1381 /* check that the gamma is reasonably uniform across the ramp */
1382 if (g_max
- g_min
> 12.8)
1384 TRACE("ramp not uniform (max=%f, min=%f, avg=%f), rejected\n", g_max
, g_min
, g_avg
);
1388 /* check that the gamma is not too bright */
1391 TRACE("too bright gamma ( %5.3f), rejected\n", g_avg
);
1401 /***********************************************************************
1402 * SetDeviceGammaRamp (GDI32.@)
1404 BOOL WINAPI
SetDeviceGammaRamp(HDC hDC
, LPVOID ptr
)
1407 DC
*dc
= get_dc_ptr( hDC
);
1409 TRACE("%p, %p\n", hDC
, ptr
);
1412 if (GetObjectType( hDC
) != OBJ_MEMDC
)
1414 PHYSDEV physdev
= GET_DC_PHYSDEV( dc
, pSetDeviceGammaRamp
);
1416 if (check_gamma_ramps(ptr
))
1417 ret
= physdev
->funcs
->pSetDeviceGammaRamp( physdev
, ptr
);
1419 else SetLastError( ERROR_INVALID_PARAMETER
);
1420 release_dc_ptr( dc
);
1425 /***********************************************************************
1426 * GetColorSpace (GDI32.@)
1428 HCOLORSPACE WINAPI
GetColorSpace(HDC hdc
)
1430 /*FIXME Need to do whatever GetColorSpace actually does */
1434 /***********************************************************************
1435 * CreateColorSpaceA (GDI32.@)
1437 HCOLORSPACE WINAPI
CreateColorSpaceA( LPLOGCOLORSPACEA lpLogColorSpace
)
1443 /***********************************************************************
1444 * CreateColorSpaceW (GDI32.@)
1446 HCOLORSPACE WINAPI
CreateColorSpaceW( LPLOGCOLORSPACEW lpLogColorSpace
)
1452 /***********************************************************************
1453 * DeleteColorSpace (GDI32.@)
1455 BOOL WINAPI
DeleteColorSpace( HCOLORSPACE hColorSpace
)
1462 /***********************************************************************
1463 * SetColorSpace (GDI32.@)
1465 HCOLORSPACE WINAPI
SetColorSpace( HDC hDC
, HCOLORSPACE hColorSpace
)
1472 /***********************************************************************
1473 * GetBoundsRect (GDI32.@)
1475 UINT WINAPI
GetBoundsRect(HDC hdc
, LPRECT rect
, UINT flags
)
1480 DC
*dc
= get_dc_ptr( hdc
);
1482 if ( !dc
) return 0;
1484 physdev
= GET_DC_PHYSDEV( dc
, pGetBoundsRect
);
1485 ret
= physdev
->funcs
->pGetBoundsRect( physdev
, &device_rect
, DCB_RESET
);
1488 release_dc_ptr( dc
);
1491 if (dc
->bounds_enabled
&& ret
== DCB_SET
) add_bounds_rect( &dc
->bounds
, &device_rect
);
1495 if (is_rect_empty( &dc
->bounds
))
1497 rect
->left
= rect
->top
= rect
->right
= rect
->bottom
= 0;
1503 rect
->left
= max( rect
->left
, 0 );
1504 rect
->top
= max( rect
->top
, 0 );
1505 rect
->right
= min( rect
->right
, dc
->vis_rect
.right
- dc
->vis_rect
.left
);
1506 rect
->bottom
= min( rect
->bottom
, dc
->vis_rect
.bottom
- dc
->vis_rect
.top
);
1509 dp_to_lp( dc
, (POINT
*)rect
, 2 );
1513 if (flags
& DCB_RESET
) reset_bounds( &dc
->bounds
);
1514 release_dc_ptr( dc
);
1519 /***********************************************************************
1520 * SetBoundsRect (GDI32.@)
1522 UINT WINAPI
SetBoundsRect(HDC hdc
, const RECT
* rect
, UINT flags
)
1528 if ((flags
& DCB_ENABLE
) && (flags
& DCB_DISABLE
)) return 0;
1529 if (!(dc
= get_dc_ptr( hdc
))) return 0;
1531 physdev
= GET_DC_PHYSDEV( dc
, pSetBoundsRect
);
1532 ret
= physdev
->funcs
->pSetBoundsRect( physdev
, &dc
->bounds
, flags
);
1535 release_dc_ptr( dc
);
1539 ret
= (dc
->bounds_enabled
? DCB_ENABLE
: DCB_DISABLE
) |
1540 (is_rect_empty( &dc
->bounds
) ? ret
& DCB_SET
: DCB_SET
);
1542 if (flags
& DCB_RESET
) reset_bounds( &dc
->bounds
);
1544 if ((flags
& DCB_ACCUMULATE
) && rect
)
1548 lp_to_dp( dc
, (POINT
*)&rc
, 2 );
1549 add_bounds_rect( &dc
->bounds
, &rc
);
1552 if (flags
& DCB_ENABLE
) dc
->bounds_enabled
= TRUE
;
1553 if (flags
& DCB_DISABLE
) dc
->bounds_enabled
= FALSE
;
1555 release_dc_ptr( dc
);
1560 /***********************************************************************
1561 * GetRelAbs (GDI32.@)
1563 INT WINAPI
GetRelAbs( HDC hdc
, DWORD dwIgnore
)
1566 DC
*dc
= get_dc_ptr( hdc
);
1569 ret
= dc
->relAbsMode
;
1570 release_dc_ptr( dc
);
1578 /***********************************************************************
1579 * GetBkMode (GDI32.@)
1581 INT WINAPI
GetBkMode( HDC hdc
)
1584 DC
* dc
= get_dc_ptr( hdc
);
1587 ret
= dc
->backgroundMode
;
1588 release_dc_ptr( dc
);
1594 /***********************************************************************
1595 * SetBkMode (GDI32.@)
1597 INT WINAPI
SetBkMode( HDC hdc
, INT mode
)
1602 if ((mode
<= 0) || (mode
> BKMODE_LAST
))
1604 SetLastError(ERROR_INVALID_PARAMETER
);
1607 if ((dc
= get_dc_ptr( hdc
)))
1609 PHYSDEV physdev
= GET_DC_PHYSDEV( dc
, pSetBkMode
);
1610 mode
= physdev
->funcs
->pSetBkMode( physdev
, mode
);
1613 ret
= dc
->backgroundMode
;
1614 dc
->backgroundMode
= mode
;
1616 release_dc_ptr( dc
);
1622 /***********************************************************************
1625 INT WINAPI
GetROP2( HDC hdc
)
1628 DC
* dc
= get_dc_ptr( hdc
);
1632 release_dc_ptr( dc
);
1638 /***********************************************************************
1641 INT WINAPI
SetROP2( HDC hdc
, INT mode
)
1646 if ((mode
< R2_BLACK
) || (mode
> R2_WHITE
))
1648 SetLastError(ERROR_INVALID_PARAMETER
);
1651 if ((dc
= get_dc_ptr( hdc
)))
1653 PHYSDEV physdev
= GET_DC_PHYSDEV( dc
, pSetROP2
);
1654 mode
= physdev
->funcs
->pSetROP2( physdev
, mode
);
1660 release_dc_ptr( dc
);
1666 /***********************************************************************
1667 * SetRelAbs (GDI32.@)
1669 INT WINAPI
SetRelAbs( HDC hdc
, INT mode
)
1674 if ((mode
!= ABSOLUTE
) && (mode
!= RELATIVE
))
1676 SetLastError(ERROR_INVALID_PARAMETER
);
1679 if ((dc
= get_dc_ptr( hdc
)))
1681 PHYSDEV physdev
= GET_DC_PHYSDEV( dc
, pSetRelAbs
);
1682 mode
= physdev
->funcs
->pSetRelAbs( physdev
, mode
);
1685 ret
= dc
->relAbsMode
;
1686 dc
->relAbsMode
= mode
;
1688 release_dc_ptr( dc
);
1694 /***********************************************************************
1695 * GetPolyFillMode (GDI32.@)
1697 INT WINAPI
GetPolyFillMode( HDC hdc
)
1700 DC
* dc
= get_dc_ptr( hdc
);
1703 ret
= dc
->polyFillMode
;
1704 release_dc_ptr( dc
);
1710 /***********************************************************************
1711 * SetPolyFillMode (GDI32.@)
1713 INT WINAPI
SetPolyFillMode( HDC hdc
, INT mode
)
1718 if ((mode
<= 0) || (mode
> POLYFILL_LAST
))
1720 SetLastError(ERROR_INVALID_PARAMETER
);
1723 if ((dc
= get_dc_ptr( hdc
)))
1725 PHYSDEV physdev
= GET_DC_PHYSDEV( dc
, pSetPolyFillMode
);
1726 mode
= physdev
->funcs
->pSetPolyFillMode( physdev
, mode
);
1729 ret
= dc
->polyFillMode
;
1730 dc
->polyFillMode
= mode
;
1732 release_dc_ptr( dc
);
1738 /***********************************************************************
1739 * GetStretchBltMode (GDI32.@)
1741 INT WINAPI
GetStretchBltMode( HDC hdc
)
1744 DC
* dc
= get_dc_ptr( hdc
);
1747 ret
= dc
->stretchBltMode
;
1748 release_dc_ptr( dc
);
1754 /***********************************************************************
1755 * SetStretchBltMode (GDI32.@)
1757 INT WINAPI
SetStretchBltMode( HDC hdc
, INT mode
)
1762 if ((mode
<= 0) || (mode
> MAXSTRETCHBLTMODE
))
1764 SetLastError(ERROR_INVALID_PARAMETER
);
1767 if ((dc
= get_dc_ptr( hdc
)))
1769 PHYSDEV physdev
= GET_DC_PHYSDEV( dc
, pSetStretchBltMode
);
1770 mode
= physdev
->funcs
->pSetStretchBltMode( physdev
, mode
);
1773 ret
= dc
->stretchBltMode
;
1774 dc
->stretchBltMode
= mode
;
1776 release_dc_ptr( dc
);
1782 /***********************************************************************
1783 * GetMapMode (GDI32.@)
1785 INT WINAPI
GetMapMode( HDC hdc
)
1788 DC
* dc
= get_dc_ptr( hdc
);
1792 release_dc_ptr( dc
);
1798 /***********************************************************************
1799 * GetBrushOrgEx (GDI32.@)
1801 BOOL WINAPI
GetBrushOrgEx( HDC hdc
, LPPOINT pt
)
1803 DC
* dc
= get_dc_ptr( hdc
);
1804 if (!dc
) return FALSE
;
1805 *pt
= dc
->brush_org
;
1806 release_dc_ptr( dc
);
1811 /***********************************************************************
1812 * GetCurrentPositionEx (GDI32.@)
1814 BOOL WINAPI
GetCurrentPositionEx( HDC hdc
, LPPOINT pt
)
1816 DC
* dc
= get_dc_ptr( hdc
);
1817 if (!dc
) return FALSE
;
1819 release_dc_ptr( dc
);
1824 /***********************************************************************
1825 * GetViewportExtEx (GDI32.@)
1827 BOOL WINAPI
GetViewportExtEx( HDC hdc
, LPSIZE size
)
1829 DC
* dc
= get_dc_ptr( hdc
);
1830 if (!dc
) return FALSE
;
1831 *size
= dc
->vport_ext
;
1832 release_dc_ptr( dc
);
1837 /***********************************************************************
1838 * GetViewportOrgEx (GDI32.@)
1840 BOOL WINAPI
GetViewportOrgEx( HDC hdc
, LPPOINT pt
)
1842 DC
* dc
= get_dc_ptr( hdc
);
1843 if (!dc
) return FALSE
;
1844 *pt
= dc
->vport_org
;
1845 release_dc_ptr( dc
);
1850 /***********************************************************************
1851 * GetWindowExtEx (GDI32.@)
1853 BOOL WINAPI
GetWindowExtEx( HDC hdc
, LPSIZE size
)
1855 DC
* dc
= get_dc_ptr( hdc
);
1856 if (!dc
) return FALSE
;
1857 *size
= dc
->wnd_ext
;
1858 release_dc_ptr( dc
);
1863 /***********************************************************************
1864 * GetWindowOrgEx (GDI32.@)
1866 BOOL WINAPI
GetWindowOrgEx( HDC hdc
, LPPOINT pt
)
1868 DC
* dc
= get_dc_ptr( hdc
);
1869 if (!dc
) return FALSE
;
1871 release_dc_ptr( dc
);
1876 /***********************************************************************
1877 * GetLayout (GDI32.@)
1879 * Gets left->right or right->left text layout flags of a dc.
1882 DWORD WINAPI
GetLayout(HDC hdc
)
1884 DWORD layout
= GDI_ERROR
;
1886 DC
* dc
= get_dc_ptr( hdc
);
1889 layout
= dc
->layout
;
1890 release_dc_ptr( dc
);
1893 TRACE("hdc : %p, layout : %08x\n", hdc
, layout
);
1898 /***********************************************************************
1899 * SetLayout (GDI32.@)
1901 * Sets left->right or right->left text layout flags of a dc.
1904 DWORD WINAPI
SetLayout(HDC hdc
, DWORD layout
)
1906 DWORD oldlayout
= GDI_ERROR
;
1908 DC
* dc
= get_dc_ptr( hdc
);
1911 PHYSDEV physdev
= GET_DC_PHYSDEV( dc
, pSetLayout
);
1912 layout
= physdev
->funcs
->pSetLayout( physdev
, layout
);
1913 if (layout
!= GDI_ERROR
)
1915 oldlayout
= dc
->layout
;
1916 dc
->layout
= layout
;
1917 if (layout
!= oldlayout
)
1919 if (layout
& LAYOUT_RTL
) dc
->MapMode
= MM_ANISOTROPIC
;
1920 DC_UpdateXforms( dc
);
1923 release_dc_ptr( dc
);
1926 TRACE("hdc : %p, old layout : %08x, new layout : %08x\n", hdc
, oldlayout
, layout
);
1931 /***********************************************************************
1932 * GetDCBrushColor (GDI32.@)
1934 COLORREF WINAPI
GetDCBrushColor(HDC hdc
)
1937 COLORREF dcBrushColor
= CLR_INVALID
;
1939 TRACE("hdc(%p)\n", hdc
);
1941 dc
= get_dc_ptr( hdc
);
1944 dcBrushColor
= dc
->dcBrushColor
;
1945 release_dc_ptr( dc
);
1948 return dcBrushColor
;
1951 /***********************************************************************
1952 * SetDCBrushColor (GDI32.@)
1954 COLORREF WINAPI
SetDCBrushColor(HDC hdc
, COLORREF crColor
)
1957 COLORREF oldClr
= CLR_INVALID
;
1959 TRACE("hdc(%p) crColor(%08x)\n", hdc
, crColor
);
1961 dc
= get_dc_ptr( hdc
);
1964 PHYSDEV physdev
= GET_DC_PHYSDEV( dc
, pSetDCBrushColor
);
1965 crColor
= physdev
->funcs
->pSetDCBrushColor( physdev
, crColor
);
1966 if (crColor
!= CLR_INVALID
)
1968 oldClr
= dc
->dcBrushColor
;
1969 dc
->dcBrushColor
= crColor
;
1971 release_dc_ptr( dc
);
1977 /***********************************************************************
1978 * GetDCPenColor (GDI32.@)
1980 COLORREF WINAPI
GetDCPenColor(HDC hdc
)
1983 COLORREF dcPenColor
= CLR_INVALID
;
1985 TRACE("hdc(%p)\n", hdc
);
1987 dc
= get_dc_ptr( hdc
);
1990 dcPenColor
= dc
->dcPenColor
;
1991 release_dc_ptr( dc
);
1997 /***********************************************************************
1998 * SetDCPenColor (GDI32.@)
2000 COLORREF WINAPI
SetDCPenColor(HDC hdc
, COLORREF crColor
)
2003 COLORREF oldClr
= CLR_INVALID
;
2005 TRACE("hdc(%p) crColor(%08x)\n", hdc
, crColor
);
2007 dc
= get_dc_ptr( hdc
);
2010 PHYSDEV physdev
= GET_DC_PHYSDEV( dc
, pSetDCPenColor
);
2011 crColor
= physdev
->funcs
->pSetDCPenColor( physdev
, crColor
);
2012 if (crColor
!= CLR_INVALID
)
2014 oldClr
= dc
->dcPenColor
;
2015 dc
->dcPenColor
= crColor
;
2017 release_dc_ptr( dc
);
2023 /***********************************************************************
2024 * CancelDC (GDI32.@)
2026 BOOL WINAPI
CancelDC(HDC hdc
)
2032 /*******************************************************************
2033 * GetMiterLimit [GDI32.@]
2037 BOOL WINAPI
GetMiterLimit(HDC hdc
, PFLOAT peLimit
)
2042 TRACE("(%p,%p)\n", hdc
, peLimit
);
2044 dc
= get_dc_ptr( hdc
);
2048 *peLimit
= dc
->miterLimit
;
2050 release_dc_ptr( dc
);
2056 /*******************************************************************
2057 * SetMiterLimit [GDI32.@]
2061 BOOL WINAPI
SetMiterLimit(HDC hdc
, FLOAT eNewLimit
, PFLOAT peOldLimit
)
2066 TRACE("(%p,%f,%p)\n", hdc
, eNewLimit
, peOldLimit
);
2068 dc
= get_dc_ptr( hdc
);
2072 *peOldLimit
= dc
->miterLimit
;
2073 dc
->miterLimit
= eNewLimit
;
2074 release_dc_ptr( dc
);
2080 /*******************************************************************
2081 * GdiIsMetaPrintDC [GDI32.@]
2083 BOOL WINAPI
GdiIsMetaPrintDC(HDC hdc
)
2089 /*******************************************************************
2090 * GdiIsMetaFileDC [GDI32.@]
2092 BOOL WINAPI
GdiIsMetaFileDC(HDC hdc
)
2096 switch( GetObjectType( hdc
) )
2105 /*******************************************************************
2106 * GdiIsPlayMetafileDC [GDI32.@]
2108 BOOL WINAPI
GdiIsPlayMetafileDC(HDC hdc
)