?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
gdi32: Store char_extra in DC_ATTR.
[wine.git] / dlls / gdi32 / dc.c
blob5f2f129532c6a72548a3fb0e0bbc71f411f9af0c
1 /*
2 * GDI Device Context functions
3 *
4 * Copyright 1993 Alexandre Julliard
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #include <assert.h>
22 #include <stdarg.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include "windef.h"
26 #include "winbase.h"
27 #include "wingdi.h"
28 #include "winreg.h"
29 #include "winnls.h"
30 #include "winternl.h"
31 #include "winerror.h"
32 #include "ntgdi_private.h"
33 #include "gdi_private.h"
34 #include "wine/debug.h"
35
36 WINE_DEFAULT_DEBUG_CHANNEL(dc);
37
38 static BOOL DC_DeleteObject( HGDIOBJ handle );
39
40 static const struct gdi_obj_funcs dc_funcs =
41 {
42 NULL, /* pGetObjectW */
43 NULL, /* pUnrealizeObject */
44 DC_DeleteObject /* pDeleteObject */
45 };
46
47
48 static inline DC *get_dc_obj( HDC hdc )
49 {
50 WORD type;
51 DC *dc = get_any_obj_ptr( hdc, &type );
52 if (!dc) return NULL;
53
54 switch (type)
55 {
56 case NTGDI_OBJ_DC:
57 case NTGDI_OBJ_MEMDC:
58 case NTGDI_OBJ_METADC:
59 case NTGDI_OBJ_ENHMETADC:
60 return dc;
61 default:
62 GDI_ReleaseObj( hdc );
63 SetLastError( ERROR_INVALID_HANDLE );
64 return NULL;
65 }
66 }
67
68
69 /***********************************************************************
70 * set_initial_dc_state
71 */
72 static void set_initial_dc_state( DC *dc )
73 {
74 dc->attr->wnd_org.x = 0;
75 dc->attr->wnd_org.y = 0;
76 dc->attr->wnd_ext.cx = 1;
77 dc->attr->wnd_ext.cy = 1;
78 dc->attr->vport_org.x = 0;
79 dc->attr->vport_org.y = 0;
80 dc->attr->vport_ext.cx = 1;
81 dc->attr->vport_ext.cy = 1;
82 dc->attr->miter_limit = 10.0f; /* 10.0 is the default, from MSDN */
83 dc->attr->layout = 0;
84 dc->font_code_page = CP_ACP;
85 dc->attr->rop_mode = R2_COPYPEN;
86 dc->attr->poly_fill_mode = ALTERNATE;
87 dc->attr->stretch_blt_mode = BLACKONWHITE;
88 dc->attr->rel_abs_mode = ABSOLUTE;
89 dc->attr->background_mode = OPAQUE;
90 dc->attr->background_color = RGB( 255, 255, 255 );
91 dc->attr->brush_color = RGB( 255, 255, 255 );
92 dc->attr->pen_color = RGB( 0, 0, 0 );
93 dc->attr->text_color = RGB( 0, 0, 0 );
94 dc->attr->brush_org.x = 0;
95 dc->attr->brush_org.y = 0;
96 dc->mapperFlags = 0;
97 dc->attr->text_align = TA_LEFT | TA_TOP | TA_NOUPDATECP;
98 dc->attr->char_extra = 0;
99 dc->breakExtra = 0;
100 dc->breakRem = 0;
101 dc->attr->map_mode = MM_TEXT;
102 dc->attr->graphics_mode = GM_COMPATIBLE;
103 dc->attr->cur_pos.x = 0;
104 dc->attr->cur_pos.y = 0;
105 dc->attr->arc_direction = AD_COUNTERCLOCKWISE;
106 dc->xformWorld2Wnd.eM11 = 1.0f;
107 dc->xformWorld2Wnd.eM12 = 0.0f;
108 dc->xformWorld2Wnd.eM21 = 0.0f;
109 dc->xformWorld2Wnd.eM22 = 1.0f;
110 dc->xformWorld2Wnd.eDx = 0.0f;
111 dc->xformWorld2Wnd.eDy = 0.0f;
112 dc->xformWorld2Vport = dc->xformWorld2Wnd;
113 dc->xformVport2World = dc->xformWorld2Wnd;
114 dc->vport2WorldValid = TRUE;
115
116 reset_bounds( &dc->bounds );
117 }
118
119 /***********************************************************************
120 * alloc_dc_ptr
121 */
122 DC *alloc_dc_ptr( WORD magic )
123 {
124 DC *dc;
125
126 if (!(dc = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*dc) ))) return NULL;
127 if (!(dc->attr = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*dc->attr))))
128 {
129 HeapFree( GetProcessHeap(), 0, dc->attr );
130 return NULL;
131 }
132
133 dc->nulldrv.funcs = &null_driver;
134 dc->physDev = &dc->nulldrv;
135 dc->thread = GetCurrentThreadId();
136 dc->refcount = 1;
137 dc->hPen = GDI_inc_ref_count( GetStockObject( BLACK_PEN ));
138 dc->hBrush = GDI_inc_ref_count( GetStockObject( WHITE_BRUSH ));
139 dc->hFont = GDI_inc_ref_count( GetStockObject( SYSTEM_FONT ));
140 dc->hPalette = GetStockObject( DEFAULT_PALETTE );
141
142 set_initial_dc_state( dc );
143
144 if (!(dc->hSelf = alloc_gdi_handle( &dc->obj, magic, &dc_funcs )))
145 {
146 HeapFree( GetProcessHeap(), 0, dc->attr );
147 HeapFree( GetProcessHeap(), 0, dc );
148 return NULL;
149 }
150 dc->nulldrv.hdc = dc->hSelf;
151 set_gdi_client_ptr( dc->hSelf, dc->attr );
152
153 if (!font_driver.pCreateDC( &dc->physDev, NULL, NULL, NULL, NULL ))
154 {
155 free_dc_ptr( dc );
156 return NULL;
157 }
158 return dc;
159 }
160
161
162
163 /***********************************************************************
164 * free_dc_state
165 */
166 static void free_dc_state( DC *dc )
167 {
168 if (dc->hClipRgn) DeleteObject( dc->hClipRgn );
169 if (dc->hMetaRgn) DeleteObject( dc->hMetaRgn );
170 if (dc->hVisRgn) DeleteObject( dc->hVisRgn );
171 if (dc->region) DeleteObject( dc->region );
172 if (dc->path) free_gdi_path( dc->path );
173 HeapFree( GetProcessHeap(), 0, dc->attr );
174 HeapFree( GetProcessHeap(), 0, dc );
175 }
176
177
178 /***********************************************************************
179 * free_dc_ptr
180 */
181 void free_dc_ptr( DC *dc )
182 {
183 assert( dc->refcount == 1 );
184
185 while (dc->physDev != &dc->nulldrv)
186 {
187 PHYSDEV physdev = dc->physDev;
188 dc->physDev = physdev->next;
189 physdev->funcs->pDeleteDC( physdev );
190 }
191 GDI_dec_ref_count( dc->hPen );
192 GDI_dec_ref_count( dc->hBrush );
193 GDI_dec_ref_count( dc->hFont );
194 if (dc->hBitmap) GDI_dec_ref_count( dc->hBitmap );
195 free_gdi_handle( dc->hSelf );
196 free_dc_state( dc );
197 }
198
199
200 /***********************************************************************
201 * get_dc_ptr
202 *
203 * Retrieve a DC pointer but release the GDI lock.
204 */
205 DC *get_dc_ptr( HDC hdc )
206 {
207 DC *dc = get_dc_obj( hdc );
208 if (!dc) return NULL;
209 if (dc->attr->disabled)
210 {
211 GDI_ReleaseObj( hdc );
212 return NULL;
213 }
214
215 if (!InterlockedCompareExchange( &dc->refcount, 1, 0 ))
216 {
217 dc->thread = GetCurrentThreadId();
218 }
219 else if (dc->thread != GetCurrentThreadId())
220 {
221 WARN( "dc %p belongs to thread %04x\n", hdc, dc->thread );
222 GDI_ReleaseObj( hdc );
223 return NULL;
224 }
225 else InterlockedIncrement( &dc->refcount );
226
227 GDI_ReleaseObj( hdc );
228 return dc;
229 }
230
231
232 /***********************************************************************
233 * release_dc_ptr
234 */
235 void release_dc_ptr( DC *dc )
236 {
237 LONG ref;
238
239 dc->thread = 0;
240 ref = InterlockedDecrement( &dc->refcount );
241 assert( ref >= 0 );
242 if (ref) dc->thread = GetCurrentThreadId(); /* we still own it */
243 }
244
245
246 /***********************************************************************
247 * update_dc
248 *
249 * Make sure the DC vis region is up to date.
250 * This function may call up to USER so the GDI lock should _not_
251 * be held when calling it.
252 */
253 void update_dc( DC *dc )
254 {
255 if (InterlockedExchange( &dc->dirty, 0 ) && dc->hookProc)
256 dc->hookProc( dc->hSelf, DCHC_INVALIDVISRGN, dc->dwHookData, 0 );
257 }
258
259
260 /***********************************************************************
261 * DC_DeleteObject
262 */
263 static BOOL DC_DeleteObject( HGDIOBJ handle )
264 {
265 return DeleteDC( handle );
266 }
267
268
269 /***********************************************************************
270 * DC_InitDC
271 *
272 * Setup device-specific DC values for a newly created DC.
273 */
274 void DC_InitDC( DC* dc )
275 {
276 PHYSDEV physdev = GET_DC_PHYSDEV( dc, pRealizeDefaultPalette );
277 physdev->funcs->pRealizeDefaultPalette( physdev );
278 SetTextColor( dc->hSelf, dc->attr->text_color );
279 SetBkColor( dc->hSelf, dc->attr->background_color );
280 NtGdiSelectPen( dc->hSelf, dc->hPen );
281 NtGdiSelectBrush( dc->hSelf, dc->hBrush );
282 NtGdiSelectFont( dc->hSelf, dc->hFont );
283 update_dc_clipping( dc );
284 NtGdiSetVirtualResolution( dc->hSelf, 0, 0, 0, 0 );
285 physdev = GET_DC_PHYSDEV( dc, pSetBoundsRect );
286 physdev->funcs->pSetBoundsRect( physdev, &dc->bounds, dc->bounds_enabled ? DCB_ENABLE : DCB_DISABLE );
287 }
288
289
290 /***********************************************************************
291 * DC_InvertXform
292 *
293 * Computes the inverse of the transformation xformSrc and stores it to
294 * xformDest. Returns TRUE if successful or FALSE if the xformSrc matrix
295 * is singular.
296 */
297 static BOOL DC_InvertXform( const XFORM *xformSrc, XFORM *xformDest )
298 {
299 double determinant;
300
301 determinant = xformSrc->eM11*xformSrc->eM22 -
302 xformSrc->eM12*xformSrc->eM21;
303 if (determinant > -1e-12 && determinant < 1e-12)
304 return FALSE;
305
306 xformDest->eM11 = xformSrc->eM22 / determinant;
307 xformDest->eM12 = -xformSrc->eM12 / determinant;
308 xformDest->eM21 = -xformSrc->eM21 / determinant;
309 xformDest->eM22 = xformSrc->eM11 / determinant;
310 xformDest->eDx = -xformSrc->eDx * xformDest->eM11 -
311 xformSrc->eDy * xformDest->eM21;
312 xformDest->eDy = -xformSrc->eDx * xformDest->eM12 -
313 xformSrc->eDy * xformDest->eM22;
314
315 return TRUE;
316 }
317
318 /* Construct a transformation to do the window-to-viewport conversion */
319 static void construct_window_to_viewport(DC *dc, XFORM *xform)
320 {
321 double scaleX, scaleY;
322 scaleX = (double)dc->attr->vport_ext.cx / (double)dc->attr->wnd_ext.cx;
323 scaleY = (double)dc->attr->vport_ext.cy / (double)dc->attr->wnd_ext.cy;
324
325 if (dc->attr->layout & LAYOUT_RTL) scaleX = -scaleX;
326 xform->eM11 = scaleX;
327 xform->eM12 = 0.0;
328 xform->eM21 = 0.0;
329 xform->eM22 = scaleY;
330 xform->eDx = (double)dc->attr->vport_org.x - scaleX * (double)dc->attr->wnd_org.x;
331 xform->eDy = (double)dc->attr->vport_org.y - scaleY * (double)dc->attr->wnd_org.y;
332 if (dc->attr->layout & LAYOUT_RTL)
333 xform->eDx = dc->attr->vis_rect.right - dc->attr->vis_rect.left - 1 - xform->eDx;
334 }
335
336 /***********************************************************************
337 * linear_xform_cmp
338 *
339 * Compares the linear transform portion of two XFORMs (i.e. the 2x2 submatrix).
340 * Returns 0 if they match.
341 */
342 static inline int linear_xform_cmp( const XFORM *a, const XFORM *b )
343 {
344 return memcmp( a, b, FIELD_OFFSET( XFORM, eDx ) );
345 }
346
347 /***********************************************************************
348 * DC_UpdateXforms
349 *
350 * Updates the xformWorld2Vport, xformVport2World and vport2WorldValid
351 * fields of the specified DC by creating a transformation that
352 * represents the current mapping mode and combining it with the DC's
353 * world transform. This function should be called whenever the
354 * parameters associated with the mapping mode (window and viewport
355 * extents and origins) or the world transform change.
356 */
357 void DC_UpdateXforms( DC *dc )
358 {
359 XFORM xformWnd2Vport, oldworld2vport;
360
361 construct_window_to_viewport(dc, &xformWnd2Vport);
362
363 oldworld2vport = dc->xformWorld2Vport;
364 /* Combine with the world transformation */
365 CombineTransform( &dc->xformWorld2Vport, &dc->xformWorld2Wnd,
366 &xformWnd2Vport );
367
368 /* Create inverse of world-to-viewport transformation */
369 dc->vport2WorldValid = DC_InvertXform( &dc->xformWorld2Vport,
370 &dc->xformVport2World );
371
372 /* Reselect the font and pen back into the dc so that the size
373 gets updated. */
374 if (linear_xform_cmp( &oldworld2vport, &dc->xformWorld2Vport ) &&
375 GetObjectType( dc->hSelf ) != OBJ_METADC)
376 {
377 NtGdiSelectFont(dc->hSelf, dc->hFont);
378 NtGdiSelectPen(dc->hSelf, dc->hPen);
379 }
380 }
381
382
383 /***********************************************************************
384 * nulldrv_RestoreDC
385 */
386 BOOL CDECL nulldrv_RestoreDC( PHYSDEV dev, INT level )
387 {
388 DC *dcs, *first_dcs, *dc = get_nulldrv_dc( dev );
389 INT save_level;
390
391 /* find the state level to restore */
392
393 if (abs(level) > dc->saveLevel || level == 0) return FALSE;
394 if (level < 0) level = dc->saveLevel + level + 1;
395 first_dcs = dc->saved_dc;
396 for (dcs = first_dcs, save_level = dc->saveLevel; save_level > level; save_level--)
397 dcs = dcs->saved_dc;
398
399 /* restore the state */
400
401 if (!PATH_RestorePath( dc, dcs )) return FALSE;
402
403 dc->attr->layout = dcs->attr->layout;
404 dc->attr->rop_mode = dcs->attr->rop_mode;
405 dc->attr->poly_fill_mode = dcs->attr->poly_fill_mode;
406 dc->attr->stretch_blt_mode = dcs->attr->stretch_blt_mode;
407 dc->attr->rel_abs_mode = dcs->attr->rel_abs_mode;
408 dc->attr->background_mode = dcs->attr->background_mode;
409 dc->attr->background_color = dcs->attr->background_color;
410 dc->attr->text_color = dcs->attr->text_color;
411 dc->attr->brush_color = dcs->attr->brush_color;
412 dc->attr->pen_color = dcs->attr->pen_color;
413 dc->attr->brush_org = dcs->attr->brush_org;
414 dc->mapperFlags = dcs->mapperFlags;
415 dc->attr->text_align = dcs->attr->text_align;
416 dc->attr->char_extra = dcs->attr->char_extra;
417 dc->breakExtra = dcs->breakExtra;
418 dc->breakRem = dcs->breakRem;
419 dc->attr->map_mode = dcs->attr->map_mode;
420 dc->attr->graphics_mode = dcs->attr->graphics_mode;
421 dc->attr->cur_pos = dcs->attr->cur_pos;
422 dc->attr->arc_direction = dcs->attr->arc_direction;
423 dc->xformWorld2Wnd = dcs->xformWorld2Wnd;
424 dc->xformWorld2Vport = dcs->xformWorld2Vport;
425 dc->xformVport2World = dcs->xformVport2World;
426 dc->vport2WorldValid = dcs->vport2WorldValid;
427 dc->attr->wnd_org = dcs->attr->wnd_org;
428 dc->attr->wnd_ext = dcs->attr->wnd_ext;
429 dc->attr->vport_org = dcs->attr->vport_org;
430 dc->attr->vport_ext = dcs->attr->vport_ext;
431 dc->virtual_res = dcs->virtual_res;
432 dc->virtual_size = dcs->virtual_size;
433
434 if (dcs->hClipRgn)
435 {
436 if (!dc->hClipRgn) dc->hClipRgn = NtGdiCreateRectRgn( 0, 0, 0, 0 );
437 NtGdiCombineRgn( dc->hClipRgn, dcs->hClipRgn, 0, RGN_COPY );
438 }
439 else
440 {
441 if (dc->hClipRgn) DeleteObject( dc->hClipRgn );
442 dc->hClipRgn = 0;
443 }
444 if (dcs->hMetaRgn)
445 {
446 if (!dc->hMetaRgn) dc->hMetaRgn = NtGdiCreateRectRgn( 0, 0, 0, 0 );
447 NtGdiCombineRgn( dc->hMetaRgn, dcs->hMetaRgn, 0, RGN_COPY );
448 }
449 else
450 {
451 if (dc->hMetaRgn) DeleteObject( dc->hMetaRgn );
452 dc->hMetaRgn = 0;
453 }
454 DC_UpdateXforms( dc );
455 update_dc_clipping( dc );
456
457 NtGdiSelectBitmap( dev->hdc, dcs->hBitmap );
458 NtGdiSelectBrush( dev->hdc, dcs->hBrush );
459 NtGdiSelectFont( dev->hdc, dcs->hFont );
460 NtGdiSelectPen( dev->hdc, dcs->hPen );
461 SetBkColor( dev->hdc, dcs->attr->background_color);
462 SetTextColor( dev->hdc, dcs->attr->text_color);
463 GDISelectPalette( dev->hdc, dcs->hPalette, FALSE );
464
465 dc->saved_dc = dcs->saved_dc;
466 dcs->saved_dc = 0;
467 dc->saveLevel = save_level - 1;
468
469 /* now destroy all the saved DCs */
470
471 while (first_dcs)
472 {
473 DC *next = first_dcs->saved_dc;
474 free_dc_state( first_dcs );
475 first_dcs = next;
476 }
477 return TRUE;
478 }
479
480
481 /***********************************************************************
482 * reset_dc_state
483 */
484 static BOOL reset_dc_state( HDC hdc )
485 {
486 DC *dc, *dcs, *next;
487
488 if (!(dc = get_dc_ptr( hdc ))) return FALSE;
489
490 set_initial_dc_state( dc );
491 SetBkColor( hdc, RGB( 255, 255, 255 ));
492 SetTextColor( hdc, RGB( 0, 0, 0 ));
493 NtGdiSelectBrush( hdc, GetStockObject( WHITE_BRUSH ));
494 NtGdiSelectFont( hdc, GetStockObject( SYSTEM_FONT ));
495 NtGdiSelectPen( hdc, GetStockObject( BLACK_PEN ));
496 NtGdiSetVirtualResolution( hdc, 0, 0, 0, 0 );
497 GDISelectPalette( hdc, GetStockObject( DEFAULT_PALETTE ), FALSE );
498 NtGdiSetBoundsRect( hdc, NULL, DCB_DISABLE );
499 AbortPath( hdc );
500
501 if (dc->hClipRgn) DeleteObject( dc->hClipRgn );
502 if (dc->hMetaRgn) DeleteObject( dc->hMetaRgn );
503 dc->hClipRgn = 0;
504 dc->hMetaRgn = 0;
505 update_dc_clipping( dc );
506
507 for (dcs = dc->saved_dc; dcs; dcs = next)
508 {
509 next = dcs->saved_dc;
510 free_dc_state( dcs );
511 }
512 dc->saved_dc = NULL;
513 dc->saveLevel = 0;
514 release_dc_ptr( dc );
515 return TRUE;
516 }
517
518
519 /***********************************************************************
520 * NtGdiSaveDC (win32u.@)
521 */
522 INT WINAPI NtGdiSaveDC( HDC hdc )
523 {
524 DC *dc, *newdc;
525 INT ret;
526
527 if (!(dc = get_dc_ptr( hdc ))) return 0;
528
529 if (!(newdc = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*newdc ))))
530 {
531 release_dc_ptr( dc );
532 return 0;
533 }
534 if (!(newdc->attr = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*newdc->attr) )))
535 {
536 HeapFree( GetProcessHeap(), 0, newdc );
537 release_dc_ptr( dc );
538 return 0;
539 }
540
541 *newdc->attr = *dc->attr;
542 newdc->hPen = dc->hPen;
543 newdc->hBrush = dc->hBrush;
544 newdc->hFont = dc->hFont;
545 newdc->hBitmap = dc->hBitmap;
546 newdc->hPalette = dc->hPalette;
547 newdc->mapperFlags = dc->mapperFlags;
548 newdc->breakExtra = dc->breakExtra;
549 newdc->breakRem = dc->breakRem;
550 newdc->xformWorld2Wnd = dc->xformWorld2Wnd;
551 newdc->xformWorld2Vport = dc->xformWorld2Vport;
552 newdc->xformVport2World = dc->xformVport2World;
553 newdc->vport2WorldValid = dc->vport2WorldValid;
554 newdc->virtual_res = dc->virtual_res;
555 newdc->virtual_size = dc->virtual_size;
556
557 /* Get/SetDCState() don't change hVisRgn field ("Undoc. Windows" p.559). */
558
559 if (dc->hClipRgn)
560 {
561 newdc->hClipRgn = NtGdiCreateRectRgn( 0, 0, 0, 0 );
562 NtGdiCombineRgn( newdc->hClipRgn, dc->hClipRgn, 0, RGN_COPY );
563 }
564 if (dc->hMetaRgn)
565 {
566 newdc->hMetaRgn = NtGdiCreateRectRgn( 0, 0, 0, 0 );
567 NtGdiCombineRgn( newdc->hMetaRgn, dc->hMetaRgn, 0, RGN_COPY );
568 }
569
570 if (!PATH_SavePath( newdc, dc ))
571 {
572 release_dc_ptr( dc );
573 free_dc_state( newdc );
574 return 0;
575 }
576
577 newdc->saved_dc = dc->saved_dc;
578 dc->saved_dc = newdc;
579 ret = ++dc->saveLevel;
580 release_dc_ptr( dc );
581 return ret;
582 }
583
584
585 /***********************************************************************
586 * RestoreDC (GDI32.@)
587 */
588 BOOL WINAPI RestoreDC( HDC hdc, INT level )
589 {
590 PHYSDEV physdev;
591 DC *dc;
592 BOOL success = FALSE;
593
594 TRACE("%p %d\n", hdc, level );
595 if ((dc = get_dc_ptr( hdc )))
596 {
597 update_dc( dc );
598 physdev = GET_DC_PHYSDEV( dc, pRestoreDC );
599 success = physdev->funcs->pRestoreDC( physdev, level );
600 release_dc_ptr( dc );
601 }
602 return success;
603 }
604
605
606 /***********************************************************************
607 * CreateDCW (GDI32.@)
608 */
609 HDC WINAPI CreateDCW( LPCWSTR driver, LPCWSTR device, LPCWSTR output,
610 const DEVMODEW *initData )
611 {
612 const WCHAR *display, *p;
613 HDC hdc;
614 DC * dc;
615 const struct gdi_dc_funcs *funcs;
616 WCHAR buf[300];
617
618 GDI_CheckNotLock();
619
620 if (!device || !DRIVER_GetDriverName( device, buf, 300 ))
621 {
622 if (!driver)
623 {
624 ERR( "no device found for %s\n", debugstr_w(device) );
625 return 0;
626 }
627 lstrcpyW(buf, driver);
628 }
629
630 if (!(funcs = DRIVER_load_driver( buf )))
631 {
632 ERR( "no driver found for %s\n", debugstr_w(buf) );
633 return 0;
634 }
635 if (!(dc = alloc_dc_ptr( NTGDI_OBJ_DC ))) return 0;
636 hdc = dc->hSelf;
637
638 dc->hBitmap = GDI_inc_ref_count( GetStockObject( DEFAULT_BITMAP ));
639
640 TRACE("(driver=%s, device=%s, output=%s): returning %p\n",
641 debugstr_w(driver), debugstr_w(device), debugstr_w(output), dc->hSelf );
642
643 if (funcs->pCreateDC)
644 {
645 if (!funcs->pCreateDC( &dc->physDev, buf, device, output, initData ))
646 {
647 WARN("creation aborted by device\n" );
648 free_dc_ptr( dc );
649 return 0;
650 }
651 }
652
653 if (is_display_device( driver ))
654 display = driver;
655 else if (is_display_device( device ))
656 display = device;
657 else
658 display = NULL;
659
660 if (display)
661 {
662 /* Copy only the display name. For example, \\.\DISPLAY1 in \\.\DISPLAY1\Monitor0 */
663 p = display + 12;
664 while (iswdigit( *p ))
665 ++p;
666 lstrcpynW( dc->display, display, p - display + 1 );
667 dc->display[p - display] = '\0';
668 }
669
670 dc->attr->vis_rect.left = 0;
671 dc->attr->vis_rect.top = 0;
672 dc->attr->vis_rect.right = GetDeviceCaps( hdc, DESKTOPHORZRES );
673 dc->attr->vis_rect.bottom = GetDeviceCaps( hdc, DESKTOPVERTRES );
674
675 DC_InitDC( dc );
676 release_dc_ptr( dc );
677 return hdc;
678 }
679
680
681 /***********************************************************************
682 * NtGdiCreateCompatibleDC (win32u.@)
683 */
684 HDC WINAPI NtGdiCreateCompatibleDC( HDC hdc )
685 {
686 DC *dc, *origDC;
687 HDC ret;
688 const struct gdi_dc_funcs *funcs;
689 PHYSDEV physDev = NULL;
690
691 GDI_CheckNotLock();
692
693 if (hdc)
694 {
695 if (!(origDC = get_dc_ptr( hdc ))) return 0;
696 physDev = GET_DC_PHYSDEV( origDC, pCreateCompatibleDC );
697 funcs = physDev->funcs;
698 release_dc_ptr( origDC );
699 }
700 else funcs = DRIVER_load_driver( L"display" );
701
702 if (!(dc = alloc_dc_ptr( NTGDI_OBJ_MEMDC ))) return 0;
703
704 TRACE("(%p): returning %p\n", hdc, dc->hSelf );
705
706 dc->hBitmap = GDI_inc_ref_count( GetStockObject( DEFAULT_BITMAP ));
707 dc->attr->vis_rect.left = 0;
708 dc->attr->vis_rect.top = 0;
709 dc->attr->vis_rect.right = 1;
710 dc->attr->vis_rect.bottom = 1;
711 dc->device_rect = dc->attr->vis_rect;
712
713 ret = dc->hSelf;
714
715 if (funcs->pCreateCompatibleDC && !funcs->pCreateCompatibleDC( physDev, &dc->physDev ))
716 {
717 WARN("creation aborted by device\n");
718 free_dc_ptr( dc );
719 return 0;
720 }
721
722 if (!dib_driver.pCreateDC( &dc->physDev, NULL, NULL, NULL, NULL ))
723 {
724 free_dc_ptr( dc );
725 return 0;
726 }
727 physDev = GET_DC_PHYSDEV( dc, pSelectBitmap );
728 physDev->funcs->pSelectBitmap( physDev, dc->hBitmap );
729
730 DC_InitDC( dc );
731 release_dc_ptr( dc );
732 return ret;
733 }
734
735
736 /***********************************************************************
737 * DeleteDC (GDI32.@)
738 */
739 BOOL WINAPI DeleteDC( HDC hdc )
740 {
741 DC * dc;
742
743 TRACE("%p\n", hdc );
744
745 GDI_CheckNotLock();
746
747 if (!(dc = get_dc_ptr( hdc ))) return FALSE;
748 if (dc->refcount != 1)
749 {
750 FIXME( "not deleting busy DC %p refcount %u\n", dc->hSelf, dc->refcount );
751 release_dc_ptr( dc );
752 return FALSE;
753 }
754
755 /* Call hook procedure to check whether is it OK to delete this DC */
756 if (dc->hookProc && !dc->hookProc( dc->hSelf, DCHC_DELETEDC, dc->dwHookData, 0 ))
757 {
758 release_dc_ptr( dc );
759 return TRUE;
760 }
761 reset_dc_state( hdc );
762 free_dc_ptr( dc );
763 return TRUE;
764 }
765
766
767 /***********************************************************************
768 * ResetDCW (GDI32.@)
769 */
770 HDC WINAPI ResetDCW( HDC hdc, const DEVMODEW *devmode )
771 {
772 DC *dc;
773 HDC ret = 0;
774
775 if ((dc = get_dc_ptr( hdc )))
776 {
777 PHYSDEV physdev = GET_DC_PHYSDEV( dc, pResetDC );
778 ret = physdev->funcs->pResetDC( physdev, devmode );
779 if (ret) /* reset the visible region */
780 {
781 dc->dirty = 0;
782 dc->attr->vis_rect.left = 0;
783 dc->attr->vis_rect.top = 0;
784 dc->attr->vis_rect.right = GetDeviceCaps( hdc, DESKTOPHORZRES );
785 dc->attr->vis_rect.bottom = GetDeviceCaps( hdc, DESKTOPVERTRES );
786 if (dc->hVisRgn) DeleteObject( dc->hVisRgn );
787 dc->hVisRgn = 0;
788 update_dc_clipping( dc );
789 }
790 release_dc_ptr( dc );
791 }
792 return ret;
793 }
794
795
796 /***********************************************************************
797 * NtGdiGetDeviceCaps (win32u.@)
798 */
799 INT WINAPI NtGdiGetDeviceCaps( HDC hdc, INT cap )
800 {
801 DC *dc;
802 INT ret = 0;
803
804 if ((dc = get_dc_ptr( hdc )))
805 {
806 PHYSDEV physdev = GET_DC_PHYSDEV( dc, pGetDeviceCaps );
807 ret = physdev->funcs->pGetDeviceCaps( physdev, cap );
808 release_dc_ptr( dc );
809 }
810 return ret;
811 }
812
813
814 /***********************************************************************
815 * SetBkColor (GDI32.@)
816 */
817 COLORREF WINAPI SetBkColor( HDC hdc, COLORREF color )
818 {
819 COLORREF ret = CLR_INVALID;
820 DC * dc = get_dc_ptr( hdc );
821
822 TRACE("hdc=%p color=0x%08x\n", hdc, color);
823
824 if (dc)
825 {
826 PHYSDEV physdev = GET_DC_PHYSDEV( dc, pSetBkColor );
827 ret = dc->attr->background_color;
828 dc->attr->background_color = physdev->funcs->pSetBkColor( physdev, color );
829 release_dc_ptr( dc );
830 }
831 return ret;
832 }
833
834
835 /***********************************************************************
836 * SetTextColor (GDI32.@)
837 */
838 COLORREF WINAPI SetTextColor( HDC hdc, COLORREF color )
839 {
840 COLORREF ret = CLR_INVALID;
841 DC * dc = get_dc_ptr( hdc );
842
843 TRACE(" hdc=%p color=0x%08x\n", hdc, color);
844
845 if (dc)
846 {
847 PHYSDEV physdev = GET_DC_PHYSDEV( dc, pSetTextColor );
848 ret = dc->attr->text_color;
849 dc->attr->text_color = physdev->funcs->pSetTextColor( physdev, color );
850 release_dc_ptr( dc );
851 }
852 return ret;
853 }
854
855
856 /***********************************************************************
857 * NtGdiGetAndSetDCDword (win32u.@)
858 */
859 BOOL WINAPI NtGdiGetAndSetDCDword( HDC hdc, UINT method, DWORD value, DWORD *prev_value )
860 {
861 BOOL ret;
862 DC *dc;
863
864 if (!(dc = get_dc_ptr( hdc ))) return 0;
865
866 switch (method)
867 {
868 case NtGdiSetMapMode:
869 *prev_value = dc->attr->map_mode;
870 ret = set_map_mode( dc, value );
871 break;
872
873 default:
874 WARN( "unknown method %u\n", method );
875 ret = FALSE;
876 break;
877 }
878
879 release_dc_ptr( dc );
880 return ret;
881 }
882
883
884 /***********************************************************************
885 * SetGraphicsMode (GDI32.@)
886 */
887 INT WINAPI SetGraphicsMode( HDC hdc, INT mode )
888 {
889 INT ret = 0;
890 DC *dc = get_dc_ptr( hdc );
891
892 /* One would think that setting the graphics mode to GM_COMPATIBLE
893 * would also reset the world transformation matrix to the unity
894 * matrix. However, in Windows, this is not the case. This doesn't
895 * make a lot of sense to me, but that's the way it is.
896 */
897 if (!dc) return 0;
898 if ((mode > 0) && (mode <= GM_LAST))
899 {
900 ret = dc->attr->graphics_mode;
901 dc->attr->graphics_mode = mode;
902 }
903 /* font metrics depend on the graphics mode */
904 if (ret != mode) NtGdiSelectFont(dc->hSelf, dc->hFont);
905 release_dc_ptr( dc );
906 return ret;
907 }
908
909
910 /***********************************************************************
911 * NtGdiGetTransform (win32u.@)
912 *
913 * Undocumented
914 *
915 * Returns one of the co-ordinate space transforms
916 *
917 * PARAMS
918 * hdc [I] Device context.
919 * which [I] Which xform to return:
920 * 0x203 World -> Page transform (that set by SetWorldTransform).
921 * 0x304 Page -> Device transform (the mapping mode transform).
922 * 0x204 World -> Device transform (the combination of the above two).
923 * 0x402 Device -> World transform (the inversion of the above).
924 * xform [O] The xform.
925 *
926 */
927 BOOL WINAPI NtGdiGetTransform( HDC hdc, DWORD which, XFORM *xform )
928 {
929 BOOL ret = TRUE;
930 DC *dc = get_dc_ptr( hdc );
931 if (!dc) return FALSE;
932
933 switch(which)
934 {
935 case 0x203:
936 *xform = dc->xformWorld2Wnd;
937 break;
938
939 case 0x304:
940 construct_window_to_viewport(dc, xform);
941 break;
942
943 case 0x204:
944 *xform = dc->xformWorld2Vport;
945 break;
946
947 case 0x402:
948 *xform = dc->xformVport2World;
949 break;
950
951 default:
952 FIXME("Unknown code %x\n", which);
953 ret = FALSE;
954 }
955
956 release_dc_ptr( dc );
957 return ret;
958 }
959
960
961 /****************************************************************************
962 * CombineTransform [GDI32.@]
963 * Combines two transformation matrices.
964 *
965 * PARAMS
966 * xformResult [O] Stores the result of combining the two matrices
967 * xform1 [I] Specifies the first matrix to apply
968 * xform2 [I] Specifies the second matrix to apply
969 *
970 * REMARKS
971 * The same matrix can be passed in for more than one of the parameters.
972 *
973 * RETURNS
974 * Success: TRUE.
975 * Failure: FALSE. Use GetLastError() to determine the cause.
976 */
977 BOOL WINAPI CombineTransform( LPXFORM xformResult, const XFORM *xform1,
978 const XFORM *xform2 )
979 {
980 XFORM xformTemp;
981
982 /* Check for illegal parameters */
983 if (!xformResult || !xform1 || !xform2)
984 return FALSE;
985
986 /* Create the result in a temporary XFORM, since xformResult may be
987 * equal to xform1 or xform2 */
988 xformTemp.eM11 = xform1->eM11 * xform2->eM11 +
989 xform1->eM12 * xform2->eM21;
990 xformTemp.eM12 = xform1->eM11 * xform2->eM12 +
991 xform1->eM12 * xform2->eM22;
992 xformTemp.eM21 = xform1->eM21 * xform2->eM11 +
993 xform1->eM22 * xform2->eM21;
994 xformTemp.eM22 = xform1->eM21 * xform2->eM12 +
995 xform1->eM22 * xform2->eM22;
996 xformTemp.eDx = xform1->eDx * xform2->eM11 +
997 xform1->eDy * xform2->eM21 +
998 xform2->eDx;
999 xformTemp.eDy = xform1->eDx * xform2->eM12 +
1000 xform1->eDy * xform2->eM22 +
1001 xform2->eDy;
1002
1003 /* Copy the result to xformResult */
1004 *xformResult = xformTemp;
1005
1006 return TRUE;
1007 }
1008
1009
1010 /***********************************************************************
1011 * SetDCHook (GDI32.@)
1012 *
1013 * Note: this doesn't exist in Win32, we add it here because user32 needs it.
1014 */
1015 BOOL WINAPI SetDCHook( HDC hdc, DCHOOKPROC hookProc, DWORD_PTR dwHookData )
1016 {
1017 DC *dc = get_dc_ptr( hdc );
1018
1019 if (!dc) return FALSE;
1020
1021 dc->dwHookData = dwHookData;
1022 dc->hookProc = hookProc;
1023 release_dc_ptr( dc );
1024 return TRUE;
1025 }
1026
1027
1028 /***********************************************************************
1029 * GetDCHook (GDI32.@)
1030 *
1031 * Note: this doesn't exist in Win32, we add it here because user32 needs it.
1032 */
1033 DWORD_PTR WINAPI GetDCHook( HDC hdc, DCHOOKPROC *proc )
1034 {
1035 DC *dc = get_dc_ptr( hdc );
1036 DWORD_PTR ret;
1037
1038 if (!dc) return 0;
1039 if (proc) *proc = dc->hookProc;
1040 ret = dc->dwHookData;
1041 release_dc_ptr( dc );
1042 return ret;
1043 }
1044
1045
1046 /***********************************************************************
1047 * SetHookFlags (GDI32.@)
1048 *
1049 * Note: this doesn't exist in Win32, we add it here because user32 needs it.
1050 */
1051 WORD WINAPI SetHookFlags( HDC hdc, WORD flags )
1052 {
1053 DC *dc = get_dc_obj( hdc ); /* not get_dc_ptr, this needs to work from any thread */
1054 LONG ret = 0;
1055
1056 if (!dc) return 0;
1057
1058 TRACE("hDC %p, flags %04x\n",hdc,flags);
1059
1060 if (flags & DCHF_INVALIDATEVISRGN)
1061 ret = InterlockedExchange( &dc->dirty, 1 );
1062 else if (flags & DCHF_VALIDATEVISRGN || !flags)
1063 ret = InterlockedExchange( &dc->dirty, 0 );
1064
1065 if (flags & DCHF_DISABLEDC)
1066 ret = InterlockedExchange( &dc->attr->disabled, 1 );
1067 else if (flags & DCHF_ENABLEDC)
1068 ret = InterlockedExchange( &dc->attr->disabled, 0 );
1069
1070 GDI_ReleaseObj( hdc );
1071
1072 if (flags & DCHF_RESETDC) ret = reset_dc_state( hdc );
1073 return ret;
1074 }
1075
1076 /***********************************************************************
1077 * NtGdiGetDeviceGammaRamp (win32u.@)
1078 */
1079 BOOL WINAPI NtGdiGetDeviceGammaRamp( HDC hdc, void *ptr )
1080 {
1081 BOOL ret = FALSE;
1082 DC *dc = get_dc_ptr( hdc );
1083
1084 TRACE("%p, %p\n", hdc, ptr);
1085 if( dc )
1086 {
1087 if (GetObjectType( hdc ) != OBJ_MEMDC)
1088 {
1089 PHYSDEV physdev = GET_DC_PHYSDEV( dc, pGetDeviceGammaRamp );
1090 ret = physdev->funcs->pGetDeviceGammaRamp( physdev, ptr );
1091 }
1092 else SetLastError( ERROR_INVALID_PARAMETER );
1093 release_dc_ptr( dc );
1094 }
1095 return ret;
1096 }
1097
1098 static BOOL check_gamma_ramps(void *ptr)
1099 {
1100 WORD *ramp = ptr;
1101
1102 while (ramp < (WORD*)ptr + 3 * 256)
1103 {
1104 float r_x, r_y, r_lx, r_ly, r_d, r_v, r_e, g_avg, g_min, g_max;
1105 unsigned i, f, l, g_n, c;
1106
1107 f = ramp[0];
1108 l = ramp[255];
1109 if (f >= l)
1110 {
1111 TRACE("inverted or flat gamma ramp (%d->%d), rejected\n", f, l);
1112 return FALSE;
1113 }
1114 r_d = l - f;
1115 g_min = g_max = g_avg = 0.0;
1116
1117 /* check gamma ramp entries to estimate the gamma */
1118 TRACE("analyzing gamma ramp (%d->%d)\n", f, l);
1119 for (i=1, g_n=0; i<255; i++)
1120 {
1121 if (ramp[i] < f || ramp[i] > l)
1122 {
1123 TRACE("strange gamma ramp ([%d]=%d for %d->%d), rejected\n", i, ramp[i], f, l);
1124 return FALSE;
1125 }
1126 c = ramp[i] - f;
1127 if (!c) continue; /* avoid log(0) */
1128
1129 /* normalize entry values into 0..1 range */
1130 r_x = i/255.0; r_y = c / r_d;
1131 /* compute logarithms of values */
1132 r_lx = log(r_x); r_ly = log(r_y);
1133 /* compute gamma for this entry */
1134 r_v = r_ly / r_lx;
1135 /* compute differential (error estimate) for this entry */
1136 /* some games use table-based logarithms that magnifies the error by 128 */
1137 r_e = -r_lx * 128 / (c * r_lx * r_lx);
1138
1139 /* compute min & max while compensating for estimated error */
1140 if (!g_n || g_min > (r_v + r_e)) g_min = r_v + r_e;
1141 if (!g_n || g_max < (r_v - r_e)) g_max = r_v - r_e;
1142
1143 /* add to average */
1144 g_avg += r_v;
1145 g_n++;
1146 }
1147
1148 if (!g_n)
1149 {
1150 TRACE("no gamma data, shouldn't happen\n");
1151 return FALSE;
1152 }
1153 g_avg /= g_n;
1154 TRACE("low bias is %d, high is %d, gamma is %5.3f\n", f, 65535-l, g_avg);
1155
1156 /* check that the gamma is reasonably uniform across the ramp */
1157 if (g_max - g_min > 12.8)
1158 {
1159 TRACE("ramp not uniform (max=%f, min=%f, avg=%f), rejected\n", g_max, g_min, g_avg);
1160 return FALSE;
1161 }
1162
1163 /* check that the gamma is not too bright */
1164 if (g_avg < 0.2)
1165 {
1166 TRACE("too bright gamma ( %5.3f), rejected\n", g_avg);
1167 return FALSE;
1168 }
1169
1170 ramp += 256;
1171 }
1172
1173 return TRUE;
1174 }
1175
1176 /***********************************************************************
1177 * NtGdiSetDeviceGammaRamp (win32u.@)
1178 */
1179 BOOL WINAPI NtGdiSetDeviceGammaRamp( HDC hdc, void *ptr )
1180 {
1181 BOOL ret = FALSE;
1182 DC *dc = get_dc_ptr( hdc );
1183
1184 TRACE( "%p, %p\n", hdc, ptr );
1185 if( dc )
1186 {
1187 if (GetObjectType( hdc ) != OBJ_MEMDC)
1188 {
1189 PHYSDEV physdev = GET_DC_PHYSDEV( dc, pSetDeviceGammaRamp );
1190
1191 if (check_gamma_ramps(ptr))
1192 ret = physdev->funcs->pSetDeviceGammaRamp( physdev, ptr );
1193 }
1194 else SetLastError( ERROR_INVALID_PARAMETER );
1195 release_dc_ptr( dc );
1196 }
1197 return ret;
1198 }
1199
1200
1201 /***********************************************************************
1202 * NtGdiGetBoundsRect (win32u.@)
1203 */
1204 UINT WINAPI NtGdiGetBoundsRect( HDC hdc, RECT *rect, UINT flags )
1205 {
1206 PHYSDEV physdev;
1207 RECT device_rect;
1208 UINT ret;
1209 DC *dc = get_dc_ptr( hdc );
1210
1211 if ( !dc ) return 0;
1212
1213 physdev = GET_DC_PHYSDEV( dc, pGetBoundsRect );
1214 ret = physdev->funcs->pGetBoundsRect( physdev, &device_rect, DCB_RESET );
1215 if (!ret)
1216 {
1217 release_dc_ptr( dc );
1218 return 0;
1219 }
1220 if (dc->bounds_enabled && ret == DCB_SET) add_bounds_rect( &dc->bounds, &device_rect );
1221
1222 if (rect)
1223 {
1224 if (is_rect_empty( &dc->bounds ))
1225 {
1226 rect->left = rect->top = rect->right = rect->bottom = 0;
1227 ret = DCB_RESET;
1228 }
1229 else
1230 {
1231 *rect = dc->bounds;
1232 rect->left = max( rect->left, 0 );
1233 rect->top = max( rect->top, 0 );
1234 rect->right = min( rect->right, dc->attr->vis_rect.right - dc->attr->vis_rect.left );
1235 rect->bottom = min( rect->bottom, dc->attr->vis_rect.bottom - dc->attr->vis_rect.top );
1236 ret = DCB_SET;
1237 }
1238 dp_to_lp( dc, (POINT *)rect, 2 );
1239 }
1240 else ret = 0;
1241
1242 if (flags & DCB_RESET) reset_bounds( &dc->bounds );
1243 release_dc_ptr( dc );
1244 return ret;
1245 }
1246
1247
1248 /***********************************************************************
1249 * NtGdiSetBoundsRect (win32u.@)
1250 */
1251 UINT WINAPI NtGdiSetBoundsRect( HDC hdc, const RECT *rect, UINT flags )
1252 {
1253 PHYSDEV physdev;
1254 UINT ret;
1255 DC *dc;
1256
1257 if ((flags & DCB_ENABLE) && (flags & DCB_DISABLE)) return 0;
1258 if (!(dc = get_dc_ptr( hdc ))) return 0;
1259
1260 physdev = GET_DC_PHYSDEV( dc, pSetBoundsRect );
1261 ret = physdev->funcs->pSetBoundsRect( physdev, &dc->bounds, flags );
1262 if (!ret)
1263 {
1264 release_dc_ptr( dc );
1265 return 0;
1266 }
1267
1268 ret = (dc->bounds_enabled ? DCB_ENABLE : DCB_DISABLE) |
1269 (is_rect_empty( &dc->bounds ) ? ret & DCB_SET : DCB_SET);
1270
1271 if (flags & DCB_RESET) reset_bounds( &dc->bounds );
1272
1273 if ((flags & DCB_ACCUMULATE) && rect)
1274 {
1275 RECT rc = *rect;
1276
1277 lp_to_dp( dc, (POINT *)&rc, 2 );
1278 add_bounds_rect( &dc->bounds, &rc );
1279 }
1280
1281 if (flags & DCB_ENABLE) dc->bounds_enabled = TRUE;
1282 if (flags & DCB_DISABLE) dc->bounds_enabled = FALSE;
1283
1284 release_dc_ptr( dc );
1285 return ret;
1286 }
1287
1288
1289 /***********************************************************************
1290 * SetLayout (GDI32.@)
1291 *
1292 * Sets left->right or right->left text layout flags of a dc.
1293 *
1294 */
1295 DWORD WINAPI SetLayout(HDC hdc, DWORD layout)
1296 {
1297 DWORD oldlayout = GDI_ERROR;
1298
1299 DC * dc = get_dc_ptr( hdc );
1300 if (dc)
1301 {
1302 PHYSDEV physdev = GET_DC_PHYSDEV( dc, pSetLayout );
1303 oldlayout = physdev->funcs->pSetLayout( physdev, layout );
1304 release_dc_ptr( dc );
1305 }
1306
1307 TRACE("hdc : %p, old layout : %08x, new layout : %08x\n", hdc, oldlayout, layout);
1308
1309 return oldlayout;
1310 }
1311
1312 /***********************************************************************
1313 * SetDCBrushColor (GDI32.@)
1314 */
1315 COLORREF WINAPI SetDCBrushColor(HDC hdc, COLORREF crColor)
1316 {
1317 DC *dc;
1318 COLORREF oldClr = CLR_INVALID;
1319
1320 TRACE("hdc(%p) crColor(%08x)\n", hdc, crColor);
1321
1322 dc = get_dc_ptr( hdc );
1323 if (dc)
1324 {
1325 PHYSDEV physdev = GET_DC_PHYSDEV( dc, pSetDCBrushColor );
1326 crColor = physdev->funcs->pSetDCBrushColor( physdev, crColor );
1327 if (crColor != CLR_INVALID)
1328 {
1329 oldClr = dc->attr->brush_color;
1330 dc->attr->brush_color = crColor;
1331 }
1332 release_dc_ptr( dc );
1333 }
1334
1335 return oldClr;
1336 }
1337
1338 /***********************************************************************
1339 * SetDCPenColor (GDI32.@)
1340 */
1341 COLORREF WINAPI SetDCPenColor(HDC hdc, COLORREF crColor)
1342 {
1343 DC *dc;
1344 COLORREF oldClr = CLR_INVALID;
1345
1346 TRACE("hdc(%p) crColor(%08x)\n", hdc, crColor);
1347
1348 dc = get_dc_ptr( hdc );
1349 if (dc)
1350 {
1351 PHYSDEV physdev = GET_DC_PHYSDEV( dc, pSetDCPenColor );
1352 crColor = physdev->funcs->pSetDCPenColor( physdev, crColor );
1353 if (crColor != CLR_INVALID)
1354 {
1355 oldClr = dc->attr->pen_color;
1356 dc->attr->pen_color = crColor;
1357 }
1358 release_dc_ptr( dc );
1359 }
1360
1361 return oldClr;
1362 }
Windows API implementation