?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
gdi32: Store DC brush color in DC_ATTR.
[wine.git] / dlls / gdi32 / dc.c
blobfd4a1d3abd070582bb603859542e49a90b330d94
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->wnd_org.x = 0;
75 dc->wnd_org.y = 0;
76 dc->wnd_ext.cx = 1;
77 dc->wnd_ext.cy = 1;
78 dc->vport_org.x = 0;
79 dc->vport_org.y = 0;
80 dc->vport_ext.cx = 1;
81 dc->vport_ext.cy = 1;
82 dc->miterLimit = 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->dcPenColor = RGB( 0, 0, 0 );
93 dc->attr->text_color = RGB( 0, 0, 0 );
94 dc->brush_org.x = 0;
95 dc->brush_org.y = 0;
96 dc->mapperFlags = 0;
97 dc->attr->text_align = TA_LEFT | TA_TOP | TA_NOUPDATECP;
98 dc->charExtra = 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 SetVirtualResolution( 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->vport_ext.cx / (double)dc->wnd_ext.cx;
323 scaleY = (double)dc->vport_ext.cy / (double)dc->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->vport_org.x - scaleX * (double)dc->wnd_org.x;
331 xform->eDy = (double)dc->vport_org.y - scaleY * (double)dc->wnd_org.y;
332 if (dc->attr->layout & LAYOUT_RTL) xform->eDx = dc->vis_rect.right - dc->vis_rect.left - 1 - xform->eDx;
333 }
334
335 /***********************************************************************
336 * linear_xform_cmp
337 *
338 * Compares the linear transform portion of two XFORMs (i.e. the 2x2 submatrix).
339 * Returns 0 if they match.
340 */
341 static inline int linear_xform_cmp( const XFORM *a, const XFORM *b )
342 {
343 return memcmp( a, b, FIELD_OFFSET( XFORM, eDx ) );
344 }
345
346 /***********************************************************************
347 * DC_UpdateXforms
348 *
349 * Updates the xformWorld2Vport, xformVport2World and vport2WorldValid
350 * fields of the specified DC by creating a transformation that
351 * represents the current mapping mode and combining it with the DC's
352 * world transform. This function should be called whenever the
353 * parameters associated with the mapping mode (window and viewport
354 * extents and origins) or the world transform change.
355 */
356 void DC_UpdateXforms( DC *dc )
357 {
358 XFORM xformWnd2Vport, oldworld2vport;
359
360 construct_window_to_viewport(dc, &xformWnd2Vport);
361
362 oldworld2vport = dc->xformWorld2Vport;
363 /* Combine with the world transformation */
364 CombineTransform( &dc->xformWorld2Vport, &dc->xformWorld2Wnd,
365 &xformWnd2Vport );
366
367 /* Create inverse of world-to-viewport transformation */
368 dc->vport2WorldValid = DC_InvertXform( &dc->xformWorld2Vport,
369 &dc->xformVport2World );
370
371 /* Reselect the font and pen back into the dc so that the size
372 gets updated. */
373 if (linear_xform_cmp( &oldworld2vport, &dc->xformWorld2Vport ) &&
374 GetObjectType( dc->hSelf ) != OBJ_METADC)
375 {
376 NtGdiSelectFont(dc->hSelf, dc->hFont);
377 NtGdiSelectPen(dc->hSelf, dc->hPen);
378 }
379 }
380
381
382 /***********************************************************************
383 * nulldrv_SaveDC
384 */
385 INT CDECL nulldrv_SaveDC( PHYSDEV dev )
386 {
387 DC *newdc, *dc = get_nulldrv_dc( dev );
388
389 if (!(newdc = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*newdc )))) return 0;
390 if (!(newdc->attr = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*newdc->attr) )))
391 {
392 HeapFree( GetProcessHeap(), 0, newdc );
393 return 0;
394 }
395 *newdc->attr = *dc->attr;
396 newdc->hPen = dc->hPen;
397 newdc->hBrush = dc->hBrush;
398 newdc->hFont = dc->hFont;
399 newdc->hBitmap = dc->hBitmap;
400 newdc->hPalette = dc->hPalette;
401 newdc->dcPenColor = dc->dcPenColor;
402 newdc->brush_org = dc->brush_org;
403 newdc->mapperFlags = dc->mapperFlags;
404 newdc->charExtra = dc->charExtra;
405 newdc->breakExtra = dc->breakExtra;
406 newdc->breakRem = dc->breakRem;
407 newdc->xformWorld2Wnd = dc->xformWorld2Wnd;
408 newdc->xformWorld2Vport = dc->xformWorld2Vport;
409 newdc->xformVport2World = dc->xformVport2World;
410 newdc->vport2WorldValid = dc->vport2WorldValid;
411 newdc->wnd_org = dc->wnd_org;
412 newdc->wnd_ext = dc->wnd_ext;
413 newdc->vport_org = dc->vport_org;
414 newdc->vport_ext = dc->vport_ext;
415 newdc->virtual_res = dc->virtual_res;
416 newdc->virtual_size = dc->virtual_size;
417
418 /* Get/SetDCState() don't change hVisRgn field ("Undoc. Windows" p.559). */
419
420 if (dc->hClipRgn)
421 {
422 newdc->hClipRgn = NtGdiCreateRectRgn( 0, 0, 0, 0 );
423 NtGdiCombineRgn( newdc->hClipRgn, dc->hClipRgn, 0, RGN_COPY );
424 }
425 if (dc->hMetaRgn)
426 {
427 newdc->hMetaRgn = NtGdiCreateRectRgn( 0, 0, 0, 0 );
428 NtGdiCombineRgn( newdc->hMetaRgn, dc->hMetaRgn, 0, RGN_COPY );
429 }
430
431 if (!PATH_SavePath( newdc, dc ))
432 {
433 release_dc_ptr( dc );
434 free_dc_state( newdc );
435 return 0;
436 }
437
438 newdc->saved_dc = dc->saved_dc;
439 dc->saved_dc = newdc;
440 return ++dc->saveLevel;
441 }
442
443
444 /***********************************************************************
445 * nulldrv_RestoreDC
446 */
447 BOOL CDECL nulldrv_RestoreDC( PHYSDEV dev, INT level )
448 {
449 DC *dcs, *first_dcs, *dc = get_nulldrv_dc( dev );
450 INT save_level;
451
452 /* find the state level to restore */
453
454 if (abs(level) > dc->saveLevel || level == 0) return FALSE;
455 if (level < 0) level = dc->saveLevel + level + 1;
456 first_dcs = dc->saved_dc;
457 for (dcs = first_dcs, save_level = dc->saveLevel; save_level > level; save_level--)
458 dcs = dcs->saved_dc;
459
460 /* restore the state */
461
462 if (!PATH_RestorePath( dc, dcs )) return FALSE;
463
464 dc->attr->layout = dcs->attr->layout;
465 dc->attr->rop_mode = dcs->attr->rop_mode;
466 dc->attr->poly_fill_mode = dcs->attr->poly_fill_mode;
467 dc->attr->stretch_blt_mode = dcs->attr->stretch_blt_mode;
468 dc->attr->rel_abs_mode = dcs->attr->rel_abs_mode;
469 dc->attr->background_mode = dcs->attr->background_mode;
470 dc->attr->background_color = dcs->attr->background_color;
471 dc->attr->text_color = dcs->attr->text_color;
472 dc->attr->brush_color = dcs->attr->brush_color;
473 dc->dcPenColor = dcs->dcPenColor;
474 dc->brush_org = dcs->brush_org;
475 dc->mapperFlags = dcs->mapperFlags;
476 dc->attr->text_align = dcs->attr->text_align;
477 dc->charExtra = dcs->charExtra;
478 dc->breakExtra = dcs->breakExtra;
479 dc->breakRem = dcs->breakRem;
480 dc->attr->map_mode = dcs->attr->map_mode;
481 dc->attr->graphics_mode = dcs->attr->graphics_mode;
482 dc->attr->cur_pos = dcs->attr->cur_pos;
483 dc->attr->arc_direction = dcs->attr->arc_direction;
484 dc->xformWorld2Wnd = dcs->xformWorld2Wnd;
485 dc->xformWorld2Vport = dcs->xformWorld2Vport;
486 dc->xformVport2World = dcs->xformVport2World;
487 dc->vport2WorldValid = dcs->vport2WorldValid;
488 dc->wnd_org = dcs->wnd_org;
489 dc->wnd_ext = dcs->wnd_ext;
490 dc->vport_org = dcs->vport_org;
491 dc->vport_ext = dcs->vport_ext;
492 dc->virtual_res = dcs->virtual_res;
493 dc->virtual_size = dcs->virtual_size;
494
495 if (dcs->hClipRgn)
496 {
497 if (!dc->hClipRgn) dc->hClipRgn = NtGdiCreateRectRgn( 0, 0, 0, 0 );
498 NtGdiCombineRgn( dc->hClipRgn, dcs->hClipRgn, 0, RGN_COPY );
499 }
500 else
501 {
502 if (dc->hClipRgn) DeleteObject( dc->hClipRgn );
503 dc->hClipRgn = 0;
504 }
505 if (dcs->hMetaRgn)
506 {
507 if (!dc->hMetaRgn) dc->hMetaRgn = NtGdiCreateRectRgn( 0, 0, 0, 0 );
508 NtGdiCombineRgn( dc->hMetaRgn, dcs->hMetaRgn, 0, RGN_COPY );
509 }
510 else
511 {
512 if (dc->hMetaRgn) DeleteObject( dc->hMetaRgn );
513 dc->hMetaRgn = 0;
514 }
515 DC_UpdateXforms( dc );
516 update_dc_clipping( dc );
517
518 NtGdiSelectBitmap( dev->hdc, dcs->hBitmap );
519 NtGdiSelectBrush( dev->hdc, dcs->hBrush );
520 NtGdiSelectFont( dev->hdc, dcs->hFont );
521 NtGdiSelectPen( dev->hdc, dcs->hPen );
522 SetBkColor( dev->hdc, dcs->attr->background_color);
523 SetTextColor( dev->hdc, dcs->attr->text_color);
524 GDISelectPalette( dev->hdc, dcs->hPalette, FALSE );
525
526 dc->saved_dc = dcs->saved_dc;
527 dcs->saved_dc = 0;
528 dc->saveLevel = save_level - 1;
529
530 /* now destroy all the saved DCs */
531
532 while (first_dcs)
533 {
534 DC *next = first_dcs->saved_dc;
535 free_dc_state( first_dcs );
536 first_dcs = next;
537 }
538 return TRUE;
539 }
540
541
542 /***********************************************************************
543 * reset_dc_state
544 */
545 static BOOL reset_dc_state( HDC hdc )
546 {
547 DC *dc, *dcs, *next;
548
549 if (!(dc = get_dc_ptr( hdc ))) return FALSE;
550
551 set_initial_dc_state( dc );
552 SetBkColor( hdc, RGB( 255, 255, 255 ));
553 SetTextColor( hdc, RGB( 0, 0, 0 ));
554 NtGdiSelectBrush( hdc, GetStockObject( WHITE_BRUSH ));
555 NtGdiSelectFont( hdc, GetStockObject( SYSTEM_FONT ));
556 NtGdiSelectPen( hdc, GetStockObject( BLACK_PEN ));
557 SetVirtualResolution( hdc, 0, 0, 0, 0 );
558 GDISelectPalette( hdc, GetStockObject( DEFAULT_PALETTE ), FALSE );
559 SetBoundsRect( hdc, NULL, DCB_DISABLE );
560 AbortPath( hdc );
561
562 if (dc->hClipRgn) DeleteObject( dc->hClipRgn );
563 if (dc->hMetaRgn) DeleteObject( dc->hMetaRgn );
564 dc->hClipRgn = 0;
565 dc->hMetaRgn = 0;
566 update_dc_clipping( dc );
567
568 for (dcs = dc->saved_dc; dcs; dcs = next)
569 {
570 next = dcs->saved_dc;
571 free_dc_state( dcs );
572 }
573 dc->saved_dc = NULL;
574 dc->saveLevel = 0;
575 release_dc_ptr( dc );
576 return TRUE;
577 }
578
579
580 /***********************************************************************
581 * SaveDC (GDI32.@)
582 */
583 INT WINAPI SaveDC( HDC hdc )
584 {
585 DC * dc;
586 INT ret = 0;
587
588 if ((dc = get_dc_ptr( hdc )))
589 {
590 PHYSDEV physdev = GET_DC_PHYSDEV( dc, pSaveDC );
591 ret = physdev->funcs->pSaveDC( physdev );
592 release_dc_ptr( dc );
593 }
594 return ret;
595 }
596
597
598 /***********************************************************************
599 * RestoreDC (GDI32.@)
600 */
601 BOOL WINAPI RestoreDC( HDC hdc, INT level )
602 {
603 PHYSDEV physdev;
604 DC *dc;
605 BOOL success = FALSE;
606
607 TRACE("%p %d\n", hdc, level );
608 if ((dc = get_dc_ptr( hdc )))
609 {
610 update_dc( dc );
611 physdev = GET_DC_PHYSDEV( dc, pRestoreDC );
612 success = physdev->funcs->pRestoreDC( physdev, level );
613 release_dc_ptr( dc );
614 }
615 return success;
616 }
617
618
619 /***********************************************************************
620 * CreateDCW (GDI32.@)
621 */
622 HDC WINAPI CreateDCW( LPCWSTR driver, LPCWSTR device, LPCWSTR output,
623 const DEVMODEW *initData )
624 {
625 const WCHAR *display, *p;
626 HDC hdc;
627 DC * dc;
628 const struct gdi_dc_funcs *funcs;
629 WCHAR buf[300];
630
631 GDI_CheckNotLock();
632
633 if (!device || !DRIVER_GetDriverName( device, buf, 300 ))
634 {
635 if (!driver)
636 {
637 ERR( "no device found for %s\n", debugstr_w(device) );
638 return 0;
639 }
640 lstrcpyW(buf, driver);
641 }
642
643 if (!(funcs = DRIVER_load_driver( buf )))
644 {
645 ERR( "no driver found for %s\n", debugstr_w(buf) );
646 return 0;
647 }
648 if (!(dc = alloc_dc_ptr( NTGDI_OBJ_DC ))) return 0;
649 hdc = dc->hSelf;
650
651 dc->hBitmap = GDI_inc_ref_count( GetStockObject( DEFAULT_BITMAP ));
652
653 TRACE("(driver=%s, device=%s, output=%s): returning %p\n",
654 debugstr_w(driver), debugstr_w(device), debugstr_w(output), dc->hSelf );
655
656 if (funcs->pCreateDC)
657 {
658 if (!funcs->pCreateDC( &dc->physDev, buf, device, output, initData ))
659 {
660 WARN("creation aborted by device\n" );
661 free_dc_ptr( dc );
662 return 0;
663 }
664 }
665
666 if (is_display_device( driver ))
667 display = driver;
668 else if (is_display_device( device ))
669 display = device;
670 else
671 display = NULL;
672
673 if (display)
674 {
675 /* Copy only the display name. For example, \\.\DISPLAY1 in \\.\DISPLAY1\Monitor0 */
676 p = display + 12;
677 while (iswdigit( *p ))
678 ++p;
679 lstrcpynW( dc->display, display, p - display + 1 );
680 dc->display[p - display] = '\0';
681 }
682
683 dc->vis_rect.left = 0;
684 dc->vis_rect.top = 0;
685 dc->vis_rect.right = GetDeviceCaps( hdc, DESKTOPHORZRES );
686 dc->vis_rect.bottom = GetDeviceCaps( hdc, DESKTOPVERTRES );
687
688 DC_InitDC( dc );
689 release_dc_ptr( dc );
690 return hdc;
691 }
692
693
694 /***********************************************************************
695 * CreateDCA (GDI32.@)
696 */
697 HDC WINAPI CreateDCA( LPCSTR driver, LPCSTR device, LPCSTR output,
698 const DEVMODEA *initData )
699 {
700 UNICODE_STRING driverW, deviceW, outputW;
701 DEVMODEW *initDataW;
702 HDC ret;
703
704 if (driver) RtlCreateUnicodeStringFromAsciiz(&driverW, driver);
705 else driverW.Buffer = NULL;
706
707 if (device) RtlCreateUnicodeStringFromAsciiz(&deviceW, device);
708 else deviceW.Buffer = NULL;
709
710 if (output) RtlCreateUnicodeStringFromAsciiz(&outputW, output);
711 else outputW.Buffer = NULL;
712
713 initDataW = NULL;
714 if (initData)
715 {
716 /* don't convert initData for DISPLAY driver, it's not used */
717 if (!driverW.Buffer || wcsicmp( driverW.Buffer, L"display" ))
718 initDataW = GdiConvertToDevmodeW(initData);
719 }
720
721 ret = CreateDCW( driverW.Buffer, deviceW.Buffer, outputW.Buffer, initDataW );
722
723 RtlFreeUnicodeString(&driverW);
724 RtlFreeUnicodeString(&deviceW);
725 RtlFreeUnicodeString(&outputW);
726 HeapFree(GetProcessHeap(), 0, initDataW);
727 return ret;
728 }
729
730
731 /***********************************************************************
732 * CreateICA (GDI32.@)
733 */
734 HDC WINAPI CreateICA( LPCSTR driver, LPCSTR device, LPCSTR output,
735 const DEVMODEA* initData )
736 {
737 /* Nothing special yet for ICs */
738 return CreateDCA( driver, device, output, initData );
739 }
740
741
742 /***********************************************************************
743 * CreateICW (GDI32.@)
744 */
745 HDC WINAPI CreateICW( LPCWSTR driver, LPCWSTR device, LPCWSTR output,
746 const DEVMODEW* initData )
747 {
748 /* Nothing special yet for ICs */
749 return CreateDCW( driver, device, output, initData );
750 }
751
752
753 /***********************************************************************
754 * CreateCompatibleDC (GDI32.@)
755 */
756 HDC WINAPI CreateCompatibleDC( HDC hdc )
757 {
758 DC *dc, *origDC;
759 HDC ret;
760 const struct gdi_dc_funcs *funcs;
761 PHYSDEV physDev = NULL;
762
763 GDI_CheckNotLock();
764
765 if (hdc)
766 {
767 if (!(origDC = get_dc_ptr( hdc ))) return 0;
768 physDev = GET_DC_PHYSDEV( origDC, pCreateCompatibleDC );
769 funcs = physDev->funcs;
770 release_dc_ptr( origDC );
771 }
772 else funcs = DRIVER_load_driver( L"display" );
773
774 if (!(dc = alloc_dc_ptr( NTGDI_OBJ_MEMDC ))) return 0;
775
776 TRACE("(%p): returning %p\n", hdc, dc->hSelf );
777
778 dc->hBitmap = GDI_inc_ref_count( GetStockObject( DEFAULT_BITMAP ));
779 dc->vis_rect.left = 0;
780 dc->vis_rect.top = 0;
781 dc->vis_rect.right = 1;
782 dc->vis_rect.bottom = 1;
783 dc->device_rect = dc->vis_rect;
784
785 ret = dc->hSelf;
786
787 if (funcs->pCreateCompatibleDC && !funcs->pCreateCompatibleDC( physDev, &dc->physDev ))
788 {
789 WARN("creation aborted by device\n");
790 free_dc_ptr( dc );
791 return 0;
792 }
793
794 if (!dib_driver.pCreateDC( &dc->physDev, NULL, NULL, NULL, NULL ))
795 {
796 free_dc_ptr( dc );
797 return 0;
798 }
799 physDev = GET_DC_PHYSDEV( dc, pSelectBitmap );
800 physDev->funcs->pSelectBitmap( physDev, dc->hBitmap );
801
802 DC_InitDC( dc );
803 release_dc_ptr( dc );
804 return ret;
805 }
806
807
808 /***********************************************************************
809 * DeleteDC (GDI32.@)
810 */
811 BOOL WINAPI DeleteDC( HDC hdc )
812 {
813 DC * dc;
814
815 TRACE("%p\n", hdc );
816
817 GDI_CheckNotLock();
818
819 if (!(dc = get_dc_ptr( hdc ))) return FALSE;
820 if (dc->refcount != 1)
821 {
822 FIXME( "not deleting busy DC %p refcount %u\n", dc->hSelf, dc->refcount );
823 release_dc_ptr( dc );
824 return FALSE;
825 }
826
827 /* Call hook procedure to check whether is it OK to delete this DC */
828 if (dc->hookProc && !dc->hookProc( dc->hSelf, DCHC_DELETEDC, dc->dwHookData, 0 ))
829 {
830 release_dc_ptr( dc );
831 return TRUE;
832 }
833 reset_dc_state( hdc );
834 free_dc_ptr( dc );
835 return TRUE;
836 }
837
838
839 /***********************************************************************
840 * ResetDCW (GDI32.@)
841 */
842 HDC WINAPI ResetDCW( HDC hdc, const DEVMODEW *devmode )
843 {
844 DC *dc;
845 HDC ret = 0;
846
847 if ((dc = get_dc_ptr( hdc )))
848 {
849 PHYSDEV physdev = GET_DC_PHYSDEV( dc, pResetDC );
850 ret = physdev->funcs->pResetDC( physdev, devmode );
851 if (ret) /* reset the visible region */
852 {
853 dc->dirty = 0;
854 dc->vis_rect.left = 0;
855 dc->vis_rect.top = 0;
856 dc->vis_rect.right = GetDeviceCaps( hdc, DESKTOPHORZRES );
857 dc->vis_rect.bottom = GetDeviceCaps( hdc, DESKTOPVERTRES );
858 if (dc->hVisRgn) DeleteObject( dc->hVisRgn );
859 dc->hVisRgn = 0;
860 update_dc_clipping( dc );
861 }
862 release_dc_ptr( dc );
863 }
864 return ret;
865 }
866
867
868 /***********************************************************************
869 * ResetDCA (GDI32.@)
870 */
871 HDC WINAPI ResetDCA( HDC hdc, const DEVMODEA *devmode )
872 {
873 DEVMODEW *devmodeW;
874 HDC ret;
875
876 if (devmode) devmodeW = GdiConvertToDevmodeW(devmode);
877 else devmodeW = NULL;
878
879 ret = ResetDCW(hdc, devmodeW);
880
881 HeapFree(GetProcessHeap(), 0, devmodeW);
882 return ret;
883 }
884
885
886 /***********************************************************************
887 * GetDeviceCaps (GDI32.@)
888 */
889 INT WINAPI GetDeviceCaps( HDC hdc, INT cap )
890 {
891 DC *dc;
892 INT ret = 0;
893
894 if ((dc = get_dc_ptr( hdc )))
895 {
896 PHYSDEV physdev = GET_DC_PHYSDEV( dc, pGetDeviceCaps );
897 ret = physdev->funcs->pGetDeviceCaps( physdev, cap );
898 release_dc_ptr( dc );
899 }
900 return ret;
901 }
902
903
904 /***********************************************************************
905 * SetBkColor (GDI32.@)
906 */
907 COLORREF WINAPI SetBkColor( HDC hdc, COLORREF color )
908 {
909 COLORREF ret = CLR_INVALID;
910 DC * dc = get_dc_ptr( hdc );
911
912 TRACE("hdc=%p color=0x%08x\n", hdc, color);
913
914 if (dc)
915 {
916 PHYSDEV physdev = GET_DC_PHYSDEV( dc, pSetBkColor );
917 ret = dc->attr->background_color;
918 dc->attr->background_color = physdev->funcs->pSetBkColor( physdev, color );
919 release_dc_ptr( dc );
920 }
921 return ret;
922 }
923
924
925 /***********************************************************************
926 * SetTextColor (GDI32.@)
927 */
928 COLORREF WINAPI SetTextColor( HDC hdc, COLORREF color )
929 {
930 COLORREF ret = CLR_INVALID;
931 DC * dc = get_dc_ptr( hdc );
932
933 TRACE(" hdc=%p color=0x%08x\n", hdc, color);
934
935 if (dc)
936 {
937 PHYSDEV physdev = GET_DC_PHYSDEV( dc, pSetTextColor );
938 ret = dc->attr->text_color;
939 dc->attr->text_color = physdev->funcs->pSetTextColor( physdev, color );
940 release_dc_ptr( dc );
941 }
942 return ret;
943 }
944
945
946 /***********************************************************************
947 * GetDCOrgEx (GDI32.@)
948 */
949 BOOL WINAPI GetDCOrgEx( HDC hDC, LPPOINT lpp )
950 {
951 DC * dc;
952
953 if (!lpp) return FALSE;
954 if (!(dc = get_dc_ptr( hDC ))) return FALSE;
955 lpp->x = dc->vis_rect.left;
956 lpp->y = dc->vis_rect.top;
957 release_dc_ptr( dc );
958 return TRUE;
959 }
960
961
962 /***********************************************************************
963 * SetGraphicsMode (GDI32.@)
964 */
965 INT WINAPI SetGraphicsMode( HDC hdc, INT mode )
966 {
967 INT ret = 0;
968 DC *dc = get_dc_ptr( hdc );
969
970 /* One would think that setting the graphics mode to GM_COMPATIBLE
971 * would also reset the world transformation matrix to the unity
972 * matrix. However, in Windows, this is not the case. This doesn't
973 * make a lot of sense to me, but that's the way it is.
974 */
975 if (!dc) return 0;
976 if ((mode > 0) && (mode <= GM_LAST))
977 {
978 ret = dc->attr->graphics_mode;
979 dc->attr->graphics_mode = mode;
980 }
981 /* font metrics depend on the graphics mode */
982 if (ret != mode) NtGdiSelectFont(dc->hSelf, dc->hFont);
983 release_dc_ptr( dc );
984 return ret;
985 }
986
987
988 /***********************************************************************
989 * GetWorldTransform (GDI32.@)
990 */
991 BOOL WINAPI GetWorldTransform( HDC hdc, LPXFORM xform )
992 {
993 DC * dc;
994 if (!xform) return FALSE;
995 if (!(dc = get_dc_ptr( hdc ))) return FALSE;
996 *xform = dc->xformWorld2Wnd;
997 release_dc_ptr( dc );
998 return TRUE;
999 }
1000
1001
1002 /***********************************************************************
1003 * GetTransform (GDI32.@)
1004 *
1005 * Undocumented
1006 *
1007 * Returns one of the co-ordinate space transforms
1008 *
1009 * PARAMS
1010 * hdc [I] Device context.
1011 * which [I] Which xform to return:
1012 * 0x203 World -> Page transform (that set by SetWorldTransform).
1013 * 0x304 Page -> Device transform (the mapping mode transform).
1014 * 0x204 World -> Device transform (the combination of the above two).
1015 * 0x402 Device -> World transform (the inversion of the above).
1016 * xform [O] The xform.
1017 *
1018 */
1019 BOOL WINAPI GetTransform( HDC hdc, DWORD which, XFORM *xform )
1020 {
1021 BOOL ret = TRUE;
1022 DC *dc = get_dc_ptr( hdc );
1023 if (!dc) return FALSE;
1024
1025 switch(which)
1026 {
1027 case 0x203:
1028 *xform = dc->xformWorld2Wnd;
1029 break;
1030
1031 case 0x304:
1032 construct_window_to_viewport(dc, xform);
1033 break;
1034
1035 case 0x204:
1036 *xform = dc->xformWorld2Vport;
1037 break;
1038
1039 case 0x402:
1040 *xform = dc->xformVport2World;
1041 break;
1042
1043 default:
1044 FIXME("Unknown code %x\n", which);
1045 ret = FALSE;
1046 }
1047
1048 release_dc_ptr( dc );
1049 return ret;
1050 }
1051
1052
1053 /****************************************************************************
1054 * CombineTransform [GDI32.@]
1055 * Combines two transformation matrices.
1056 *
1057 * PARAMS
1058 * xformResult [O] Stores the result of combining the two matrices
1059 * xform1 [I] Specifies the first matrix to apply
1060 * xform2 [I] Specifies the second matrix to apply
1061 *
1062 * REMARKS
1063 * The same matrix can be passed in for more than one of the parameters.
1064 *
1065 * RETURNS
1066 * Success: TRUE.
1067 * Failure: FALSE. Use GetLastError() to determine the cause.
1068 */
1069 BOOL WINAPI CombineTransform( LPXFORM xformResult, const XFORM *xform1,
1070 const XFORM *xform2 )
1071 {
1072 XFORM xformTemp;
1073
1074 /* Check for illegal parameters */
1075 if (!xformResult || !xform1 || !xform2)
1076 return FALSE;
1077
1078 /* Create the result in a temporary XFORM, since xformResult may be
1079 * equal to xform1 or xform2 */
1080 xformTemp.eM11 = xform1->eM11 * xform2->eM11 +
1081 xform1->eM12 * xform2->eM21;
1082 xformTemp.eM12 = xform1->eM11 * xform2->eM12 +
1083 xform1->eM12 * xform2->eM22;
1084 xformTemp.eM21 = xform1->eM21 * xform2->eM11 +
1085 xform1->eM22 * xform2->eM21;
1086 xformTemp.eM22 = xform1->eM21 * xform2->eM12 +
1087 xform1->eM22 * xform2->eM22;
1088 xformTemp.eDx = xform1->eDx * xform2->eM11 +
1089 xform1->eDy * xform2->eM21 +
1090 xform2->eDx;
1091 xformTemp.eDy = xform1->eDx * xform2->eM12 +
1092 xform1->eDy * xform2->eM22 +
1093 xform2->eDy;
1094
1095 /* Copy the result to xformResult */
1096 *xformResult = xformTemp;
1097
1098 return TRUE;
1099 }
1100
1101
1102 /***********************************************************************
1103 * SetDCHook (GDI32.@)
1104 *
1105 * Note: this doesn't exist in Win32, we add it here because user32 needs it.
1106 */
1107 BOOL WINAPI SetDCHook( HDC hdc, DCHOOKPROC hookProc, DWORD_PTR dwHookData )
1108 {
1109 DC *dc = get_dc_ptr( hdc );
1110
1111 if (!dc) return FALSE;
1112
1113 dc->dwHookData = dwHookData;
1114 dc->hookProc = hookProc;
1115 release_dc_ptr( dc );
1116 return TRUE;
1117 }
1118
1119
1120 /***********************************************************************
1121 * GetDCHook (GDI32.@)
1122 *
1123 * Note: this doesn't exist in Win32, we add it here because user32 needs it.
1124 */
1125 DWORD_PTR WINAPI GetDCHook( HDC hdc, DCHOOKPROC *proc )
1126 {
1127 DC *dc = get_dc_ptr( hdc );
1128 DWORD_PTR ret;
1129
1130 if (!dc) return 0;
1131 if (proc) *proc = dc->hookProc;
1132 ret = dc->dwHookData;
1133 release_dc_ptr( dc );
1134 return ret;
1135 }
1136
1137
1138 /***********************************************************************
1139 * SetHookFlags (GDI32.@)
1140 *
1141 * Note: this doesn't exist in Win32, we add it here because user32 needs it.
1142 */
1143 WORD WINAPI SetHookFlags( HDC hdc, WORD flags )
1144 {
1145 DC *dc = get_dc_obj( hdc ); /* not get_dc_ptr, this needs to work from any thread */
1146 LONG ret = 0;
1147
1148 if (!dc) return 0;
1149
1150 TRACE("hDC %p, flags %04x\n",hdc,flags);
1151
1152 if (flags & DCHF_INVALIDATEVISRGN)
1153 ret = InterlockedExchange( &dc->dirty, 1 );
1154 else if (flags & DCHF_VALIDATEVISRGN || !flags)
1155 ret = InterlockedExchange( &dc->dirty, 0 );
1156
1157 if (flags & DCHF_DISABLEDC)
1158 ret = InterlockedExchange( &dc->attr->disabled, 1 );
1159 else if (flags & DCHF_ENABLEDC)
1160 ret = InterlockedExchange( &dc->attr->disabled, 0 );
1161
1162 GDI_ReleaseObj( hdc );
1163
1164 if (flags & DCHF_RESETDC) ret = reset_dc_state( hdc );
1165 return ret;
1166 }
1167
1168 /***********************************************************************
1169 * SetICMMode (GDI32.@)
1170 */
1171 INT WINAPI SetICMMode(HDC hdc, INT iEnableICM)
1172 {
1173 /*FIXME: Assume that ICM is always off, and cannot be turned on */
1174 if (iEnableICM == ICM_OFF) return ICM_OFF;
1175 if (iEnableICM == ICM_ON) return 0;
1176 if (iEnableICM == ICM_QUERY) return ICM_OFF;
1177 return 0;
1178 }
1179
1180 /***********************************************************************
1181 * GetDeviceGammaRamp (GDI32.@)
1182 */
1183 BOOL WINAPI GetDeviceGammaRamp(HDC hDC, LPVOID ptr)
1184 {
1185 BOOL ret = FALSE;
1186 DC *dc = get_dc_ptr( hDC );
1187
1188 TRACE("%p, %p\n", hDC, ptr);
1189 if( dc )
1190 {
1191 if (GetObjectType( hDC ) != OBJ_MEMDC)
1192 {
1193 PHYSDEV physdev = GET_DC_PHYSDEV( dc, pGetDeviceGammaRamp );
1194 ret = physdev->funcs->pGetDeviceGammaRamp( physdev, ptr );
1195 }
1196 else SetLastError( ERROR_INVALID_PARAMETER );
1197 release_dc_ptr( dc );
1198 }
1199 return ret;
1200 }
1201
1202 static BOOL check_gamma_ramps(void *ptr)
1203 {
1204 WORD *ramp = ptr;
1205
1206 while (ramp < (WORD*)ptr + 3 * 256)
1207 {
1208 float r_x, r_y, r_lx, r_ly, r_d, r_v, r_e, g_avg, g_min, g_max;
1209 unsigned i, f, l, g_n, c;
1210
1211 f = ramp[0];
1212 l = ramp[255];
1213 if (f >= l)
1214 {
1215 TRACE("inverted or flat gamma ramp (%d->%d), rejected\n", f, l);
1216 return FALSE;
1217 }
1218 r_d = l - f;
1219 g_min = g_max = g_avg = 0.0;
1220
1221 /* check gamma ramp entries to estimate the gamma */
1222 TRACE("analyzing gamma ramp (%d->%d)\n", f, l);
1223 for (i=1, g_n=0; i<255; i++)
1224 {
1225 if (ramp[i] < f || ramp[i] > l)
1226 {
1227 TRACE("strange gamma ramp ([%d]=%d for %d->%d), rejected\n", i, ramp[i], f, l);
1228 return FALSE;
1229 }
1230 c = ramp[i] - f;
1231 if (!c) continue; /* avoid log(0) */
1232
1233 /* normalize entry values into 0..1 range */
1234 r_x = i/255.0; r_y = c / r_d;
1235 /* compute logarithms of values */
1236 r_lx = log(r_x); r_ly = log(r_y);
1237 /* compute gamma for this entry */
1238 r_v = r_ly / r_lx;
1239 /* compute differential (error estimate) for this entry */
1240 /* some games use table-based logarithms that magnifies the error by 128 */
1241 r_e = -r_lx * 128 / (c * r_lx * r_lx);
1242
1243 /* compute min & max while compensating for estimated error */
1244 if (!g_n || g_min > (r_v + r_e)) g_min = r_v + r_e;
1245 if (!g_n || g_max < (r_v - r_e)) g_max = r_v - r_e;
1246
1247 /* add to average */
1248 g_avg += r_v;
1249 g_n++;
1250 }
1251
1252 if (!g_n)
1253 {
1254 TRACE("no gamma data, shouldn't happen\n");
1255 return FALSE;
1256 }
1257 g_avg /= g_n;
1258 TRACE("low bias is %d, high is %d, gamma is %5.3f\n", f, 65535-l, g_avg);
1259
1260 /* check that the gamma is reasonably uniform across the ramp */
1261 if (g_max - g_min > 12.8)
1262 {
1263 TRACE("ramp not uniform (max=%f, min=%f, avg=%f), rejected\n", g_max, g_min, g_avg);
1264 return FALSE;
1265 }
1266
1267 /* check that the gamma is not too bright */
1268 if (g_avg < 0.2)
1269 {
1270 TRACE("too bright gamma ( %5.3f), rejected\n", g_avg);
1271 return FALSE;
1272 }
1273
1274 ramp += 256;
1275 }
1276
1277 return TRUE;
1278 }
1279
1280 /***********************************************************************
1281 * SetDeviceGammaRamp (GDI32.@)
1282 */
1283 BOOL WINAPI SetDeviceGammaRamp(HDC hDC, LPVOID ptr)
1284 {
1285 BOOL ret = FALSE;
1286 DC *dc = get_dc_ptr( hDC );
1287
1288 TRACE("%p, %p\n", hDC, ptr);
1289 if( dc )
1290 {
1291 if (GetObjectType( hDC ) != OBJ_MEMDC)
1292 {
1293 PHYSDEV physdev = GET_DC_PHYSDEV( dc, pSetDeviceGammaRamp );
1294
1295 if (check_gamma_ramps(ptr))
1296 ret = physdev->funcs->pSetDeviceGammaRamp( physdev, ptr );
1297 }
1298 else SetLastError( ERROR_INVALID_PARAMETER );
1299 release_dc_ptr( dc );
1300 }
1301 return ret;
1302 }
1303
1304
1305 /***********************************************************************
1306 * GetBoundsRect (GDI32.@)
1307 */
1308 UINT WINAPI GetBoundsRect(HDC hdc, LPRECT rect, UINT flags)
1309 {
1310 PHYSDEV physdev;
1311 RECT device_rect;
1312 UINT ret;
1313 DC *dc = get_dc_ptr( hdc );
1314
1315 if ( !dc ) return 0;
1316
1317 physdev = GET_DC_PHYSDEV( dc, pGetBoundsRect );
1318 ret = physdev->funcs->pGetBoundsRect( physdev, &device_rect, DCB_RESET );
1319 if (!ret)
1320 {
1321 release_dc_ptr( dc );
1322 return 0;
1323 }
1324 if (dc->bounds_enabled && ret == DCB_SET) add_bounds_rect( &dc->bounds, &device_rect );
1325
1326 if (rect)
1327 {
1328 if (is_rect_empty( &dc->bounds ))
1329 {
1330 rect->left = rect->top = rect->right = rect->bottom = 0;
1331 ret = DCB_RESET;
1332 }
1333 else
1334 {
1335 *rect = dc->bounds;
1336 rect->left = max( rect->left, 0 );
1337 rect->top = max( rect->top, 0 );
1338 rect->right = min( rect->right, dc->vis_rect.right - dc->vis_rect.left );
1339 rect->bottom = min( rect->bottom, dc->vis_rect.bottom - dc->vis_rect.top );
1340 ret = DCB_SET;
1341 }
1342 dp_to_lp( dc, (POINT *)rect, 2 );
1343 }
1344 else ret = 0;
1345
1346 if (flags & DCB_RESET) reset_bounds( &dc->bounds );
1347 release_dc_ptr( dc );
1348 return ret;
1349 }
1350
1351
1352 /***********************************************************************
1353 * SetBoundsRect (GDI32.@)
1354 */
1355 UINT WINAPI SetBoundsRect(HDC hdc, const RECT* rect, UINT flags)
1356 {
1357 PHYSDEV physdev;
1358 UINT ret;
1359 DC *dc;
1360
1361 if ((flags & DCB_ENABLE) && (flags & DCB_DISABLE)) return 0;
1362 if (!(dc = get_dc_ptr( hdc ))) return 0;
1363
1364 physdev = GET_DC_PHYSDEV( dc, pSetBoundsRect );
1365 ret = physdev->funcs->pSetBoundsRect( physdev, &dc->bounds, flags );
1366 if (!ret)
1367 {
1368 release_dc_ptr( dc );
1369 return 0;
1370 }
1371
1372 ret = (dc->bounds_enabled ? DCB_ENABLE : DCB_DISABLE) |
1373 (is_rect_empty( &dc->bounds ) ? ret & DCB_SET : DCB_SET);
1374
1375 if (flags & DCB_RESET) reset_bounds( &dc->bounds );
1376
1377 if ((flags & DCB_ACCUMULATE) && rect)
1378 {
1379 RECT rc = *rect;
1380
1381 lp_to_dp( dc, (POINT *)&rc, 2 );
1382 add_bounds_rect( &dc->bounds, &rc );
1383 }
1384
1385 if (flags & DCB_ENABLE) dc->bounds_enabled = TRUE;
1386 if (flags & DCB_DISABLE) dc->bounds_enabled = FALSE;
1387
1388 release_dc_ptr( dc );
1389 return ret;
1390 }
1391
1392
1393 /***********************************************************************
1394 * GetBrushOrgEx (GDI32.@)
1395 */
1396 BOOL WINAPI GetBrushOrgEx( HDC hdc, LPPOINT pt )
1397 {
1398 DC * dc = get_dc_ptr( hdc );
1399 if (!dc) return FALSE;
1400 *pt = dc->brush_org;
1401 release_dc_ptr( dc );
1402 return TRUE;
1403 }
1404
1405
1406 /***********************************************************************
1407 * GetViewportExtEx (GDI32.@)
1408 */
1409 BOOL WINAPI GetViewportExtEx( HDC hdc, LPSIZE size )
1410 {
1411 DC * dc = get_dc_ptr( hdc );
1412 if (!dc) return FALSE;
1413 *size = dc->vport_ext;
1414 release_dc_ptr( dc );
1415 return TRUE;
1416 }
1417
1418
1419 /***********************************************************************
1420 * GetViewportOrgEx (GDI32.@)
1421 */
1422 BOOL WINAPI GetViewportOrgEx( HDC hdc, LPPOINT pt )
1423 {
1424 DC * dc = get_dc_ptr( hdc );
1425 if (!dc) return FALSE;
1426 *pt = dc->vport_org;
1427 release_dc_ptr( dc );
1428 return TRUE;
1429 }
1430
1431
1432 /***********************************************************************
1433 * GetWindowExtEx (GDI32.@)
1434 */
1435 BOOL WINAPI GetWindowExtEx( HDC hdc, LPSIZE size )
1436 {
1437 DC * dc = get_dc_ptr( hdc );
1438 if (!dc) return FALSE;
1439 *size = dc->wnd_ext;
1440 release_dc_ptr( dc );
1441 return TRUE;
1442 }
1443
1444
1445 /***********************************************************************
1446 * GetWindowOrgEx (GDI32.@)
1447 */
1448 BOOL WINAPI GetWindowOrgEx( HDC hdc, LPPOINT pt )
1449 {
1450 DC * dc = get_dc_ptr( hdc );
1451 if (!dc) return FALSE;
1452 *pt = dc->wnd_org;
1453 release_dc_ptr( dc );
1454 return TRUE;
1455 }
1456
1457
1458 /***********************************************************************
1459 * SetLayout (GDI32.@)
1460 *
1461 * Sets left->right or right->left text layout flags of a dc.
1462 *
1463 */
1464 DWORD WINAPI SetLayout(HDC hdc, DWORD layout)
1465 {
1466 DWORD oldlayout = GDI_ERROR;
1467
1468 DC * dc = get_dc_ptr( hdc );
1469 if (dc)
1470 {
1471 PHYSDEV physdev = GET_DC_PHYSDEV( dc, pSetLayout );
1472 oldlayout = physdev->funcs->pSetLayout( physdev, layout );
1473 release_dc_ptr( dc );
1474 }
1475
1476 TRACE("hdc : %p, old layout : %08x, new layout : %08x\n", hdc, oldlayout, layout);
1477
1478 return oldlayout;
1479 }
1480
1481 /***********************************************************************
1482 * SetDCBrushColor (GDI32.@)
1483 */
1484 COLORREF WINAPI SetDCBrushColor(HDC hdc, COLORREF crColor)
1485 {
1486 DC *dc;
1487 COLORREF oldClr = CLR_INVALID;
1488
1489 TRACE("hdc(%p) crColor(%08x)\n", hdc, crColor);
1490
1491 dc = get_dc_ptr( hdc );
1492 if (dc)
1493 {
1494 PHYSDEV physdev = GET_DC_PHYSDEV( dc, pSetDCBrushColor );
1495 crColor = physdev->funcs->pSetDCBrushColor( physdev, crColor );
1496 if (crColor != CLR_INVALID)
1497 {
1498 oldClr = dc->attr->brush_color;
1499 dc->attr->brush_color = crColor;
1500 }
1501 release_dc_ptr( dc );
1502 }
1503
1504 return oldClr;
1505 }
1506
1507 /***********************************************************************
1508 * GetDCPenColor (GDI32.@)
1509 */
1510 COLORREF WINAPI GetDCPenColor(HDC hdc)
1511 {
1512 DC *dc;
1513 COLORREF dcPenColor = CLR_INVALID;
1514
1515 TRACE("hdc(%p)\n", hdc);
1516
1517 dc = get_dc_ptr( hdc );
1518 if (dc)
1519 {
1520 dcPenColor = dc->dcPenColor;
1521 release_dc_ptr( dc );
1522 }
1523
1524 return dcPenColor;
1525 }
1526
1527 /***********************************************************************
1528 * SetDCPenColor (GDI32.@)
1529 */
1530 COLORREF WINAPI SetDCPenColor(HDC hdc, COLORREF crColor)
1531 {
1532 DC *dc;
1533 COLORREF oldClr = CLR_INVALID;
1534
1535 TRACE("hdc(%p) crColor(%08x)\n", hdc, crColor);
1536
1537 dc = get_dc_ptr( hdc );
1538 if (dc)
1539 {
1540 PHYSDEV physdev = GET_DC_PHYSDEV( dc, pSetDCPenColor );
1541 crColor = physdev->funcs->pSetDCPenColor( physdev, crColor );
1542 if (crColor != CLR_INVALID)
1543 {
1544 oldClr = dc->dcPenColor;
1545 dc->dcPenColor = crColor;
1546 }
1547 release_dc_ptr( dc );
1548 }
1549
1550 return oldClr;
1551 }
1552
1553 /***********************************************************************
1554 * CancelDC (GDI32.@)
1555 */
1556 BOOL WINAPI CancelDC(HDC hdc)
1557 {
1558 FIXME("stub\n");
1559 return TRUE;
1560 }
1561
1562 /*******************************************************************
1563 * GetMiterLimit [GDI32.@]
1564 *
1565 *
1566 */
1567 BOOL WINAPI GetMiterLimit(HDC hdc, PFLOAT peLimit)
1568 {
1569 BOOL bRet = FALSE;
1570 DC *dc;
1571
1572 TRACE("(%p,%p)\n", hdc, peLimit);
1573
1574 dc = get_dc_ptr( hdc );
1575 if (dc)
1576 {
1577 if (peLimit)
1578 *peLimit = dc->miterLimit;
1579
1580 release_dc_ptr( dc );
1581 bRet = TRUE;
1582 }
1583 return bRet;
1584 }
1585
1586 /*******************************************************************
1587 * SetMiterLimit [GDI32.@]
1588 *
1589 *
1590 */
1591 BOOL WINAPI SetMiterLimit(HDC hdc, FLOAT eNewLimit, PFLOAT peOldLimit)
1592 {
1593 BOOL bRet = FALSE;
1594 DC *dc;
1595
1596 TRACE("(%p,%f,%p)\n", hdc, eNewLimit, peOldLimit);
1597
1598 dc = get_dc_ptr( hdc );
1599 if (dc)
1600 {
1601 if (peOldLimit)
1602 *peOldLimit = dc->miterLimit;
1603 dc->miterLimit = eNewLimit;
1604 release_dc_ptr( dc );
1605 bRet = TRUE;
1606 }
1607 return bRet;
1608 }
1609
1610 /*******************************************************************
1611 * GdiIsMetaPrintDC [GDI32.@]
1612 */
1613 BOOL WINAPI GdiIsMetaPrintDC(HDC hdc)
1614 {
1615 FIXME("%p\n", hdc);
1616 return FALSE;
1617 }
1618
1619 /*******************************************************************
1620 * GdiIsMetaFileDC [GDI32.@]
1621 */
1622 BOOL WINAPI GdiIsMetaFileDC(HDC hdc)
1623 {
1624 TRACE("%p\n", hdc);
1625
1626 switch( GetObjectType( hdc ) )
1627 {
1628 case OBJ_METADC:
1629 case OBJ_ENHMETADC:
1630 return TRUE;
1631 }
1632 return FALSE;
1633 }
1634
1635 /*******************************************************************
1636 * GdiIsPlayMetafileDC [GDI32.@]
1637 */
1638 BOOL WINAPI GdiIsPlayMetafileDC(HDC hdc)
1639 {
1640 FIXME("%p\n", hdc);
1641 return FALSE;
1642 }
Windows API implementation