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
34 #include "gdi_private.h"
35 #include "wine/unicode.h"
36 #include "wine/debug.h"
38 WINE_DEFAULT_DEBUG_CHANNEL(dc
);
40 static const WCHAR displayW
[] = { 'd','i','s','p','l','a','y',0 };
42 static BOOL
DC_DeleteObject( HGDIOBJ handle
, void *obj
);
44 static const struct gdi_obj_funcs dc_funcs
=
46 NULL
, /* pSelectObject */
47 NULL
, /* pGetObject16 */
48 NULL
, /* pGetObjectA */
49 NULL
, /* pGetObjectW */
50 NULL
, /* pUnrealizeObject */
51 DC_DeleteObject
/* pDeleteObject */
55 static inline DC
*get_dc_obj( HDC hdc
)
57 DC
*dc
= GDI_GetObjPtr( hdc
, MAGIC_DONTCARE
);
60 if ((GDIMAGIC(dc
->header
.wMagic
) != DC_MAGIC
) &&
61 (GDIMAGIC(dc
->header
.wMagic
) != MEMORY_DC_MAGIC
) &&
62 (GDIMAGIC(dc
->header
.wMagic
) != METAFILE_DC_MAGIC
) &&
63 (GDIMAGIC(dc
->header
.wMagic
) != ENHMETAFILE_DC_MAGIC
))
65 GDI_ReleaseObj( hdc
);
66 SetLastError( ERROR_INVALID_HANDLE
);
73 /***********************************************************************
76 DC
*alloc_dc_ptr( const DC_FUNCTIONS
*funcs
, WORD magic
)
81 if (!(dc
= GDI_AllocObject( sizeof(*dc
), magic
, (HGDIOBJ
*)&hdc
, &dc_funcs
))) return NULL
;
86 dc
->savedFuncs
= NULL
;
87 dc
->savedPhysDev
= NULL
;
88 dc
->thread
= GetCurrentThreadId();
104 dc
->miterLimit
= 10.0f
; /* 10.0 is the default, from MSDN */
109 dc
->hMetaClipRgn
= 0;
111 dc
->hPen
= GetStockObject( BLACK_PEN
);
112 dc
->hBrush
= GetStockObject( WHITE_BRUSH
);
113 dc
->hFont
= GetStockObject( SYSTEM_FONT
);
116 dc
->hPalette
= GetStockObject( DEFAULT_PALETTE
);
118 dc
->ROPmode
= R2_COPYPEN
;
119 dc
->polyFillMode
= ALTERNATE
;
120 dc
->stretchBltMode
= BLACKONWHITE
;
121 dc
->relAbsMode
= ABSOLUTE
;
122 dc
->backgroundMode
= OPAQUE
;
123 dc
->backgroundColor
= RGB( 255, 255, 255 );
124 dc
->dcBrushColor
= RGB( 255, 255, 255 );
125 dc
->dcPenColor
= RGB( 0, 0, 0 );
126 dc
->textColor
= RGB( 0, 0, 0 );
129 dc
->textAlign
= TA_LEFT
| TA_TOP
| TA_NOUPDATECP
;
133 dc
->MapMode
= MM_TEXT
;
134 dc
->GraphicsMode
= GM_COMPATIBLE
;
135 dc
->pAbortProc
= NULL
;
138 dc
->ArcDirection
= AD_COUNTERCLOCKWISE
;
139 dc
->xformWorld2Wnd
.eM11
= 1.0f
;
140 dc
->xformWorld2Wnd
.eM12
= 0.0f
;
141 dc
->xformWorld2Wnd
.eM21
= 0.0f
;
142 dc
->xformWorld2Wnd
.eM22
= 1.0f
;
143 dc
->xformWorld2Wnd
.eDx
= 0.0f
;
144 dc
->xformWorld2Wnd
.eDy
= 0.0f
;
145 dc
->xformWorld2Vport
= dc
->xformWorld2Wnd
;
146 dc
->xformVport2World
= dc
->xformWorld2Wnd
;
147 dc
->vport2WorldValid
= TRUE
;
148 dc
->BoundsRect
.left
= 0;
149 dc
->BoundsRect
.top
= 0;
150 dc
->BoundsRect
.right
= 0;
151 dc
->BoundsRect
.bottom
= 0;
152 dc
->saved_visrgn
= NULL
;
153 PATH_InitGdiPath(&dc
->path
);
154 GDI_ReleaseObj( dc
->hSelf
);
160 /***********************************************************************
163 DC
*DC_GetDCPtr( HDC hdc
)
165 DC
*dc
= get_dc_obj( hdc
);
166 if (!dc
) return NULL
;
168 if (!InterlockedCompareExchange( &dc
->refcount
, 1, 0 ))
170 dc
->thread
= GetCurrentThreadId();
172 else if (dc
->thread
!= GetCurrentThreadId())
174 GDI_ReleaseObj( hdc
);
175 SetLastError( ERROR_ACCESS_DENIED
);
178 else InterlockedIncrement( &dc
->refcount
);
184 /***********************************************************************
187 void DC_ReleaseDCPtr( DC
*dc
)
189 release_dc_ptr( dc
);
190 GDI_ReleaseObj( dc
->hSelf
);
194 /***********************************************************************
197 BOOL
free_dc_ptr( DC
*dc
)
199 assert( dc
->refcount
== 1 );
200 /* grab the gdi lock again */
201 if (!GDI_GetObjPtr( dc
->hSelf
, MAGIC_DONTCARE
)) return FALSE
; /* shouldn't happen */
202 return GDI_FreeObject( dc
->hSelf
, dc
);
206 /***********************************************************************
209 * Retrieve a DC pointer but release the GDI lock.
211 DC
*get_dc_ptr( HDC hdc
)
213 DC
*dc
= get_dc_obj( hdc
);
214 if (!dc
) return NULL
;
216 if (!InterlockedCompareExchange( &dc
->refcount
, 1, 0 ))
218 dc
->thread
= GetCurrentThreadId();
220 else if (dc
->thread
!= GetCurrentThreadId())
222 WARN( "dc %p belongs to thread %04x\n", hdc
, dc
->thread
);
223 GDI_ReleaseObj( hdc
);
226 else InterlockedIncrement( &dc
->refcount
);
228 GDI_ReleaseObj( hdc
);
233 /***********************************************************************
236 void release_dc_ptr( DC
*dc
)
241 ref
= InterlockedDecrement( &dc
->refcount
);
243 if (ref
) dc
->thread
= GetCurrentThreadId(); /* we still own it */
247 /***********************************************************************
250 * Make sure the DC vis region is up to date.
251 * This function may call up to USER so the GDI lock should _not_
252 * be held when calling it.
254 void update_dc( DC
*dc
)
256 if (InterlockedExchange( &dc
->dirty
, 0 ) && dc
->hookThunk
)
257 dc
->hookThunk( dc
->hSelf
, DCHC_INVALIDVISRGN
, dc
->dwHookData
, 0 );
261 /***********************************************************************
264 static BOOL
DC_DeleteObject( HGDIOBJ handle
, void *obj
)
266 GDI_ReleaseObj( handle
);
267 return DeleteDC( handle
);
271 /***********************************************************************
274 * Setup device-specific DC values for a newly created DC.
276 void DC_InitDC( DC
* dc
)
278 if (dc
->funcs
->pRealizeDefaultPalette
) dc
->funcs
->pRealizeDefaultPalette( dc
->physDev
);
279 SetTextColor( dc
->hSelf
, dc
->textColor
);
280 SetBkColor( dc
->hSelf
, dc
->backgroundColor
);
281 SelectObject( dc
->hSelf
, dc
->hPen
);
282 SelectObject( dc
->hSelf
, dc
->hBrush
);
283 SelectObject( dc
->hSelf
, dc
->hFont
);
284 CLIPPING_UpdateGCRegion( dc
);
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
;
317 /***********************************************************************
320 * Updates the xformWorld2Vport, xformVport2World and vport2WorldValid
321 * fields of the specified DC by creating a transformation that
322 * represents the current mapping mode and combining it with the DC's
323 * world transform. This function should be called whenever the
324 * parameters associated with the mapping mode (window and viewport
325 * extents and origins) or the world transform change.
327 void DC_UpdateXforms( DC
*dc
)
329 XFORM xformWnd2Vport
, oldworld2vport
;
330 FLOAT scaleX
, scaleY
;
332 /* Construct a transformation to do the window-to-viewport conversion */
333 scaleX
= (FLOAT
)dc
->vportExtX
/ (FLOAT
)dc
->wndExtX
;
334 scaleY
= (FLOAT
)dc
->vportExtY
/ (FLOAT
)dc
->wndExtY
;
335 xformWnd2Vport
.eM11
= scaleX
;
336 xformWnd2Vport
.eM12
= 0.0;
337 xformWnd2Vport
.eM21
= 0.0;
338 xformWnd2Vport
.eM22
= scaleY
;
339 xformWnd2Vport
.eDx
= (FLOAT
)dc
->vportOrgX
-
340 scaleX
* (FLOAT
)dc
->wndOrgX
;
341 xformWnd2Vport
.eDy
= (FLOAT
)dc
->vportOrgY
-
342 scaleY
* (FLOAT
)dc
->wndOrgY
;
344 oldworld2vport
= dc
->xformWorld2Vport
;
345 /* Combine with the world transformation */
346 CombineTransform( &dc
->xformWorld2Vport
, &dc
->xformWorld2Wnd
,
349 /* Create inverse of world-to-viewport transformation */
350 dc
->vport2WorldValid
= DC_InvertXform( &dc
->xformWorld2Vport
,
351 &dc
->xformVport2World
);
353 /* Reselect the font and pen back into the dc so that the size
355 if(memcmp(&oldworld2vport
, &dc
->xformWorld2Vport
, sizeof(oldworld2vport
)))
357 SelectObject(dc
->hSelf
, GetCurrentObject(dc
->hSelf
, OBJ_FONT
));
358 SelectObject(dc
->hSelf
, GetCurrentObject(dc
->hSelf
, OBJ_PEN
));
363 /***********************************************************************
364 * GetDCState (Not a Windows API)
366 HDC WINAPI
GetDCState( HDC hdc
)
371 if (!(dc
= get_dc_ptr( hdc
))) return 0;
372 if (!(newdc
= GDI_AllocObject( sizeof(DC
), GDIMAGIC(dc
->header
.wMagic
), &handle
, &dc_funcs
)))
374 release_dc_ptr( dc
);
377 TRACE("(%p): returning %p\n", hdc
, handle
);
379 newdc
->flags
= dc
->flags
| DC_SAVED
;
380 newdc
->layout
= dc
->layout
;
381 newdc
->hPen
= dc
->hPen
;
382 newdc
->hBrush
= dc
->hBrush
;
383 newdc
->hFont
= dc
->hFont
;
384 newdc
->hBitmap
= dc
->hBitmap
;
385 newdc
->hDevice
= dc
->hDevice
;
386 newdc
->hPalette
= dc
->hPalette
;
387 newdc
->ROPmode
= dc
->ROPmode
;
388 newdc
->polyFillMode
= dc
->polyFillMode
;
389 newdc
->stretchBltMode
= dc
->stretchBltMode
;
390 newdc
->relAbsMode
= dc
->relAbsMode
;
391 newdc
->backgroundMode
= dc
->backgroundMode
;
392 newdc
->backgroundColor
= dc
->backgroundColor
;
393 newdc
->textColor
= dc
->textColor
;
394 newdc
->dcBrushColor
= dc
->dcBrushColor
;
395 newdc
->dcPenColor
= dc
->dcPenColor
;
396 newdc
->brushOrgX
= dc
->brushOrgX
;
397 newdc
->brushOrgY
= dc
->brushOrgY
;
398 newdc
->textAlign
= dc
->textAlign
;
399 newdc
->charExtra
= dc
->charExtra
;
400 newdc
->breakExtra
= dc
->breakExtra
;
401 newdc
->breakRem
= dc
->breakRem
;
402 newdc
->MapMode
= dc
->MapMode
;
403 newdc
->GraphicsMode
= dc
->GraphicsMode
;
404 newdc
->CursPosX
= dc
->CursPosX
;
405 newdc
->CursPosY
= dc
->CursPosY
;
406 newdc
->ArcDirection
= dc
->ArcDirection
;
407 newdc
->xformWorld2Wnd
= dc
->xformWorld2Wnd
;
408 newdc
->xformWorld2Vport
= dc
->xformWorld2Vport
;
409 newdc
->xformVport2World
= dc
->xformVport2World
;
410 newdc
->vport2WorldValid
= dc
->vport2WorldValid
;
411 newdc
->wndOrgX
= dc
->wndOrgX
;
412 newdc
->wndOrgY
= dc
->wndOrgY
;
413 newdc
->wndExtX
= dc
->wndExtX
;
414 newdc
->wndExtY
= dc
->wndExtY
;
415 newdc
->vportOrgX
= dc
->vportOrgX
;
416 newdc
->vportOrgY
= dc
->vportOrgY
;
417 newdc
->vportExtX
= dc
->vportExtX
;
418 newdc
->vportExtY
= dc
->vportExtY
;
419 newdc
->BoundsRect
= dc
->BoundsRect
;
421 newdc
->hSelf
= (HDC
)handle
;
422 newdc
->thread
= GetCurrentThreadId();
424 newdc
->saveLevel
= 0;
426 GDI_ReleaseObj( handle
);
428 PATH_InitGdiPath( &newdc
->path
);
430 newdc
->pAbortProc
= NULL
;
431 newdc
->hookThunk
= NULL
;
433 newdc
->saved_visrgn
= NULL
;
435 /* Get/SetDCState() don't change hVisRgn field ("Undoc. Windows" p.559). */
440 newdc
->hMetaClipRgn
= 0;
443 newdc
->hClipRgn
= CreateRectRgn( 0, 0, 0, 0 );
444 CombineRgn( newdc
->hClipRgn
, dc
->hClipRgn
, 0, RGN_COPY
);
448 newdc
->hMetaRgn
= CreateRectRgn( 0, 0, 0, 0 );
449 CombineRgn( newdc
->hMetaRgn
, dc
->hMetaRgn
, 0, RGN_COPY
);
451 /* don't bother recomputing hMetaClipRgn, we'll do that in SetDCState */
454 newdc
->gdiFont
= dc
->gdiFont
;
458 release_dc_ptr( newdc
);
459 release_dc_ptr( dc
);
464 /***********************************************************************
465 * SetDCState (Not a Windows API)
467 void WINAPI
SetDCState( HDC hdc
, HDC hdcs
)
471 if (!(dc
= get_dc_ptr( hdc
))) return;
472 if (!(dcs
= get_dc_ptr( hdcs
)))
474 release_dc_ptr( dc
);
477 if (!(dcs
->flags
& DC_SAVED
))
479 release_dc_ptr( dc
);
480 release_dc_ptr( dcs
);
483 TRACE("%p %p\n", hdc
, hdcs
);
486 dc
->flags
= dcs
->flags
& ~DC_SAVED
;
487 dc
->layout
= dcs
->layout
;
488 dc
->hDevice
= dcs
->hDevice
;
489 dc
->ROPmode
= dcs
->ROPmode
;
490 dc
->polyFillMode
= dcs
->polyFillMode
;
491 dc
->stretchBltMode
= dcs
->stretchBltMode
;
492 dc
->relAbsMode
= dcs
->relAbsMode
;
493 dc
->backgroundMode
= dcs
->backgroundMode
;
494 dc
->backgroundColor
= dcs
->backgroundColor
;
495 dc
->textColor
= dcs
->textColor
;
496 dc
->dcBrushColor
= dcs
->dcBrushColor
;
497 dc
->dcPenColor
= dcs
->dcPenColor
;
498 dc
->brushOrgX
= dcs
->brushOrgX
;
499 dc
->brushOrgY
= dcs
->brushOrgY
;
500 dc
->textAlign
= dcs
->textAlign
;
501 dc
->charExtra
= dcs
->charExtra
;
502 dc
->breakExtra
= dcs
->breakExtra
;
503 dc
->breakRem
= dcs
->breakRem
;
504 dc
->MapMode
= dcs
->MapMode
;
505 dc
->GraphicsMode
= dcs
->GraphicsMode
;
506 dc
->CursPosX
= dcs
->CursPosX
;
507 dc
->CursPosY
= dcs
->CursPosY
;
508 dc
->ArcDirection
= dcs
->ArcDirection
;
509 dc
->xformWorld2Wnd
= dcs
->xformWorld2Wnd
;
510 dc
->xformWorld2Vport
= dcs
->xformWorld2Vport
;
511 dc
->xformVport2World
= dcs
->xformVport2World
;
512 dc
->vport2WorldValid
= dcs
->vport2WorldValid
;
513 dc
->BoundsRect
= dcs
->BoundsRect
;
515 dc
->wndOrgX
= dcs
->wndOrgX
;
516 dc
->wndOrgY
= dcs
->wndOrgY
;
517 dc
->wndExtX
= dcs
->wndExtX
;
518 dc
->wndExtY
= dcs
->wndExtY
;
519 dc
->vportOrgX
= dcs
->vportOrgX
;
520 dc
->vportOrgY
= dcs
->vportOrgY
;
521 dc
->vportExtX
= dcs
->vportExtX
;
522 dc
->vportExtY
= dcs
->vportExtY
;
526 if (!dc
->hClipRgn
) dc
->hClipRgn
= CreateRectRgn( 0, 0, 0, 0 );
527 CombineRgn( dc
->hClipRgn
, dcs
->hClipRgn
, 0, RGN_COPY
);
531 if (dc
->hClipRgn
) DeleteObject( dc
->hClipRgn
);
536 if (!dc
->hMetaRgn
) dc
->hMetaRgn
= CreateRectRgn( 0, 0, 0, 0 );
537 CombineRgn( dc
->hMetaRgn
, dcs
->hMetaRgn
, 0, RGN_COPY
);
541 if (dc
->hMetaRgn
) DeleteObject( dc
->hMetaRgn
);
544 CLIPPING_UpdateGCRegion( dc
);
546 SelectObject( hdc
, dcs
->hBitmap
);
547 SelectObject( hdc
, dcs
->hBrush
);
548 SelectObject( hdc
, dcs
->hFont
);
549 SelectObject( hdc
, dcs
->hPen
);
550 SetBkColor( hdc
, dcs
->backgroundColor
);
551 SetTextColor( hdc
, dcs
->textColor
);
552 GDISelectPalette( hdc
, dcs
->hPalette
, FALSE
);
553 release_dc_ptr( dc
);
554 release_dc_ptr( dcs
);
558 /***********************************************************************
559 * GetDCState (GDI.179)
561 HDC16 WINAPI
GetDCState16( HDC16 hdc
)
563 return HDC_16( GetDCState( HDC_32(hdc
) ));
567 /***********************************************************************
568 * SetDCState (GDI.180)
570 void WINAPI
SetDCState16( HDC16 hdc
, HDC16 hdcs
)
572 SetDCState( HDC_32(hdc
), HDC_32(hdcs
) );
576 /***********************************************************************
579 INT WINAPI
SaveDC( HDC hdc
)
585 dc
= get_dc_ptr( hdc
);
588 if(dc
->funcs
->pSaveDC
)
590 ret
= dc
->funcs
->pSaveDC( dc
->physDev
);
592 ret
= ++dc
->saveLevel
;
593 release_dc_ptr( dc
);
597 if (!(hdcs
= GetDCState( hdc
)))
599 release_dc_ptr( dc
);
602 dcs
= get_dc_ptr( hdcs
);
604 /* Copy path. The reason why path saving / restoring is in SaveDC/
605 * RestoreDC and not in GetDCState/SetDCState is that the ...DCState
606 * functions are only in Win16 (which doesn't have paths) and that
607 * SetDCState doesn't allow us to signal an error (which can happen
608 * when copying paths).
610 if (!PATH_AssignGdiPath( &dcs
->path
, &dc
->path
))
612 release_dc_ptr( dc
);
613 release_dc_ptr( dcs
);
618 dcs
->saved_dc
= dc
->saved_dc
;
620 TRACE("(%p): returning %d\n", hdc
, dc
->saveLevel
+1 );
621 ret
= ++dc
->saveLevel
;
622 release_dc_ptr( dcs
);
623 release_dc_ptr( dc
);
628 /***********************************************************************
629 * RestoreDC (GDI32.@)
631 BOOL WINAPI
RestoreDC( HDC hdc
, INT level
)
636 TRACE("%p %d\n", hdc
, level
);
637 if (!(dc
= get_dc_ptr( hdc
))) return FALSE
;
639 if(abs(level
) > dc
->saveLevel
|| level
== 0)
641 release_dc_ptr( dc
);
647 if(dc
->funcs
->pRestoreDC
)
649 success
= dc
->funcs
->pRestoreDC( dc
->physDev
, level
);
650 if(level
< 0) level
= dc
->saveLevel
+ level
+ 1;
652 dc
->saveLevel
= level
- 1;
653 release_dc_ptr( dc
);
657 if (level
< 0) level
= dc
->saveLevel
+ level
+ 1;
659 while (dc
->saveLevel
>= level
)
661 HDC hdcs
= dc
->saved_dc
;
662 if (!(dcs
= get_dc_ptr( hdcs
)))
667 dc
->saved_dc
= dcs
->saved_dc
;
669 if (--dc
->saveLevel
< level
)
671 SetDCState( hdc
, hdcs
);
672 if (!PATH_AssignGdiPath( &dc
->path
, &dcs
->path
))
673 /* FIXME: This might not be quite right, since we're
674 * returning FALSE but still destroying the saved DC state */
677 release_dc_ptr( dcs
);
680 release_dc_ptr( dc
);
685 /***********************************************************************
686 * CreateDCW (GDI32.@)
688 HDC WINAPI
CreateDCW( LPCWSTR driver
, LPCWSTR device
, LPCWSTR output
,
689 const DEVMODEW
*initData
)
693 const DC_FUNCTIONS
*funcs
;
698 if (!device
|| !DRIVER_GetDriverName( device
, buf
, 300 ))
702 ERR( "no device found for %s\n", debugstr_w(device
) );
705 strcpyW(buf
, driver
);
708 if (!(funcs
= DRIVER_load_driver( buf
)))
710 ERR( "no driver found for %s\n", debugstr_w(buf
) );
713 if (!(dc
= alloc_dc_ptr( funcs
, DC_MAGIC
))) goto error
;
716 dc
->hBitmap
= GetStockObject( DEFAULT_BITMAP
);
717 if (!(dc
->hVisRgn
= CreateRectRgn( 0, 0, 1, 1 ))) goto error
;
719 TRACE("(driver=%s, device=%s, output=%s): returning %p\n",
720 debugstr_w(driver
), debugstr_w(device
), debugstr_w(output
), dc
->hSelf
);
722 if (dc
->funcs
->pCreateDC
&&
723 !dc
->funcs
->pCreateDC( hdc
, &dc
->physDev
, buf
, device
, output
, initData
))
725 WARN("creation aborted by device\n" );
729 SetRectRgn( dc
->hVisRgn
, 0, 0,
730 GetDeviceCaps( hdc
, DESKTOPHORZRES
), GetDeviceCaps( hdc
, DESKTOPVERTRES
) );
733 release_dc_ptr( dc
);
737 if (dc
&& dc
->hVisRgn
) DeleteObject( dc
->hVisRgn
);
738 if (dc
) free_dc_ptr( dc
);
739 DRIVER_release_driver( funcs
);
744 /***********************************************************************
745 * CreateDCA (GDI32.@)
747 HDC WINAPI
CreateDCA( LPCSTR driver
, LPCSTR device
, LPCSTR output
,
748 const DEVMODEA
*initData
)
750 UNICODE_STRING driverW
, deviceW
, outputW
;
754 if (driver
) RtlCreateUnicodeStringFromAsciiz(&driverW
, driver
);
755 else driverW
.Buffer
= NULL
;
757 if (device
) RtlCreateUnicodeStringFromAsciiz(&deviceW
, device
);
758 else deviceW
.Buffer
= NULL
;
760 if (output
) RtlCreateUnicodeStringFromAsciiz(&outputW
, output
);
761 else outputW
.Buffer
= NULL
;
766 /* don't convert initData for DISPLAY driver, it's not used */
767 if (!driverW
.Buffer
|| strcmpiW( driverW
.Buffer
, displayW
))
768 initDataW
= GdiConvertToDevmodeW(initData
);
771 ret
= CreateDCW( driverW
.Buffer
, deviceW
.Buffer
, outputW
.Buffer
, initDataW
);
773 RtlFreeUnicodeString(&driverW
);
774 RtlFreeUnicodeString(&deviceW
);
775 RtlFreeUnicodeString(&outputW
);
776 HeapFree(GetProcessHeap(), 0, initDataW
);
781 /***********************************************************************
782 * CreateICA (GDI32.@)
784 HDC WINAPI
CreateICA( LPCSTR driver
, LPCSTR device
, LPCSTR output
,
785 const DEVMODEA
* initData
)
787 /* Nothing special yet for ICs */
788 return CreateDCA( driver
, device
, output
, initData
);
792 /***********************************************************************
793 * CreateICW (GDI32.@)
795 HDC WINAPI
CreateICW( LPCWSTR driver
, LPCWSTR device
, LPCWSTR output
,
796 const DEVMODEW
* initData
)
798 /* Nothing special yet for ICs */
799 return CreateDCW( driver
, device
, output
, initData
);
803 /***********************************************************************
804 * CreateCompatibleDC (GDI32.@)
806 HDC WINAPI
CreateCompatibleDC( HDC hdc
)
810 const DC_FUNCTIONS
*funcs
= NULL
;
811 PHYSDEV physDev
= NULL
;
815 if ((origDC
= get_dc_ptr( hdc
)))
817 if (GetObjectType( hdc
) == OBJ_DC
)
819 funcs
= origDC
->funcs
;
820 physDev
= origDC
->physDev
;
822 release_dc_ptr( origDC
);
823 if (funcs
) funcs
= DRIVER_get_driver( funcs
);
826 if (!funcs
&& !(funcs
= DRIVER_load_driver( displayW
))) return 0;
828 if (!(dc
= alloc_dc_ptr( funcs
, MEMORY_DC_MAGIC
))) goto error
;
830 TRACE("(%p): returning %p\n", hdc
, dc
->hSelf
);
832 dc
->hBitmap
= GetStockObject( DEFAULT_BITMAP
);
833 if (!(dc
->hVisRgn
= CreateRectRgn( 0, 0, 1, 1 ))) goto error
; /* default bitmap is 1x1 */
835 /* Copy the driver-specific physical device info into
836 * the new DC. The driver may use this read-only info
837 * while creating the compatible DC below. */
838 dc
->physDev
= physDev
;
841 if (dc
->funcs
->pCreateDC
&&
842 !dc
->funcs
->pCreateDC( dc
->hSelf
, &dc
->physDev
, NULL
, NULL
, NULL
, NULL
))
844 WARN("creation aborted by device\n");
849 release_dc_ptr( dc
);
853 if (dc
&& dc
->hVisRgn
) DeleteObject( dc
->hVisRgn
);
854 if (dc
) free_dc_ptr( dc
);
855 DRIVER_release_driver( funcs
);
860 /***********************************************************************
863 BOOL WINAPI
DeleteDC( HDC hdc
)
865 const DC_FUNCTIONS
*funcs
= NULL
;
872 if (!(dc
= get_dc_ptr( hdc
))) return FALSE
;
873 if (dc
->refcount
!= 1)
875 FIXME( "not deleting busy DC %p refcount %u\n", dc
->hSelf
, dc
->refcount
);
876 release_dc_ptr( dc
);
880 /* Call hook procedure to check whether is it OK to delete this DC */
881 if (dc
->hookThunk
&& !dc
->hookThunk( hdc
, DCHC_DELETEDC
, dc
->dwHookData
, 0 ))
883 release_dc_ptr( dc
);
887 while (dc
->saveLevel
)
890 HDC hdcs
= dc
->saved_dc
;
891 if (!(dcs
= get_dc_ptr( hdcs
))) break;
892 dc
->saved_dc
= dcs
->saved_dc
;
894 if (dcs
->hClipRgn
) DeleteObject( dcs
->hClipRgn
);
895 if (dcs
->hMetaRgn
) DeleteObject( dcs
->hMetaRgn
);
896 if (dcs
->hMetaClipRgn
) DeleteObject( dcs
->hMetaClipRgn
);
897 if (dcs
->hVisRgn
) DeleteObject( dcs
->hVisRgn
);
898 PATH_DestroyGdiPath(&dcs
->path
);
902 if (!(dc
->flags
& DC_SAVED
))
904 SelectObject( hdc
, GetStockObject(BLACK_PEN
) );
905 SelectObject( hdc
, GetStockObject(WHITE_BRUSH
) );
906 SelectObject( hdc
, GetStockObject(SYSTEM_FONT
) );
907 SelectObject( hdc
, GetStockObject(DEFAULT_BITMAP
) );
909 if (dc
->funcs
->pDeleteDC
) dc
->funcs
->pDeleteDC(dc
->physDev
);
913 while (dc
->saved_visrgn
)
915 struct saved_visrgn
*next
= dc
->saved_visrgn
->next
;
916 DeleteObject( dc
->saved_visrgn
->hrgn
);
917 HeapFree( GetProcessHeap(), 0, dc
->saved_visrgn
);
918 dc
->saved_visrgn
= next
;
920 if (dc
->hClipRgn
) DeleteObject( dc
->hClipRgn
);
921 if (dc
->hMetaRgn
) DeleteObject( dc
->hMetaRgn
);
922 if (dc
->hMetaClipRgn
) DeleteObject( dc
->hMetaClipRgn
);
923 if (dc
->hVisRgn
) DeleteObject( dc
->hVisRgn
);
924 PATH_DestroyGdiPath(&dc
->path
);
927 if (funcs
) DRIVER_release_driver( funcs
); /* do that after releasing the GDI lock */
932 /***********************************************************************
935 HDC WINAPI
ResetDCW( HDC hdc
, const DEVMODEW
*devmode
)
940 if ((dc
= get_dc_ptr( hdc
)))
942 if (dc
->funcs
->pResetDC
) ret
= dc
->funcs
->pResetDC( dc
->physDev
, devmode
);
943 release_dc_ptr( dc
);
949 /***********************************************************************
952 HDC WINAPI
ResetDCA( HDC hdc
, const DEVMODEA
*devmode
)
957 if (devmode
) devmodeW
= GdiConvertToDevmodeW(devmode
);
958 else devmodeW
= NULL
;
960 ret
= ResetDCW(hdc
, devmodeW
);
962 HeapFree(GetProcessHeap(), 0, devmodeW
);
967 /***********************************************************************
968 * GetDeviceCaps (GDI32.@)
970 INT WINAPI
GetDeviceCaps( HDC hdc
, INT cap
)
975 if ((dc
= get_dc_ptr( hdc
)))
977 if (dc
->funcs
->pGetDeviceCaps
) ret
= dc
->funcs
->pGetDeviceCaps( dc
->physDev
, cap
);
978 else switch(cap
) /* return meaningful values for some entries */
980 case HORZRES
: ret
= 640; break;
981 case VERTRES
: ret
= 480; break;
982 case BITSPIXEL
: ret
= 1; break;
983 case PLANES
: ret
= 1; break;
984 case NUMCOLORS
: ret
= 2; break;
985 case ASPECTX
: ret
= 36; break;
986 case ASPECTY
: ret
= 36; break;
987 case ASPECTXY
: ret
= 51; break;
988 case LOGPIXELSX
: ret
= 72; break;
989 case LOGPIXELSY
: ret
= 72; break;
990 case SIZEPALETTE
: ret
= 2; break;
992 release_dc_ptr( dc
);
998 /***********************************************************************
999 * GetBkColor (GDI32.@)
1001 COLORREF WINAPI
GetBkColor( HDC hdc
)
1004 DC
* dc
= get_dc_ptr( hdc
);
1007 ret
= dc
->backgroundColor
;
1008 release_dc_ptr( dc
);
1014 /***********************************************************************
1015 * SetBkColor (GDI32.@)
1017 COLORREF WINAPI
SetBkColor( HDC hdc
, COLORREF color
)
1020 DC
* dc
= get_dc_ptr( hdc
);
1022 TRACE("hdc=%p color=0x%08x\n", hdc
, color
);
1024 if (!dc
) return CLR_INVALID
;
1025 oldColor
= dc
->backgroundColor
;
1026 if (dc
->funcs
->pSetBkColor
)
1028 color
= dc
->funcs
->pSetBkColor(dc
->physDev
, color
);
1029 if (color
== CLR_INVALID
) /* don't change it */
1032 oldColor
= CLR_INVALID
;
1035 dc
->backgroundColor
= color
;
1036 release_dc_ptr( dc
);
1041 /***********************************************************************
1042 * GetTextColor (GDI32.@)
1044 COLORREF WINAPI
GetTextColor( HDC hdc
)
1047 DC
* dc
= get_dc_ptr( hdc
);
1050 ret
= dc
->textColor
;
1051 release_dc_ptr( dc
);
1057 /***********************************************************************
1058 * SetTextColor (GDI32.@)
1060 COLORREF WINAPI
SetTextColor( HDC hdc
, COLORREF color
)
1063 DC
* dc
= get_dc_ptr( hdc
);
1065 TRACE(" hdc=%p color=0x%08x\n", hdc
, color
);
1067 if (!dc
) return CLR_INVALID
;
1068 oldColor
= dc
->textColor
;
1069 if (dc
->funcs
->pSetTextColor
)
1071 color
= dc
->funcs
->pSetTextColor(dc
->physDev
, color
);
1072 if (color
== CLR_INVALID
) /* don't change it */
1075 oldColor
= CLR_INVALID
;
1078 dc
->textColor
= color
;
1079 release_dc_ptr( dc
);
1084 /***********************************************************************
1085 * GetTextAlign (GDI32.@)
1087 UINT WINAPI
GetTextAlign( HDC hdc
)
1090 DC
* dc
= get_dc_ptr( hdc
);
1093 ret
= dc
->textAlign
;
1094 release_dc_ptr( dc
);
1100 /***********************************************************************
1101 * SetTextAlign (GDI32.@)
1103 UINT WINAPI
SetTextAlign( HDC hdc
, UINT align
)
1106 DC
*dc
= get_dc_ptr( hdc
);
1108 TRACE("hdc=%p align=%d\n", hdc
, align
);
1110 if (!dc
) return 0x0;
1111 ret
= dc
->textAlign
;
1112 if (dc
->funcs
->pSetTextAlign
)
1113 if (!dc
->funcs
->pSetTextAlign(dc
->physDev
, align
))
1115 if (ret
!= GDI_ERROR
)
1116 dc
->textAlign
= align
;
1117 release_dc_ptr( dc
);
1121 /***********************************************************************
1122 * GetDCOrgEx (GDI32.@)
1124 BOOL WINAPI
GetDCOrgEx( HDC hDC
, LPPOINT lpp
)
1128 if (!lpp
) return FALSE
;
1129 if (!(dc
= get_dc_ptr( hDC
))) return FALSE
;
1131 lpp
->x
= lpp
->y
= 0;
1132 if (dc
->funcs
->pGetDCOrgEx
) dc
->funcs
->pGetDCOrgEx( dc
->physDev
, lpp
);
1133 release_dc_ptr( dc
);
1138 /***********************************************************************
1139 * SetDCOrg (GDI.117)
1141 DWORD WINAPI
SetDCOrg16( HDC16 hdc16
, INT16 x
, INT16 y
)
1144 HDC hdc
= HDC_32( hdc16
);
1145 DC
*dc
= get_dc_ptr( hdc
);
1147 if (dc
->funcs
->pSetDCOrg
) prevOrg
= dc
->funcs
->pSetDCOrg( dc
->physDev
, x
, y
);
1148 release_dc_ptr( dc
);
1153 /***********************************************************************
1154 * GetGraphicsMode (GDI32.@)
1156 INT WINAPI
GetGraphicsMode( HDC hdc
)
1159 DC
* dc
= get_dc_ptr( hdc
);
1162 ret
= dc
->GraphicsMode
;
1163 release_dc_ptr( dc
);
1169 /***********************************************************************
1170 * SetGraphicsMode (GDI32.@)
1172 INT WINAPI
SetGraphicsMode( HDC hdc
, INT mode
)
1175 DC
*dc
= get_dc_ptr( hdc
);
1177 /* One would think that setting the graphics mode to GM_COMPATIBLE
1178 * would also reset the world transformation matrix to the unity
1179 * matrix. However, in Windows, this is not the case. This doesn't
1180 * make a lot of sense to me, but that's the way it is.
1183 if ((mode
> 0) && (mode
<= GM_LAST
))
1185 ret
= dc
->GraphicsMode
;
1186 dc
->GraphicsMode
= mode
;
1188 release_dc_ptr( dc
);
1193 /***********************************************************************
1194 * GetArcDirection (GDI32.@)
1196 INT WINAPI
GetArcDirection( HDC hdc
)
1199 DC
* dc
= get_dc_ptr( hdc
);
1202 ret
= dc
->ArcDirection
;
1203 release_dc_ptr( dc
);
1209 /***********************************************************************
1210 * SetArcDirection (GDI32.@)
1212 INT WINAPI
SetArcDirection( HDC hdc
, INT nDirection
)
1215 INT nOldDirection
= 0;
1217 if (nDirection
!=AD_COUNTERCLOCKWISE
&& nDirection
!=AD_CLOCKWISE
)
1219 SetLastError(ERROR_INVALID_PARAMETER
);
1223 if ((dc
= get_dc_ptr( hdc
)))
1225 if (dc
->funcs
->pSetArcDirection
)
1227 dc
->funcs
->pSetArcDirection(dc
->physDev
, nDirection
);
1229 nOldDirection
= dc
->ArcDirection
;
1230 dc
->ArcDirection
= nDirection
;
1231 release_dc_ptr( dc
);
1233 return nOldDirection
;
1237 /***********************************************************************
1238 * GetWorldTransform (GDI32.@)
1240 BOOL WINAPI
GetWorldTransform( HDC hdc
, LPXFORM xform
)
1243 if (!xform
) return FALSE
;
1244 if (!(dc
= get_dc_ptr( hdc
))) return FALSE
;
1245 *xform
= dc
->xformWorld2Wnd
;
1246 release_dc_ptr( dc
);
1251 /***********************************************************************
1252 * GetTransform (GDI32.@)
1254 BOOL WINAPI
GetTransform( HDC hdc
, DWORD unknown
, LPXFORM xform
)
1256 if (unknown
== 0x0203) return GetWorldTransform( hdc
, xform
);
1257 FIXME("stub: don't know what to do for code %x\n", unknown
);
1262 /***********************************************************************
1263 * SetWorldTransform (GDI32.@)
1265 BOOL WINAPI
SetWorldTransform( HDC hdc
, const XFORM
*xform
)
1268 DC
*dc
= get_dc_ptr( hdc
);
1270 if (!dc
) return FALSE
;
1271 if (!xform
) goto done
;
1273 /* Check that graphics mode is GM_ADVANCED */
1274 if (dc
->GraphicsMode
!=GM_ADVANCED
) goto done
;
1276 if (dc
->funcs
->pSetWorldTransform
)
1278 ret
= dc
->funcs
->pSetWorldTransform(dc
->physDev
, xform
);
1279 if (!ret
) goto done
;
1282 dc
->xformWorld2Wnd
= *xform
;
1283 DC_UpdateXforms( dc
);
1286 release_dc_ptr( dc
);
1291 /****************************************************************************
1292 * ModifyWorldTransform [GDI32.@]
1293 * Modifies the world transformation for a device context.
1296 * hdc [I] Handle to device context
1297 * xform [I] XFORM structure that will be used to modify the world
1299 * iMode [I] Specifies in what way to modify the world transformation
1302 * Resets the world transformation to the identity matrix.
1303 * The parameter xform is ignored.
1305 * Multiplies xform into the world transformation matrix from
1308 * Multiplies xform into the world transformation matrix from
1313 * Failure: FALSE. Use GetLastError() to determine the cause.
1315 BOOL WINAPI
ModifyWorldTransform( HDC hdc
, const XFORM
*xform
,
1319 DC
*dc
= get_dc_ptr( hdc
);
1321 /* Check for illegal parameters */
1322 if (!dc
) return FALSE
;
1323 if (!xform
&& iMode
!= MWT_IDENTITY
) goto done
;
1325 /* Check that graphics mode is GM_ADVANCED */
1326 if (dc
->GraphicsMode
!=GM_ADVANCED
) goto done
;
1328 if (dc
->funcs
->pModifyWorldTransform
)
1330 ret
= dc
->funcs
->pModifyWorldTransform(dc
->physDev
, xform
, iMode
);
1331 if (!ret
) goto done
;
1337 dc
->xformWorld2Wnd
.eM11
= 1.0f
;
1338 dc
->xformWorld2Wnd
.eM12
= 0.0f
;
1339 dc
->xformWorld2Wnd
.eM21
= 0.0f
;
1340 dc
->xformWorld2Wnd
.eM22
= 1.0f
;
1341 dc
->xformWorld2Wnd
.eDx
= 0.0f
;
1342 dc
->xformWorld2Wnd
.eDy
= 0.0f
;
1344 case MWT_LEFTMULTIPLY
:
1345 CombineTransform( &dc
->xformWorld2Wnd
, xform
,
1346 &dc
->xformWorld2Wnd
);
1348 case MWT_RIGHTMULTIPLY
:
1349 CombineTransform( &dc
->xformWorld2Wnd
, &dc
->xformWorld2Wnd
,
1356 DC_UpdateXforms( dc
);
1359 release_dc_ptr( dc
);
1364 /****************************************************************************
1365 * CombineTransform [GDI32.@]
1366 * Combines two transformation matrices.
1369 * xformResult [O] Stores the result of combining the two matrices
1370 * xform1 [I] Specifies the first matrix to apply
1371 * xform2 [I] Specifies the second matrix to apply
1374 * The same matrix can be passed in for more than one of the parameters.
1378 * Failure: FALSE. Use GetLastError() to determine the cause.
1380 BOOL WINAPI
CombineTransform( LPXFORM xformResult
, const XFORM
*xform1
,
1381 const XFORM
*xform2
)
1385 /* Check for illegal parameters */
1386 if (!xformResult
|| !xform1
|| !xform2
)
1389 /* Create the result in a temporary XFORM, since xformResult may be
1390 * equal to xform1 or xform2 */
1391 xformTemp
.eM11
= xform1
->eM11
* xform2
->eM11
+
1392 xform1
->eM12
* xform2
->eM21
;
1393 xformTemp
.eM12
= xform1
->eM11
* xform2
->eM12
+
1394 xform1
->eM12
* xform2
->eM22
;
1395 xformTemp
.eM21
= xform1
->eM21
* xform2
->eM11
+
1396 xform1
->eM22
* xform2
->eM21
;
1397 xformTemp
.eM22
= xform1
->eM21
* xform2
->eM12
+
1398 xform1
->eM22
* xform2
->eM22
;
1399 xformTemp
.eDx
= xform1
->eDx
* xform2
->eM11
+
1400 xform1
->eDy
* xform2
->eM21
+
1402 xformTemp
.eDy
= xform1
->eDx
* xform2
->eM12
+
1403 xform1
->eDy
* xform2
->eM22
+
1406 /* Copy the result to xformResult */
1407 *xformResult
= xformTemp
;
1413 /***********************************************************************
1414 * SetDCHook (GDI32.@)
1416 * Note: this doesn't exist in Win32, we add it here because user32 needs it.
1418 BOOL WINAPI
SetDCHook( HDC hdc
, DCHOOKPROC hookProc
, DWORD_PTR dwHookData
)
1420 DC
*dc
= get_dc_ptr( hdc
);
1422 if (!dc
) return FALSE
;
1424 if (!(dc
->flags
& DC_SAVED
))
1426 dc
->dwHookData
= dwHookData
;
1427 dc
->hookThunk
= hookProc
;
1429 release_dc_ptr( dc
);
1434 /* relay function to call the 16-bit DC hook proc */
1435 static BOOL WINAPI
call_dc_hook16( HDC hdc
, WORD code
, DWORD_PTR data
, LPARAM lParam
)
1439 DC
*dc
= get_dc_ptr( hdc
);
1441 if (!dc
) return FALSE
;
1444 args
[5] = HDC_16(hdc
);
1446 args
[3] = HIWORD(data
);
1447 args
[2] = LOWORD(data
);
1448 args
[1] = HIWORD(lParam
);
1449 args
[0] = LOWORD(lParam
);
1450 WOWCallback16Ex( (DWORD
)dc
->hookProc
, WCB16_PASCAL
, sizeof(args
), args
, &ret
);
1452 release_dc_ptr( dc
);
1456 /***********************************************************************
1457 * SetDCHook (GDI.190)
1459 BOOL16 WINAPI
SetDCHook16( HDC16 hdc16
, FARPROC16 hookProc
, DWORD dwHookData
)
1461 DC
*dc
= get_dc_ptr( HDC_32(hdc16
) );
1463 if (!dc
) return FALSE
;
1464 if (!(dc
->flags
& DC_SAVED
))
1466 dc
->dwHookData
= dwHookData
;
1467 dc
->hookThunk
= call_dc_hook16
;
1468 dc
->hookProc
= hookProc
;
1470 release_dc_ptr( dc
);
1475 /***********************************************************************
1476 * GetDCHook (GDI.191)
1478 DWORD WINAPI
GetDCHook16( HDC16 hdc16
, FARPROC16
*phookProc
)
1480 HDC hdc
= HDC_32( hdc16
);
1481 DC
*dc
= get_dc_ptr( hdc
);
1485 *phookProc
= dc
->hookProc
;
1486 ret
= dc
->dwHookData
;
1487 release_dc_ptr( dc
);
1492 /***********************************************************************
1493 * SetHookFlags (GDI.192)
1495 WORD WINAPI
SetHookFlags16(HDC16 hdc16
, WORD flags
)
1497 HDC hdc
= HDC_32( hdc16
);
1498 DC
*dc
= get_dc_obj( hdc
); /* not get_dc_ptr, this needs to work from any thread */
1503 /* "Undocumented Windows" info is slightly confusing. */
1505 TRACE("hDC %p, flags %04x\n",hdc
,flags
);
1507 if (flags
& DCHF_INVALIDATEVISRGN
)
1508 ret
= InterlockedExchange( &dc
->dirty
, 1 );
1509 else if (flags
& DCHF_VALIDATEVISRGN
|| !flags
)
1510 ret
= InterlockedExchange( &dc
->dirty
, 0 );
1512 GDI_ReleaseObj( dc
);
1516 /***********************************************************************
1517 * SetICMMode (GDI32.@)
1519 INT WINAPI
SetICMMode(HDC hdc
, INT iEnableICM
)
1521 /*FIXME Asuming that ICM is always off, and cannot be turned on */
1522 if (iEnableICM
== ICM_OFF
) return ICM_OFF
;
1523 if (iEnableICM
== ICM_ON
) return 0;
1524 if (iEnableICM
== ICM_QUERY
) return ICM_OFF
;
1528 /***********************************************************************
1529 * GetDeviceGammaRamp (GDI32.@)
1531 BOOL WINAPI
GetDeviceGammaRamp(HDC hDC
, LPVOID ptr
)
1534 DC
*dc
= get_dc_ptr( hDC
);
1538 if (dc
->funcs
->pGetDeviceGammaRamp
)
1539 ret
= dc
->funcs
->pGetDeviceGammaRamp(dc
->physDev
, ptr
);
1540 release_dc_ptr( dc
);
1545 /***********************************************************************
1546 * SetDeviceGammaRamp (GDI32.@)
1548 BOOL WINAPI
SetDeviceGammaRamp(HDC hDC
, LPVOID ptr
)
1551 DC
*dc
= get_dc_ptr( hDC
);
1555 if (dc
->funcs
->pSetDeviceGammaRamp
)
1556 ret
= dc
->funcs
->pSetDeviceGammaRamp(dc
->physDev
, ptr
);
1557 release_dc_ptr( dc
);
1562 /***********************************************************************
1563 * GetColorSpace (GDI32.@)
1565 HCOLORSPACE WINAPI
GetColorSpace(HDC hdc
)
1567 /*FIXME Need to to whatever GetColorSpace actually does */
1571 /***********************************************************************
1572 * CreateColorSpaceA (GDI32.@)
1574 HCOLORSPACE WINAPI
CreateColorSpaceA( LPLOGCOLORSPACEA lpLogColorSpace
)
1580 /***********************************************************************
1581 * CreateColorSpaceW (GDI32.@)
1583 HCOLORSPACE WINAPI
CreateColorSpaceW( LPLOGCOLORSPACEW lpLogColorSpace
)
1589 /***********************************************************************
1590 * DeleteColorSpace (GDI32.@)
1592 BOOL WINAPI
DeleteColorSpace( HCOLORSPACE hColorSpace
)
1599 /***********************************************************************
1600 * SetColorSpace (GDI32.@)
1602 HCOLORSPACE WINAPI
SetColorSpace( HDC hDC
, HCOLORSPACE hColorSpace
)
1609 /***********************************************************************
1610 * GetBoundsRect (GDI32.@)
1612 UINT WINAPI
GetBoundsRect(HDC hdc
, LPRECT rect
, UINT flags
)
1615 DC
*dc
= get_dc_ptr( hdc
);
1617 if ( !dc
) return 0;
1619 if (rect
) *rect
= dc
->BoundsRect
;
1621 ret
= ((dc
->flags
& DC_BOUNDS_SET
) ? DCB_SET
: DCB_RESET
);
1623 if (flags
& DCB_RESET
)
1625 dc
->BoundsRect
.left
= 0;
1626 dc
->BoundsRect
.top
= 0;
1627 dc
->BoundsRect
.right
= 0;
1628 dc
->BoundsRect
.bottom
= 0;
1629 dc
->flags
&= ~DC_BOUNDS_SET
;
1631 release_dc_ptr( dc
);
1636 /***********************************************************************
1637 * SetBoundsRect (GDI32.@)
1639 UINT WINAPI
SetBoundsRect(HDC hdc
, const RECT
* rect
, UINT flags
)
1644 if ((flags
& DCB_ENABLE
) && (flags
& DCB_DISABLE
)) return 0;
1645 if (!(dc
= get_dc_ptr( hdc
))) return 0;
1647 ret
= ((dc
->flags
& DC_BOUNDS_ENABLE
) ? DCB_ENABLE
: DCB_DISABLE
) |
1648 ((dc
->flags
& DC_BOUNDS_SET
) ? DCB_SET
: DCB_RESET
);
1650 if (flags
& DCB_RESET
)
1652 dc
->BoundsRect
.left
= 0;
1653 dc
->BoundsRect
.top
= 0;
1654 dc
->BoundsRect
.right
= 0;
1655 dc
->BoundsRect
.bottom
= 0;
1656 dc
->flags
&= ~DC_BOUNDS_SET
;
1659 if ((flags
& DCB_ACCUMULATE
) && rect
&& rect
->left
< rect
->right
&& rect
->top
< rect
->bottom
)
1661 if (dc
->flags
& DC_BOUNDS_SET
)
1663 dc
->BoundsRect
.left
= min( dc
->BoundsRect
.left
, rect
->left
);
1664 dc
->BoundsRect
.top
= min( dc
->BoundsRect
.top
, rect
->top
);
1665 dc
->BoundsRect
.right
= max( dc
->BoundsRect
.right
, rect
->right
);
1666 dc
->BoundsRect
.bottom
= max( dc
->BoundsRect
.bottom
, rect
->bottom
);
1670 dc
->BoundsRect
= *rect
;
1671 dc
->flags
|= DC_BOUNDS_SET
;
1675 if (flags
& DCB_ENABLE
) dc
->flags
|= DC_BOUNDS_ENABLE
;
1676 if (flags
& DCB_DISABLE
) dc
->flags
&= ~DC_BOUNDS_ENABLE
;
1678 release_dc_ptr( dc
);
1683 /***********************************************************************
1684 * GetRelAbs (GDI32.@)
1686 INT WINAPI
GetRelAbs( HDC hdc
, DWORD dwIgnore
)
1689 DC
*dc
= get_dc_ptr( hdc
);
1692 ret
= dc
->relAbsMode
;
1693 release_dc_ptr( dc
);
1701 /***********************************************************************
1702 * GetBkMode (GDI32.@)
1704 INT WINAPI
GetBkMode( HDC hdc
)
1707 DC
* dc
= get_dc_ptr( hdc
);
1710 ret
= dc
->backgroundMode
;
1711 release_dc_ptr( dc
);
1717 /***********************************************************************
1718 * SetBkMode (GDI32.@)
1720 INT WINAPI
SetBkMode( HDC hdc
, INT mode
)
1724 if ((mode
<= 0) || (mode
> BKMODE_LAST
))
1726 SetLastError(ERROR_INVALID_PARAMETER
);
1729 if (!(dc
= get_dc_ptr( hdc
))) return 0;
1731 ret
= dc
->backgroundMode
;
1732 if (dc
->funcs
->pSetBkMode
)
1733 if (!dc
->funcs
->pSetBkMode( dc
->physDev
, mode
))
1736 dc
->backgroundMode
= mode
;
1737 release_dc_ptr( dc
);
1742 /***********************************************************************
1745 INT WINAPI
GetROP2( HDC hdc
)
1748 DC
* dc
= get_dc_ptr( hdc
);
1752 release_dc_ptr( dc
);
1758 /***********************************************************************
1761 INT WINAPI
SetROP2( HDC hdc
, INT mode
)
1765 if ((mode
< R2_BLACK
) || (mode
> R2_WHITE
))
1767 SetLastError(ERROR_INVALID_PARAMETER
);
1770 if (!(dc
= get_dc_ptr( hdc
))) return 0;
1772 if (dc
->funcs
->pSetROP2
)
1773 if (!dc
->funcs
->pSetROP2( dc
->physDev
, mode
))
1777 release_dc_ptr( dc
);
1782 /***********************************************************************
1783 * SetRelAbs (GDI32.@)
1785 INT WINAPI
SetRelAbs( HDC hdc
, INT mode
)
1789 if ((mode
!= ABSOLUTE
) && (mode
!= RELATIVE
))
1791 SetLastError(ERROR_INVALID_PARAMETER
);
1794 if (!(dc
= get_dc_ptr( hdc
))) return 0;
1795 if (dc
->funcs
->pSetRelAbs
)
1796 ret
= dc
->funcs
->pSetRelAbs( dc
->physDev
, mode
);
1799 ret
= dc
->relAbsMode
;
1800 dc
->relAbsMode
= mode
;
1802 release_dc_ptr( dc
);
1807 /***********************************************************************
1808 * GetPolyFillMode (GDI32.@)
1810 INT WINAPI
GetPolyFillMode( HDC hdc
)
1813 DC
* dc
= get_dc_ptr( hdc
);
1816 ret
= dc
->polyFillMode
;
1817 release_dc_ptr( dc
);
1823 /***********************************************************************
1824 * SetPolyFillMode (GDI32.@)
1826 INT WINAPI
SetPolyFillMode( HDC hdc
, INT mode
)
1830 if ((mode
<= 0) || (mode
> POLYFILL_LAST
))
1832 SetLastError(ERROR_INVALID_PARAMETER
);
1835 if (!(dc
= get_dc_ptr( hdc
))) return 0;
1836 ret
= dc
->polyFillMode
;
1837 if (dc
->funcs
->pSetPolyFillMode
)
1838 if (!dc
->funcs
->pSetPolyFillMode( dc
->physDev
, mode
))
1841 dc
->polyFillMode
= mode
;
1842 release_dc_ptr( dc
);
1847 /***********************************************************************
1848 * GetStretchBltMode (GDI32.@)
1850 INT WINAPI
GetStretchBltMode( HDC hdc
)
1853 DC
* dc
= get_dc_ptr( hdc
);
1856 ret
= dc
->stretchBltMode
;
1857 release_dc_ptr( dc
);
1863 /***********************************************************************
1864 * SetStretchBltMode (GDI32.@)
1866 INT WINAPI
SetStretchBltMode( HDC hdc
, INT mode
)
1870 if ((mode
<= 0) || (mode
> MAXSTRETCHBLTMODE
))
1872 SetLastError(ERROR_INVALID_PARAMETER
);
1875 if (!(dc
= get_dc_ptr( hdc
))) return 0;
1876 ret
= dc
->stretchBltMode
;
1877 if (dc
->funcs
->pSetStretchBltMode
)
1878 if (!dc
->funcs
->pSetStretchBltMode( dc
->physDev
, mode
))
1881 dc
->stretchBltMode
= mode
;
1882 release_dc_ptr( dc
);
1887 /***********************************************************************
1888 * GetMapMode (GDI32.@)
1890 INT WINAPI
GetMapMode( HDC hdc
)
1893 DC
* dc
= get_dc_ptr( hdc
);
1897 release_dc_ptr( dc
);
1903 /***********************************************************************
1904 * GetBrushOrgEx (GDI32.@)
1906 BOOL WINAPI
GetBrushOrgEx( HDC hdc
, LPPOINT pt
)
1908 DC
* dc
= get_dc_ptr( hdc
);
1909 if (!dc
) return FALSE
;
1910 pt
->x
= dc
->brushOrgX
;
1911 pt
->y
= dc
->brushOrgY
;
1912 release_dc_ptr( dc
);
1917 /***********************************************************************
1918 * GetCurrentPositionEx (GDI32.@)
1920 BOOL WINAPI
GetCurrentPositionEx( HDC hdc
, LPPOINT pt
)
1922 DC
* dc
= get_dc_ptr( hdc
);
1923 if (!dc
) return FALSE
;
1924 pt
->x
= dc
->CursPosX
;
1925 pt
->y
= dc
->CursPosY
;
1926 release_dc_ptr( dc
);
1931 /***********************************************************************
1932 * GetViewportExtEx (GDI32.@)
1934 BOOL WINAPI
GetViewportExtEx( HDC hdc
, LPSIZE size
)
1936 DC
* dc
= get_dc_ptr( hdc
);
1937 if (!dc
) return FALSE
;
1938 size
->cx
= dc
->vportExtX
;
1939 size
->cy
= dc
->vportExtY
;
1940 release_dc_ptr( dc
);
1945 /***********************************************************************
1946 * GetViewportOrgEx (GDI32.@)
1948 BOOL WINAPI
GetViewportOrgEx( HDC hdc
, LPPOINT pt
)
1950 DC
* dc
= get_dc_ptr( hdc
);
1951 if (!dc
) return FALSE
;
1952 pt
->x
= dc
->vportOrgX
;
1953 pt
->y
= dc
->vportOrgY
;
1954 release_dc_ptr( dc
);
1959 /***********************************************************************
1960 * GetWindowExtEx (GDI32.@)
1962 BOOL WINAPI
GetWindowExtEx( HDC hdc
, LPSIZE size
)
1964 DC
* dc
= get_dc_ptr( hdc
);
1965 if (!dc
) return FALSE
;
1966 size
->cx
= dc
->wndExtX
;
1967 size
->cy
= dc
->wndExtY
;
1968 release_dc_ptr( dc
);
1973 /***********************************************************************
1974 * GetWindowOrgEx (GDI32.@)
1976 BOOL WINAPI
GetWindowOrgEx( HDC hdc
, LPPOINT pt
)
1978 DC
* dc
= get_dc_ptr( hdc
);
1979 if (!dc
) return FALSE
;
1980 pt
->x
= dc
->wndOrgX
;
1981 pt
->y
= dc
->wndOrgY
;
1982 release_dc_ptr( dc
);
1987 /***********************************************************************
1988 * InquireVisRgn (GDI.131)
1990 HRGN16 WINAPI
InquireVisRgn16( HDC16 hdc
)
1993 DC
* dc
= get_dc_ptr( HDC_32(hdc
) );
1996 ret
= HRGN_16(dc
->hVisRgn
);
1997 release_dc_ptr( dc
);
2003 /***********************************************************************
2004 * GetClipRgn (GDI.173)
2006 HRGN16 WINAPI
GetClipRgn16( HDC16 hdc
)
2009 DC
* dc
= get_dc_ptr( HDC_32(hdc
) );
2012 ret
= HRGN_16(dc
->hClipRgn
);
2013 release_dc_ptr( dc
);
2019 /***********************************************************************
2020 * GetLayout (GDI32.@)
2022 * Gets left->right or right->left text layout flags of a dc.
2025 DWORD WINAPI
GetLayout(HDC hdc
)
2027 DWORD layout
= GDI_ERROR
;
2029 DC
* dc
= get_dc_ptr( hdc
);
2032 layout
= dc
->layout
;
2033 release_dc_ptr( dc
);
2036 TRACE("hdc : %p, layout : %08x\n", hdc
, layout
);
2041 /***********************************************************************
2042 * SetLayout (GDI32.@)
2044 * Sets left->right or right->left text layout flags of a dc.
2047 DWORD WINAPI
SetLayout(HDC hdc
, DWORD layout
)
2049 DWORD oldlayout
= GDI_ERROR
;
2051 DC
* dc
= get_dc_ptr( hdc
);
2054 oldlayout
= dc
->layout
;
2055 dc
->layout
= layout
;
2056 release_dc_ptr( dc
);
2059 TRACE("hdc : %p, old layout : %08x, new layout : %08x\n", hdc
, oldlayout
, layout
);
2064 /***********************************************************************
2065 * GetDCBrushColor (GDI32.@)
2067 * Retrieves the current brush color for the specified device
2071 COLORREF WINAPI
GetDCBrushColor(HDC hdc
)
2074 COLORREF dcBrushColor
= CLR_INVALID
;
2076 TRACE("hdc(%p)\n", hdc
);
2078 dc
= get_dc_ptr( hdc
);
2081 dcBrushColor
= dc
->dcBrushColor
;
2082 release_dc_ptr( dc
);
2085 return dcBrushColor
;
2088 /***********************************************************************
2089 * SetDCBrushColor (GDI32.@)
2091 * Sets the current device context (DC) brush color to the specified
2092 * color value. If the device cannot represent the specified color
2093 * value, the color is set to the nearest physical color.
2096 COLORREF WINAPI
SetDCBrushColor(HDC hdc
, COLORREF crColor
)
2099 COLORREF oldClr
= CLR_INVALID
;
2101 TRACE("hdc(%p) crColor(%08x)\n", hdc
, crColor
);
2103 dc
= get_dc_ptr( hdc
);
2106 if (dc
->funcs
->pSetDCBrushColor
)
2107 crColor
= dc
->funcs
->pSetDCBrushColor( dc
->physDev
, crColor
);
2108 else if (dc
->hBrush
== GetStockObject( DC_BRUSH
))
2110 /* If DC_BRUSH is selected, update driver pen color */
2111 HBRUSH hBrush
= CreateSolidBrush( crColor
);
2112 dc
->funcs
->pSelectBrush( dc
->physDev
, hBrush
);
2113 DeleteObject( hBrush
);
2116 if (crColor
!= CLR_INVALID
)
2118 oldClr
= dc
->dcBrushColor
;
2119 dc
->dcBrushColor
= crColor
;
2122 release_dc_ptr( dc
);
2128 /***********************************************************************
2129 * GetDCPenColor (GDI32.@)
2131 * Retrieves the current pen color for the specified device
2135 COLORREF WINAPI
GetDCPenColor(HDC hdc
)
2138 COLORREF dcPenColor
= CLR_INVALID
;
2140 TRACE("hdc(%p)\n", hdc
);
2142 dc
= get_dc_ptr( hdc
);
2145 dcPenColor
= dc
->dcPenColor
;
2146 release_dc_ptr( dc
);
2152 /***********************************************************************
2153 * SetDCPenColor (GDI32.@)
2155 * Sets the current device context (DC) pen color to the specified
2156 * color value. If the device cannot represent the specified color
2157 * value, the color is set to the nearest physical color.
2160 COLORREF WINAPI
SetDCPenColor(HDC hdc
, COLORREF crColor
)
2163 COLORREF oldClr
= CLR_INVALID
;
2165 TRACE("hdc(%p) crColor(%08x)\n", hdc
, crColor
);
2167 dc
= get_dc_ptr( hdc
);
2170 if (dc
->funcs
->pSetDCPenColor
)
2171 crColor
= dc
->funcs
->pSetDCPenColor( dc
->physDev
, crColor
);
2172 else if (dc
->hPen
== GetStockObject( DC_PEN
))
2174 /* If DC_PEN is selected, update the driver pen color */
2175 LOGPEN logpen
= { PS_SOLID
, { 0, 0 }, crColor
};
2176 HPEN hPen
= CreatePenIndirect( &logpen
);
2177 dc
->funcs
->pSelectPen( dc
->physDev
, hPen
);
2178 DeleteObject( hPen
);
2181 if (crColor
!= CLR_INVALID
)
2183 oldClr
= dc
->dcPenColor
;
2184 dc
->dcPenColor
= crColor
;
2187 release_dc_ptr( dc
);
2193 /***********************************************************************
2194 * CancelDC (GDI32.@)
2196 BOOL WINAPI
CancelDC(HDC hdc
)
2202 /***********************************************************************
2203 * SetVirtualResolution (GDI32.@)
2205 * Undocumented on msdn. Called when PowerPoint XP saves a file.
2207 DWORD WINAPI
SetVirtualResolution(HDC hdc
, DWORD dw2
, DWORD dw3
, DWORD dw4
, DWORD dw5
)
2209 FIXME("(%p %08x %08x %08x %08x): stub!\n", hdc
, dw2
, dw3
, dw4
, dw5
);
2213 /*******************************************************************
2214 * GetMiterLimit [GDI32.@]
2218 BOOL WINAPI
GetMiterLimit(HDC hdc
, PFLOAT peLimit
)
2223 TRACE("(%p,%p)\n", hdc
, peLimit
);
2225 dc
= get_dc_ptr( hdc
);
2229 *peLimit
= dc
->miterLimit
;
2231 release_dc_ptr( dc
);
2237 /*******************************************************************
2238 * SetMiterLimit [GDI32.@]
2242 BOOL WINAPI
SetMiterLimit(HDC hdc
, FLOAT eNewLimit
, PFLOAT peOldLimit
)
2247 TRACE("(%p,%f,%p)\n", hdc
, eNewLimit
, peOldLimit
);
2249 dc
= get_dc_ptr( hdc
);
2253 *peOldLimit
= dc
->miterLimit
;
2254 dc
->miterLimit
= eNewLimit
;
2255 release_dc_ptr( dc
);
2261 /*******************************************************************
2262 * GdiIsMetaPrintDC [GDI32.@]
2264 BOOL WINAPI
GdiIsMetaPrintDC(HDC hdc
)
2270 /*******************************************************************
2271 * GdiIsMetaFileDC [GDI32.@]
2273 BOOL WINAPI
GdiIsMetaFileDC(HDC hdc
)
2277 switch( GetObjectType( hdc
) )
2286 /*******************************************************************
2287 * GdiIsPlayMetafileDC [GDI32.@]
2289 BOOL WINAPI
GdiIsPlayMetafileDC(HDC hdc
)