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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
33 #include "wine/winuser16.h"
35 #include "gdi_private.h"
36 #include "wine/unicode.h"
37 #include "wine/debug.h"
39 WINE_DEFAULT_DEBUG_CHANNEL(dc
);
41 static BOOL
DC_DeleteObject( HGDIOBJ handle
, void *obj
);
43 static const struct gdi_obj_funcs dc_funcs
=
45 NULL
, /* pSelectObject */
46 NULL
, /* pGetObject16 */
47 NULL
, /* pGetObjectA */
48 NULL
, /* pGetObjectW */
49 NULL
, /* pUnrealizeObject */
50 DC_DeleteObject
/* pDeleteObject */
53 /***********************************************************************
56 DC
*DC_AllocDC( const DC_FUNCTIONS
*funcs
, WORD magic
)
61 if (!(dc
= GDI_AllocObject( sizeof(*dc
), magic
, (HGDIOBJ
*)&hdc
, &dc_funcs
))) return NULL
;
78 dc
->miterLimit
= 10.0f
; /* 10.0 is the default, from MSDN */
82 dc
->hPen
= GetStockObject( BLACK_PEN
);
83 dc
->hBrush
= GetStockObject( WHITE_BRUSH
);
84 dc
->hFont
= GetStockObject( SYSTEM_FONT
);
87 dc
->hPalette
= GetStockObject( DEFAULT_PALETTE
);
89 dc
->ROPmode
= R2_COPYPEN
;
90 dc
->polyFillMode
= ALTERNATE
;
91 dc
->stretchBltMode
= BLACKONWHITE
;
92 dc
->relAbsMode
= ABSOLUTE
;
93 dc
->backgroundMode
= OPAQUE
;
94 dc
->backgroundColor
= RGB( 255, 255, 255 );
95 dc
->dcBrushColor
= RGB( 255, 255, 255 );
96 dc
->dcPenColor
= RGB( 0, 0, 0 );
97 dc
->textColor
= RGB( 0, 0, 0 );
100 dc
->textAlign
= TA_LEFT
| TA_TOP
| TA_NOUPDATECP
;
104 dc
->MapMode
= MM_TEXT
;
105 dc
->GraphicsMode
= GM_COMPATIBLE
;
106 dc
->pAbortProc
= NULL
;
109 dc
->ArcDirection
= AD_COUNTERCLOCKWISE
;
110 dc
->xformWorld2Wnd
.eM11
= 1.0f
;
111 dc
->xformWorld2Wnd
.eM12
= 0.0f
;
112 dc
->xformWorld2Wnd
.eM21
= 0.0f
;
113 dc
->xformWorld2Wnd
.eM22
= 1.0f
;
114 dc
->xformWorld2Wnd
.eDx
= 0.0f
;
115 dc
->xformWorld2Wnd
.eDy
= 0.0f
;
116 dc
->xformWorld2Vport
= dc
->xformWorld2Wnd
;
117 dc
->xformVport2World
= dc
->xformWorld2Wnd
;
118 dc
->vport2WorldValid
= TRUE
;
119 dc
->BoundsRect
.left
= 0;
120 dc
->BoundsRect
.top
= 0;
121 dc
->BoundsRect
.right
= 0;
122 dc
->BoundsRect
.bottom
= 0;
123 PATH_InitGdiPath(&dc
->path
);
129 /***********************************************************************
132 DC
*DC_GetDCPtr( HDC hdc
)
134 GDIOBJHDR
*ptr
= GDI_GetObjPtr( hdc
, MAGIC_DONTCARE
);
135 if (!ptr
) return NULL
;
136 if ((GDIMAGIC(ptr
->wMagic
) == DC_MAGIC
) ||
137 (GDIMAGIC(ptr
->wMagic
) == MEMORY_DC_MAGIC
) ||
138 (GDIMAGIC(ptr
->wMagic
) == METAFILE_DC_MAGIC
) ||
139 (GDIMAGIC(ptr
->wMagic
) == ENHMETAFILE_DC_MAGIC
))
141 GDI_ReleaseObj( hdc
);
142 SetLastError( ERROR_INVALID_HANDLE
);
146 /***********************************************************************
149 * Retrieve a DC ptr while making sure the visRgn is updated.
150 * This function may call up to USER so the GDI lock should _not_
151 * be held when calling it.
153 DC
*DC_GetDCUpdate( HDC hdc
)
155 DC
*dc
= DC_GetDCPtr( hdc
);
156 if (!dc
) return NULL
;
157 while (dc
->flags
& DC_DIRTY
)
159 DCHOOKPROC proc
= dc
->hookThunk
;
160 dc
->flags
&= ~DC_DIRTY
;
163 DWORD data
= dc
->dwHookData
;
164 GDI_ReleaseObj( hdc
);
165 proc( HDC_16(hdc
), DCHC_INVALIDVISRGN
, data
, 0 );
166 if (!(dc
= DC_GetDCPtr( hdc
))) break;
167 /* otherwise restart the loop in case it became dirty again in the meantime */
174 /***********************************************************************
177 static BOOL
DC_DeleteObject( HGDIOBJ handle
, void *obj
)
179 GDI_ReleaseObj( handle
);
180 return DeleteDC( handle
);
184 /***********************************************************************
187 * Setup device-specific DC values for a newly created DC.
189 void DC_InitDC( DC
* dc
)
191 if (dc
->funcs
->pRealizeDefaultPalette
) dc
->funcs
->pRealizeDefaultPalette( dc
->physDev
);
192 SetTextColor( dc
->hSelf
, dc
->textColor
);
193 SetBkColor( dc
->hSelf
, dc
->backgroundColor
);
194 SelectObject( dc
->hSelf
, dc
->hPen
);
195 SelectObject( dc
->hSelf
, dc
->hBrush
);
196 SelectObject( dc
->hSelf
, dc
->hFont
);
197 CLIPPING_UpdateGCRegion( dc
);
201 /***********************************************************************
204 * Computes the inverse of the transformation xformSrc and stores it to
205 * xformDest. Returns TRUE if successful or FALSE if the xformSrc matrix
208 static BOOL
DC_InvertXform( const XFORM
*xformSrc
, XFORM
*xformDest
)
212 determinant
= xformSrc
->eM11
*xformSrc
->eM22
-
213 xformSrc
->eM12
*xformSrc
->eM21
;
214 if (determinant
> -1e-12 && determinant
< 1e-12)
217 xformDest
->eM11
= xformSrc
->eM22
/ determinant
;
218 xformDest
->eM12
= -xformSrc
->eM12
/ determinant
;
219 xformDest
->eM21
= -xformSrc
->eM21
/ determinant
;
220 xformDest
->eM22
= xformSrc
->eM11
/ determinant
;
221 xformDest
->eDx
= -xformSrc
->eDx
* xformDest
->eM11
-
222 xformSrc
->eDy
* xformDest
->eM21
;
223 xformDest
->eDy
= -xformSrc
->eDx
* xformDest
->eM12
-
224 xformSrc
->eDy
* xformDest
->eM22
;
230 /***********************************************************************
233 * Updates the xformWorld2Vport, xformVport2World and vport2WorldValid
234 * fields of the specified DC by creating a transformation that
235 * represents the current mapping mode and combining it with the DC's
236 * world transform. This function should be called whenever the
237 * parameters associated with the mapping mode (window and viewport
238 * extents and origins) or the world transform change.
240 void DC_UpdateXforms( DC
*dc
)
242 XFORM xformWnd2Vport
, oldworld2vport
;
243 FLOAT scaleX
, scaleY
;
245 /* Construct a transformation to do the window-to-viewport conversion */
246 scaleX
= (FLOAT
)dc
->vportExtX
/ (FLOAT
)dc
->wndExtX
;
247 scaleY
= (FLOAT
)dc
->vportExtY
/ (FLOAT
)dc
->wndExtY
;
248 xformWnd2Vport
.eM11
= scaleX
;
249 xformWnd2Vport
.eM12
= 0.0;
250 xformWnd2Vport
.eM21
= 0.0;
251 xformWnd2Vport
.eM22
= scaleY
;
252 xformWnd2Vport
.eDx
= (FLOAT
)dc
->vportOrgX
-
253 scaleX
* (FLOAT
)dc
->wndOrgX
;
254 xformWnd2Vport
.eDy
= (FLOAT
)dc
->vportOrgY
-
255 scaleY
* (FLOAT
)dc
->wndOrgY
;
257 oldworld2vport
= dc
->xformWorld2Vport
;
258 /* Combine with the world transformation */
259 CombineTransform( &dc
->xformWorld2Vport
, &dc
->xformWorld2Wnd
,
262 /* Create inverse of world-to-viewport transformation */
263 dc
->vport2WorldValid
= DC_InvertXform( &dc
->xformWorld2Vport
,
264 &dc
->xformVport2World
);
266 /* Reselect the font and pen back into the dc so that the size
268 if(memcmp(&oldworld2vport
, &dc
->xformWorld2Vport
, sizeof(oldworld2vport
)))
270 SelectObject(dc
->hSelf
, GetCurrentObject(dc
->hSelf
, OBJ_FONT
));
271 SelectObject(dc
->hSelf
, GetCurrentObject(dc
->hSelf
, OBJ_PEN
));
276 /***********************************************************************
277 * GetDCState (Not a Windows API)
279 HDC WINAPI
GetDCState( HDC hdc
)
284 if (!(dc
= DC_GetDCPtr( hdc
))) return 0;
285 if (!(newdc
= GDI_AllocObject( sizeof(DC
), GDIMAGIC(dc
->header
.wMagic
), &handle
, &dc_funcs
)))
287 GDI_ReleaseObj( hdc
);
290 TRACE("(%p): returning %p\n", hdc
, handle
);
292 newdc
->flags
= dc
->flags
| DC_SAVED
;
293 newdc
->hPen
= dc
->hPen
;
294 newdc
->hBrush
= dc
->hBrush
;
295 newdc
->hFont
= dc
->hFont
;
296 newdc
->hBitmap
= dc
->hBitmap
;
297 newdc
->hDevice
= dc
->hDevice
;
298 newdc
->hPalette
= dc
->hPalette
;
299 newdc
->ROPmode
= dc
->ROPmode
;
300 newdc
->polyFillMode
= dc
->polyFillMode
;
301 newdc
->stretchBltMode
= dc
->stretchBltMode
;
302 newdc
->relAbsMode
= dc
->relAbsMode
;
303 newdc
->backgroundMode
= dc
->backgroundMode
;
304 newdc
->backgroundColor
= dc
->backgroundColor
;
305 newdc
->textColor
= dc
->textColor
;
306 newdc
->dcBrushColor
= dc
->dcBrushColor
;
307 newdc
->dcPenColor
= dc
->dcPenColor
;
308 newdc
->brushOrgX
= dc
->brushOrgX
;
309 newdc
->brushOrgY
= dc
->brushOrgY
;
310 newdc
->textAlign
= dc
->textAlign
;
311 newdc
->charExtra
= dc
->charExtra
;
312 newdc
->breakExtra
= dc
->breakExtra
;
313 newdc
->breakRem
= dc
->breakRem
;
314 newdc
->MapMode
= dc
->MapMode
;
315 newdc
->GraphicsMode
= dc
->GraphicsMode
;
316 newdc
->CursPosX
= dc
->CursPosX
;
317 newdc
->CursPosY
= dc
->CursPosY
;
318 newdc
->ArcDirection
= dc
->ArcDirection
;
319 newdc
->xformWorld2Wnd
= dc
->xformWorld2Wnd
;
320 newdc
->xformWorld2Vport
= dc
->xformWorld2Vport
;
321 newdc
->xformVport2World
= dc
->xformVport2World
;
322 newdc
->vport2WorldValid
= dc
->vport2WorldValid
;
323 newdc
->wndOrgX
= dc
->wndOrgX
;
324 newdc
->wndOrgY
= dc
->wndOrgY
;
325 newdc
->wndExtX
= dc
->wndExtX
;
326 newdc
->wndExtY
= dc
->wndExtY
;
327 newdc
->vportOrgX
= dc
->vportOrgX
;
328 newdc
->vportOrgY
= dc
->vportOrgY
;
329 newdc
->vportExtX
= dc
->vportExtX
;
330 newdc
->vportExtY
= dc
->vportExtY
;
331 newdc
->BoundsRect
= dc
->BoundsRect
;
333 newdc
->hSelf
= (HDC
)handle
;
334 newdc
->saveLevel
= 0;
336 PATH_InitGdiPath( &newdc
->path
);
338 newdc
->pAbortProc
= NULL
;
339 newdc
->hookThunk
= NULL
;
342 /* Get/SetDCState() don't change hVisRgn field ("Undoc. Windows" p.559). */
347 newdc
->hClipRgn
= CreateRectRgn( 0, 0, 0, 0 );
348 CombineRgn( newdc
->hClipRgn
, dc
->hClipRgn
, 0, RGN_COPY
);
354 newdc
->gdiFont
= dc
->gdiFont
;
358 GDI_ReleaseObj( handle
);
359 GDI_ReleaseObj( hdc
);
364 /***********************************************************************
365 * SetDCState (Not a Windows API)
367 void WINAPI
SetDCState( HDC hdc
, HDC hdcs
)
371 if (!(dc
= DC_GetDCUpdate( hdc
))) return;
372 if (!(dcs
= DC_GetDCPtr( hdcs
)))
374 GDI_ReleaseObj( hdc
);
377 if (!dcs
->flags
& DC_SAVED
)
379 GDI_ReleaseObj( hdc
);
380 GDI_ReleaseObj( hdcs
);
383 TRACE("%p %p\n", hdc
, hdcs
);
385 dc
->flags
= dcs
->flags
& ~(DC_SAVED
| DC_DIRTY
);
386 dc
->hDevice
= dcs
->hDevice
;
387 dc
->ROPmode
= dcs
->ROPmode
;
388 dc
->polyFillMode
= dcs
->polyFillMode
;
389 dc
->stretchBltMode
= dcs
->stretchBltMode
;
390 dc
->relAbsMode
= dcs
->relAbsMode
;
391 dc
->backgroundMode
= dcs
->backgroundMode
;
392 dc
->backgroundColor
= dcs
->backgroundColor
;
393 dc
->textColor
= dcs
->textColor
;
394 dc
->dcBrushColor
= dcs
->dcBrushColor
;
395 dc
->dcPenColor
= dcs
->dcPenColor
;
396 dc
->brushOrgX
= dcs
->brushOrgX
;
397 dc
->brushOrgY
= dcs
->brushOrgY
;
398 dc
->textAlign
= dcs
->textAlign
;
399 dc
->charExtra
= dcs
->charExtra
;
400 dc
->breakExtra
= dcs
->breakExtra
;
401 dc
->breakRem
= dcs
->breakRem
;
402 dc
->MapMode
= dcs
->MapMode
;
403 dc
->GraphicsMode
= dcs
->GraphicsMode
;
404 dc
->CursPosX
= dcs
->CursPosX
;
405 dc
->CursPosY
= dcs
->CursPosY
;
406 dc
->ArcDirection
= dcs
->ArcDirection
;
407 dc
->xformWorld2Wnd
= dcs
->xformWorld2Wnd
;
408 dc
->xformWorld2Vport
= dcs
->xformWorld2Vport
;
409 dc
->xformVport2World
= dcs
->xformVport2World
;
410 dc
->vport2WorldValid
= dcs
->vport2WorldValid
;
411 dc
->BoundsRect
= dcs
->BoundsRect
;
413 dc
->wndOrgX
= dcs
->wndOrgX
;
414 dc
->wndOrgY
= dcs
->wndOrgY
;
415 dc
->wndExtX
= dcs
->wndExtX
;
416 dc
->wndExtY
= dcs
->wndExtY
;
417 dc
->vportOrgX
= dcs
->vportOrgX
;
418 dc
->vportOrgY
= dcs
->vportOrgY
;
419 dc
->vportExtX
= dcs
->vportExtX
;
420 dc
->vportExtY
= dcs
->vportExtY
;
424 if (!dc
->hClipRgn
) dc
->hClipRgn
= CreateRectRgn( 0, 0, 0, 0 );
425 CombineRgn( dc
->hClipRgn
, dcs
->hClipRgn
, 0, RGN_COPY
);
429 if (dc
->hClipRgn
) DeleteObject( dc
->hClipRgn
);
432 CLIPPING_UpdateGCRegion( dc
);
434 SelectObject( hdc
, dcs
->hBitmap
);
435 SelectObject( hdc
, dcs
->hBrush
);
436 SelectObject( hdc
, dcs
->hFont
);
437 SelectObject( hdc
, dcs
->hPen
);
438 SetBkColor( hdc
, dcs
->backgroundColor
);
439 SetTextColor( hdc
, dcs
->textColor
);
440 GDISelectPalette( hdc
, dcs
->hPalette
, FALSE
);
441 GDI_ReleaseObj( hdcs
);
442 GDI_ReleaseObj( hdc
);
446 /***********************************************************************
447 * GetDCState (GDI.179)
449 HDC16 WINAPI
GetDCState16( HDC16 hdc
)
451 return HDC_16( GetDCState( HDC_32(hdc
) ));
455 /***********************************************************************
456 * SetDCState (GDI.180)
458 void WINAPI
SetDCState16( HDC16 hdc
, HDC16 hdcs
)
460 SetDCState( HDC_32(hdc
), HDC_32(hdcs
) );
464 /***********************************************************************
467 INT WINAPI
SaveDC( HDC hdc
)
473 dc
= DC_GetDCPtr( hdc
);
476 if(dc
->funcs
->pSaveDC
)
478 ret
= dc
->funcs
->pSaveDC( dc
->physDev
);
479 GDI_ReleaseObj( hdc
);
483 if (!(hdcs
= GetDCState( hdc
)))
485 GDI_ReleaseObj( hdc
);
488 dcs
= DC_GetDCPtr( hdcs
);
490 /* Copy path. The reason why path saving / restoring is in SaveDC/
491 * RestoreDC and not in GetDCState/SetDCState is that the ...DCState
492 * functions are only in Win16 (which doesn't have paths) and that
493 * SetDCState doesn't allow us to signal an error (which can happen
494 * when copying paths).
496 if (!PATH_AssignGdiPath( &dcs
->path
, &dc
->path
))
498 GDI_ReleaseObj( hdc
);
499 GDI_ReleaseObj( hdcs
);
504 dcs
->header
.hNext
= dc
->header
.hNext
;
505 dc
->header
.hNext
= HDC_16(hdcs
);
506 TRACE("(%p): returning %d\n", hdc
, dc
->saveLevel
+1 );
507 ret
= ++dc
->saveLevel
;
508 GDI_ReleaseObj( hdcs
);
509 GDI_ReleaseObj( hdc
);
514 /***********************************************************************
515 * RestoreDC (GDI32.@)
517 BOOL WINAPI
RestoreDC( HDC hdc
, INT level
)
522 TRACE("%p %d\n", hdc
, level
);
523 dc
= DC_GetDCUpdate( hdc
);
524 if(!dc
) return FALSE
;
525 if(dc
->funcs
->pRestoreDC
)
527 success
= dc
->funcs
->pRestoreDC( dc
->physDev
, level
);
528 GDI_ReleaseObj( hdc
);
532 if (level
== -1) level
= dc
->saveLevel
;
534 /* This pair of checks disagrees with MSDN "Platform SDK:
535 Windows GDI" July 2000 which says all negative values
536 for level will be interpreted as an instance relative
537 to the current state. Restricting it to just -1 does
539 || (level
> dc
->saveLevel
))
541 GDI_ReleaseObj( hdc
);
546 while (dc
->saveLevel
>= level
)
548 HDC hdcs
= HDC_32(dc
->header
.hNext
);
549 if (!(dcs
= DC_GetDCPtr( hdcs
)))
551 GDI_ReleaseObj( hdc
);
554 dc
->header
.hNext
= dcs
->header
.hNext
;
555 if (--dc
->saveLevel
< level
)
557 SetDCState( hdc
, hdcs
);
558 if (!PATH_AssignGdiPath( &dc
->path
, &dcs
->path
))
559 /* FIXME: This might not be quite right, since we're
560 * returning FALSE but still destroying the saved DC state */
563 GDI_ReleaseObj( hdcs
);
564 GDI_ReleaseObj( hdc
);
566 if (!(dc
= DC_GetDCPtr( hdc
))) return FALSE
;
568 GDI_ReleaseObj( hdc
);
573 /***********************************************************************
574 * CreateDCW (GDI32.@)
576 HDC WINAPI
CreateDCW( LPCWSTR driver
, LPCWSTR device
, LPCWSTR output
,
577 const DEVMODEW
*initData
)
581 const DC_FUNCTIONS
*funcs
;
586 if (!device
|| !DRIVER_GetDriverName( device
, buf
, 300 ))
588 if (!driver
) return 0;
589 strcpyW(buf
, driver
);
592 if (!(funcs
= DRIVER_load_driver( buf
)))
594 ERR( "no driver found for %s\n", debugstr_w(buf
) );
597 if (!(dc
= DC_AllocDC( funcs
, DC_MAGIC
)))
599 DRIVER_release_driver( funcs
);
604 dc
->hBitmap
= GetStockObject( DEFAULT_BITMAP
);
606 TRACE("(driver=%s, device=%s, output=%s): returning %p\n",
607 debugstr_w(driver
), debugstr_w(device
), debugstr_w(output
), dc
->hSelf
);
609 if (dc
->funcs
->pCreateDC
&&
610 !dc
->funcs
->pCreateDC( hdc
, &dc
->physDev
, buf
, device
, output
, initData
))
612 WARN("creation aborted by device\n" );
613 GDI_FreeObject( dc
->hSelf
, dc
);
614 DRIVER_release_driver( funcs
);
618 dc
->hVisRgn
= CreateRectRgn( 0, 0, GetDeviceCaps( hdc
, HORZRES
),
619 GetDeviceCaps( hdc
, VERTRES
) );
622 GDI_ReleaseObj( hdc
);
627 /***********************************************************************
628 * CreateDCA (GDI32.@)
630 HDC WINAPI
CreateDCA( LPCSTR driver
, LPCSTR device
, LPCSTR output
,
631 const DEVMODEA
*initData
)
633 UNICODE_STRING driverW
, deviceW
, outputW
;
637 if (driver
) RtlCreateUnicodeStringFromAsciiz(&driverW
, driver
);
638 else driverW
.Buffer
= NULL
;
640 if (device
) RtlCreateUnicodeStringFromAsciiz(&deviceW
, device
);
641 else deviceW
.Buffer
= NULL
;
643 if (output
) RtlCreateUnicodeStringFromAsciiz(&outputW
, output
);
644 else outputW
.Buffer
= NULL
;
646 if (initData
) initDataW
= GdiConvertToDevmodeW(initData
);
647 else initDataW
= NULL
;
649 ret
= CreateDCW( driverW
.Buffer
, deviceW
.Buffer
, outputW
.Buffer
, initDataW
);
651 RtlFreeUnicodeString(&driverW
);
652 RtlFreeUnicodeString(&deviceW
);
653 RtlFreeUnicodeString(&outputW
);
654 if (initDataW
) HeapFree(GetProcessHeap(), 0, initDataW
);
659 /***********************************************************************
660 * CreateICA (GDI32.@)
662 HDC WINAPI
CreateICA( LPCSTR driver
, LPCSTR device
, LPCSTR output
,
663 const DEVMODEA
* initData
)
665 /* Nothing special yet for ICs */
666 return CreateDCA( driver
, device
, output
, initData
);
670 /***********************************************************************
671 * CreateICW (GDI32.@)
673 HDC WINAPI
CreateICW( LPCWSTR driver
, LPCWSTR device
, LPCWSTR output
,
674 const DEVMODEW
* initData
)
676 /* Nothing special yet for ICs */
677 return CreateDCW( driver
, device
, output
, initData
);
681 /***********************************************************************
682 * CreateCompatibleDC (GDI32.@)
684 HDC WINAPI
CreateCompatibleDC( HDC hdc
)
687 const DC_FUNCTIONS
*funcs
;
692 if ((origDC
= GDI_GetObjPtr( hdc
, DC_MAGIC
)))
694 funcs
= origDC
->funcs
;
695 physDev
= origDC
->physDev
;
696 GDI_ReleaseObj( hdc
); /* can't hold the lock while loading the driver */
697 funcs
= DRIVER_get_driver( funcs
);
701 static const WCHAR displayW
[] = { 'd','i','s','p','l','a','y',0 };
702 funcs
= DRIVER_load_driver( displayW
);
706 if (!funcs
) return 0;
708 if (!(dc
= DC_AllocDC( funcs
, MEMORY_DC_MAGIC
)))
710 DRIVER_release_driver( funcs
);
714 TRACE("(%p): returning %p\n", hdc
, dc
->hSelf
);
716 dc
->hBitmap
= GetStockObject( DEFAULT_BITMAP
);
718 /* Copy the driver-specific physical device info into
719 * the new DC. The driver may use this read-only info
720 * while creating the compatible DC below. */
721 dc
->physDev
= physDev
;
723 if (dc
->funcs
->pCreateDC
&&
724 !dc
->funcs
->pCreateDC( dc
->hSelf
, &dc
->physDev
, NULL
, NULL
, NULL
, NULL
))
726 WARN("creation aborted by device\n");
727 GDI_FreeObject( dc
->hSelf
, dc
);
728 DRIVER_release_driver( funcs
);
732 dc
->hVisRgn
= CreateRectRgn( 0, 0, 1, 1 ); /* default bitmap is 1x1 */
735 GDI_ReleaseObj( dc
->hSelf
);
740 /***********************************************************************
743 BOOL WINAPI
DeleteDC( HDC hdc
)
745 const DC_FUNCTIONS
*funcs
= NULL
;
752 if (!(dc
= DC_GetDCPtr( hdc
))) return FALSE
;
754 /* Call hook procedure to check whether is it OK to delete this DC */
757 DCHOOKPROC proc
= dc
->hookThunk
;
758 DWORD data
= dc
->dwHookData
;
759 GDI_ReleaseObj( hdc
);
760 if (!proc( HDC_16(hdc
), DCHC_DELETEDC
, data
, 0 )) return FALSE
;
761 if (!(dc
= DC_GetDCPtr( hdc
))) return TRUE
; /* deleted by the hook */
764 while (dc
->saveLevel
)
767 HDC hdcs
= HDC_32(dc
->header
.hNext
);
768 if (!(dcs
= DC_GetDCPtr( hdcs
))) break;
769 dc
->header
.hNext
= dcs
->header
.hNext
;
771 if (dcs
->hClipRgn
) DeleteObject( dcs
->hClipRgn
);
772 if (dcs
->hVisRgn
) DeleteObject( dcs
->hVisRgn
);
773 PATH_DestroyGdiPath(&dcs
->path
);
774 GDI_FreeObject( hdcs
, dcs
);
777 if (!(dc
->flags
& DC_SAVED
))
779 SelectObject( hdc
, GetStockObject(BLACK_PEN
) );
780 SelectObject( hdc
, GetStockObject(WHITE_BRUSH
) );
781 SelectObject( hdc
, GetStockObject(SYSTEM_FONT
) );
782 SelectObject( hdc
, GetStockObject(DEFAULT_BITMAP
) );
784 if (dc
->funcs
->pDeleteDC
) dc
->funcs
->pDeleteDC(dc
->physDev
);
788 if (dc
->hClipRgn
) DeleteObject( dc
->hClipRgn
);
789 if (dc
->hVisRgn
) DeleteObject( dc
->hVisRgn
);
790 PATH_DestroyGdiPath(&dc
->path
);
792 GDI_FreeObject( hdc
, dc
);
793 if (funcs
) DRIVER_release_driver( funcs
); /* do that after releasing the GDI lock */
798 /***********************************************************************
801 HDC WINAPI
ResetDCW( HDC hdc
, const DEVMODEW
*devmode
)
806 if ((dc
= DC_GetDCPtr( hdc
)))
808 if (dc
->funcs
->pResetDC
) ret
= dc
->funcs
->pResetDC( dc
->physDev
, devmode
);
809 GDI_ReleaseObj( hdc
);
815 /***********************************************************************
818 HDC WINAPI
ResetDCA( HDC hdc
, const DEVMODEA
*devmode
)
823 if (devmode
) devmodeW
= GdiConvertToDevmodeW(devmode
);
824 else devmodeW
= NULL
;
826 ret
= ResetDCW(hdc
, devmodeW
);
828 if (devmodeW
) HeapFree(GetProcessHeap(), 0, devmodeW
);
833 /***********************************************************************
834 * GetDeviceCaps (GDI32.@)
836 INT WINAPI
GetDeviceCaps( HDC hdc
, INT cap
)
841 if ((dc
= DC_GetDCPtr( hdc
)))
843 if (dc
->funcs
->pGetDeviceCaps
) ret
= dc
->funcs
->pGetDeviceCaps( dc
->physDev
, cap
);
844 GDI_ReleaseObj( hdc
);
850 /***********************************************************************
851 * GetBkColor (GDI32.@)
853 COLORREF WINAPI
GetBkColor( HDC hdc
)
856 DC
* dc
= DC_GetDCPtr( hdc
);
859 ret
= dc
->backgroundColor
;
860 GDI_ReleaseObj( hdc
);
866 /***********************************************************************
867 * SetBkColor (GDI32.@)
869 COLORREF WINAPI
SetBkColor( HDC hdc
, COLORREF color
)
872 DC
* dc
= DC_GetDCPtr( hdc
);
874 TRACE("hdc=%p color=0x%08lx\n", hdc
, color
);
876 if (!dc
) return CLR_INVALID
;
877 oldColor
= dc
->backgroundColor
;
878 if (dc
->funcs
->pSetBkColor
)
880 color
= dc
->funcs
->pSetBkColor(dc
->physDev
, color
);
881 if (color
== CLR_INVALID
) /* don't change it */
884 oldColor
= CLR_INVALID
;
887 dc
->backgroundColor
= color
;
888 GDI_ReleaseObj( hdc
);
893 /***********************************************************************
894 * GetTextColor (GDI32.@)
896 COLORREF WINAPI
GetTextColor( HDC hdc
)
899 DC
* dc
= DC_GetDCPtr( hdc
);
903 GDI_ReleaseObj( hdc
);
909 /***********************************************************************
910 * SetTextColor (GDI32.@)
912 COLORREF WINAPI
SetTextColor( HDC hdc
, COLORREF color
)
915 DC
* dc
= DC_GetDCPtr( hdc
);
917 TRACE(" hdc=%p color=0x%08lx\n", hdc
, color
);
919 if (!dc
) return CLR_INVALID
;
920 oldColor
= dc
->textColor
;
921 if (dc
->funcs
->pSetTextColor
)
923 color
= dc
->funcs
->pSetTextColor(dc
->physDev
, color
);
924 if (color
== CLR_INVALID
) /* don't change it */
927 oldColor
= CLR_INVALID
;
930 dc
->textColor
= color
;
931 GDI_ReleaseObj( hdc
);
936 /***********************************************************************
937 * GetTextAlign (GDI32.@)
939 UINT WINAPI
GetTextAlign( HDC hdc
)
942 DC
* dc
= DC_GetDCPtr( hdc
);
946 GDI_ReleaseObj( hdc
);
952 /***********************************************************************
953 * SetTextAlign (GDI32.@)
955 UINT WINAPI
SetTextAlign( HDC hdc
, UINT align
)
958 DC
*dc
= DC_GetDCPtr( hdc
);
960 TRACE("hdc=%p align=%d\n", hdc
, align
);
963 if (dc
->funcs
->pSetTextAlign
)
964 prevAlign
= dc
->funcs
->pSetTextAlign(dc
->physDev
, align
);
966 prevAlign
= dc
->textAlign
;
967 dc
->textAlign
= align
;
969 GDI_ReleaseObj( hdc
);
973 /***********************************************************************
974 * GetDCOrgEx (GDI32.@)
976 BOOL WINAPI
GetDCOrgEx( HDC hDC
, LPPOINT lpp
)
980 if (!lpp
) return FALSE
;
981 if (!(dc
= DC_GetDCPtr( hDC
))) return FALSE
;
984 if (dc
->funcs
->pGetDCOrgEx
) dc
->funcs
->pGetDCOrgEx( dc
->physDev
, lpp
);
985 GDI_ReleaseObj( hDC
);
990 /***********************************************************************
993 DWORD WINAPI
SetDCOrg16( HDC16 hdc16
, INT16 x
, INT16 y
)
996 HDC hdc
= HDC_32( hdc16
);
997 DC
*dc
= DC_GetDCPtr( hdc
);
999 if (dc
->funcs
->pSetDCOrg
) prevOrg
= dc
->funcs
->pSetDCOrg( dc
->physDev
, x
, y
);
1000 GDI_ReleaseObj( hdc
);
1005 /***********************************************************************
1006 * GetGraphicsMode (GDI32.@)
1008 INT WINAPI
GetGraphicsMode( HDC hdc
)
1011 DC
* dc
= DC_GetDCPtr( hdc
);
1014 ret
= dc
->GraphicsMode
;
1015 GDI_ReleaseObj( hdc
);
1021 /***********************************************************************
1022 * SetGraphicsMode (GDI32.@)
1024 INT WINAPI
SetGraphicsMode( HDC hdc
, INT mode
)
1027 DC
*dc
= DC_GetDCPtr( hdc
);
1029 /* One would think that setting the graphics mode to GM_COMPATIBLE
1030 * would also reset the world transformation matrix to the unity
1031 * matrix. However, in Windows, this is not the case. This doesn't
1032 * make a lot of sense to me, but that's the way it is.
1035 if ((mode
> 0) && (mode
<= GM_LAST
))
1037 ret
= dc
->GraphicsMode
;
1038 dc
->GraphicsMode
= mode
;
1040 GDI_ReleaseObj( hdc
);
1045 /***********************************************************************
1046 * GetArcDirection (GDI32.@)
1048 INT WINAPI
GetArcDirection( HDC hdc
)
1051 DC
* dc
= DC_GetDCPtr( hdc
);
1054 ret
= dc
->ArcDirection
;
1055 GDI_ReleaseObj( hdc
);
1061 /***********************************************************************
1062 * SetArcDirection (GDI32.@)
1064 INT WINAPI
SetArcDirection( HDC hdc
, INT nDirection
)
1067 INT nOldDirection
= 0;
1069 if (nDirection
!=AD_COUNTERCLOCKWISE
&& nDirection
!=AD_CLOCKWISE
)
1071 SetLastError(ERROR_INVALID_PARAMETER
);
1075 if ((dc
= DC_GetDCPtr( hdc
)))
1077 if (dc
->funcs
->pSetArcDirection
)
1079 dc
->funcs
->pSetArcDirection(dc
->physDev
, nDirection
);
1081 nOldDirection
= dc
->ArcDirection
;
1082 dc
->ArcDirection
= nDirection
;
1083 GDI_ReleaseObj( hdc
);
1085 return nOldDirection
;
1089 /***********************************************************************
1090 * GetWorldTransform (GDI32.@)
1092 BOOL WINAPI
GetWorldTransform( HDC hdc
, LPXFORM xform
)
1095 if (!xform
) return FALSE
;
1096 if (!(dc
= DC_GetDCPtr( hdc
))) return FALSE
;
1097 *xform
= dc
->xformWorld2Wnd
;
1098 GDI_ReleaseObj( hdc
);
1103 /***********************************************************************
1104 * GetTransform (GDI32.@)
1106 BOOL WINAPI
GetTransform( HDC hdc
, DWORD unknown
, LPXFORM xform
)
1108 if (unknown
== 0x0203) return GetWorldTransform( hdc
, xform
);
1109 FIXME("stub: don't know what to do for code %lx\n", unknown
);
1114 /***********************************************************************
1115 * SetWorldTransform (GDI32.@)
1117 BOOL WINAPI
SetWorldTransform( HDC hdc
, const XFORM
*xform
)
1120 DC
*dc
= DC_GetDCPtr( hdc
);
1122 if (!dc
) return FALSE
;
1123 if (!xform
) goto done
;
1125 /* Check that graphics mode is GM_ADVANCED */
1126 if (dc
->GraphicsMode
!=GM_ADVANCED
) goto done
;
1128 if (dc
->funcs
->pSetWorldTransform
)
1130 ret
= dc
->funcs
->pSetWorldTransform(dc
->physDev
, xform
);
1131 if (!ret
) goto done
;
1134 dc
->xformWorld2Wnd
= *xform
;
1135 DC_UpdateXforms( dc
);
1138 GDI_ReleaseObj( hdc
);
1143 /****************************************************************************
1144 * ModifyWorldTransform [GDI32.@]
1145 * Modifies the world transformation for a device context.
1148 * hdc [I] Handle to device context
1149 * xform [I] XFORM structure that will be used to modify the world
1151 * iMode [I] Specifies in what way to modify the world transformation
1154 * Resets the world transformation to the identity matrix.
1155 * The parameter xform is ignored.
1157 * Multiplies xform into the world transformation matrix from
1160 * Multiplies xform into the world transformation matrix from
1165 * Failure: FALSE. Use GetLastError() to determine the cause.
1167 BOOL WINAPI
ModifyWorldTransform( HDC hdc
, const XFORM
*xform
,
1171 DC
*dc
= DC_GetDCPtr( hdc
);
1173 /* Check for illegal parameters */
1174 if (!dc
) return FALSE
;
1175 if (!xform
) goto done
;
1177 /* Check that graphics mode is GM_ADVANCED */
1178 if (dc
->GraphicsMode
!=GM_ADVANCED
) goto done
;
1180 if (dc
->funcs
->pModifyWorldTransform
)
1182 ret
= dc
->funcs
->pModifyWorldTransform(dc
->physDev
, xform
, iMode
);
1183 if (!ret
) goto done
;
1189 dc
->xformWorld2Wnd
.eM11
= 1.0f
;
1190 dc
->xformWorld2Wnd
.eM12
= 0.0f
;
1191 dc
->xformWorld2Wnd
.eM21
= 0.0f
;
1192 dc
->xformWorld2Wnd
.eM22
= 1.0f
;
1193 dc
->xformWorld2Wnd
.eDx
= 0.0f
;
1194 dc
->xformWorld2Wnd
.eDy
= 0.0f
;
1196 case MWT_LEFTMULTIPLY
:
1197 CombineTransform( &dc
->xformWorld2Wnd
, xform
,
1198 &dc
->xformWorld2Wnd
);
1200 case MWT_RIGHTMULTIPLY
:
1201 CombineTransform( &dc
->xformWorld2Wnd
, &dc
->xformWorld2Wnd
,
1208 DC_UpdateXforms( dc
);
1211 GDI_ReleaseObj( hdc
);
1216 /****************************************************************************
1217 * CombineTransform [GDI32.@]
1218 * Combines two transformation matrices.
1221 * xformResult [O] Stores the result of combining the two matrices
1222 * xform1 [I] Specifies the first matrix to apply
1223 * xform2 [I] Specifies the second matrix to apply
1226 * The same matrix can be passed in for more than one of the parameters.
1230 * Failure: FALSE. Use GetLastError() to determine the cause.
1232 BOOL WINAPI
CombineTransform( LPXFORM xformResult
, const XFORM
*xform1
,
1233 const XFORM
*xform2
)
1237 /* Check for illegal parameters */
1238 if (!xformResult
|| !xform1
|| !xform2
)
1241 /* Create the result in a temporary XFORM, since xformResult may be
1242 * equal to xform1 or xform2 */
1243 xformTemp
.eM11
= xform1
->eM11
* xform2
->eM11
+
1244 xform1
->eM12
* xform2
->eM21
;
1245 xformTemp
.eM12
= xform1
->eM11
* xform2
->eM12
+
1246 xform1
->eM12
* xform2
->eM22
;
1247 xformTemp
.eM21
= xform1
->eM21
* xform2
->eM11
+
1248 xform1
->eM22
* xform2
->eM21
;
1249 xformTemp
.eM22
= xform1
->eM21
* xform2
->eM12
+
1250 xform1
->eM22
* xform2
->eM22
;
1251 xformTemp
.eDx
= xform1
->eDx
* xform2
->eM11
+
1252 xform1
->eDy
* xform2
->eM21
+
1254 xformTemp
.eDy
= xform1
->eDx
* xform2
->eM12
+
1255 xform1
->eDy
* xform2
->eM22
+
1258 /* Copy the result to xformResult */
1259 *xformResult
= xformTemp
;
1265 /***********************************************************************
1266 * SetDCHook (GDI32.@)
1268 * Note: this doesn't exist in Win32, we add it here because user32 needs it.
1270 BOOL WINAPI
SetDCHook( HDC hdc
, DCHOOKPROC hookProc
, DWORD dwHookData
)
1272 DC
*dc
= GDI_GetObjPtr( hdc
, DC_MAGIC
);
1274 if (!dc
) return FALSE
;
1276 if (!(dc
->flags
& DC_SAVED
))
1278 dc
->dwHookData
= dwHookData
;
1279 dc
->hookThunk
= hookProc
;
1281 GDI_ReleaseObj( hdc
);
1286 /* relay function to call the 16-bit DC hook proc */
1287 static BOOL16 WINAPI
call_dc_hook16( HDC16 hdc16
, WORD code
, DWORD data
, LPARAM lParam
)
1291 FARPROC16 proc
= NULL
;
1292 HDC hdc
= HDC_32( hdc16
);
1293 DC
*dc
= DC_GetDCPtr( hdc
);
1295 if (!dc
) return FALSE
;
1296 proc
= dc
->hookProc
;
1297 GDI_ReleaseObj( hdc
);
1298 if (!proc
) return FALSE
;
1301 args
[3] = HIWORD(data
);
1302 args
[2] = LOWORD(data
);
1303 args
[1] = HIWORD(lParam
);
1304 args
[0] = LOWORD(lParam
);
1305 WOWCallback16Ex( (DWORD
)proc
, WCB16_PASCAL
, sizeof(args
), args
, &ret
);
1309 /***********************************************************************
1310 * SetDCHook (GDI.190)
1312 BOOL16 WINAPI
SetDCHook16( HDC16 hdc16
, FARPROC16 hookProc
, DWORD dwHookData
)
1314 HDC hdc
= HDC_32( hdc16
);
1315 DC
*dc
= DC_GetDCPtr( hdc
);
1316 if (!dc
) return FALSE
;
1318 dc
->hookProc
= hookProc
;
1319 GDI_ReleaseObj( hdc
);
1320 return SetDCHook( hdc
, call_dc_hook16
, dwHookData
);
1324 /***********************************************************************
1325 * GetDCHook (GDI.191)
1327 DWORD WINAPI
GetDCHook16( HDC16 hdc16
, FARPROC16
*phookProc
)
1329 HDC hdc
= HDC_32( hdc16
);
1330 DC
*dc
= DC_GetDCPtr( hdc
);
1334 *phookProc
= dc
->hookProc
;
1335 ret
= dc
->dwHookData
;
1336 GDI_ReleaseObj( hdc
);
1341 /***********************************************************************
1342 * SetHookFlags (GDI.192)
1344 WORD WINAPI
SetHookFlags16(HDC16 hdc16
, WORD flags
)
1346 HDC hdc
= HDC_32( hdc16
);
1347 DC
*dc
= DC_GetDCPtr( hdc
);
1351 WORD wRet
= dc
->flags
& DC_DIRTY
;
1353 /* "Undocumented Windows" info is slightly confusing.
1356 TRACE("hDC %p, flags %04x\n",hdc
,flags
);
1358 if( flags
& DCHF_INVALIDATEVISRGN
)
1359 dc
->flags
|= DC_DIRTY
;
1360 else if( flags
& DCHF_VALIDATEVISRGN
|| !flags
)
1361 dc
->flags
&= ~DC_DIRTY
;
1362 GDI_ReleaseObj( hdc
);
1368 /***********************************************************************
1369 * SetICMMode (GDI32.@)
1371 INT WINAPI
SetICMMode(HDC hdc
, INT iEnableICM
)
1373 /*FIXME Asuming that ICM is always off, and cannot be turned on */
1374 if (iEnableICM
== ICM_OFF
) return ICM_OFF
;
1375 if (iEnableICM
== ICM_ON
) return 0;
1376 if (iEnableICM
== ICM_QUERY
) return ICM_OFF
;
1380 /***********************************************************************
1381 * GetDeviceGammaRamp (GDI32.@)
1383 BOOL WINAPI
GetDeviceGammaRamp(HDC hDC
, LPVOID ptr
)
1386 DC
*dc
= DC_GetDCPtr( hDC
);
1390 if (dc
->funcs
->pGetDeviceGammaRamp
)
1391 ret
= dc
->funcs
->pGetDeviceGammaRamp(dc
->physDev
, ptr
);
1392 GDI_ReleaseObj( hDC
);
1397 /***********************************************************************
1398 * SetDeviceGammaRamp (GDI32.@)
1400 BOOL WINAPI
SetDeviceGammaRamp(HDC hDC
, LPVOID ptr
)
1403 DC
*dc
= DC_GetDCPtr( hDC
);
1407 if (dc
->funcs
->pSetDeviceGammaRamp
)
1408 ret
= dc
->funcs
->pSetDeviceGammaRamp(dc
->physDev
, ptr
);
1409 GDI_ReleaseObj( hDC
);
1414 /***********************************************************************
1415 * GetColorSpace (GDI32.@)
1417 HCOLORSPACE WINAPI
GetColorSpace(HDC hdc
)
1419 /*FIXME Need to to whatever GetColorSpace actually does */
1423 /***********************************************************************
1424 * CreateColorSpaceA (GDI32.@)
1426 HCOLORSPACE WINAPI
CreateColorSpaceA( LPLOGCOLORSPACEA lpLogColorSpace
)
1432 /***********************************************************************
1433 * CreateColorSpaceW (GDI32.@)
1435 HCOLORSPACE WINAPI
CreateColorSpaceW( LPLOGCOLORSPACEW lpLogColorSpace
)
1441 /***********************************************************************
1442 * DeleteColorSpace (GDI32.@)
1444 BOOL WINAPI
DeleteColorSpace( HCOLORSPACE hColorSpace
)
1451 /***********************************************************************
1452 * SetColorSpace (GDI32.@)
1454 HCOLORSPACE WINAPI
SetColorSpace( HDC hDC
, HCOLORSPACE hColorSpace
)
1461 /***********************************************************************
1462 * GetBoundsRect (GDI32.@)
1464 UINT WINAPI
GetBoundsRect(HDC hdc
, LPRECT rect
, UINT flags
)
1467 DC
*dc
= DC_GetDCPtr( hdc
);
1469 if ( !dc
) return 0;
1471 if (rect
) *rect
= dc
->BoundsRect
;
1473 ret
= ((dc
->flags
& DC_BOUNDS_SET
) ? DCB_SET
: DCB_RESET
);
1475 if (flags
& DCB_RESET
)
1477 dc
->BoundsRect
.left
= 0;
1478 dc
->BoundsRect
.top
= 0;
1479 dc
->BoundsRect
.right
= 0;
1480 dc
->BoundsRect
.bottom
= 0;
1481 dc
->flags
&= ~DC_BOUNDS_SET
;
1483 GDI_ReleaseObj( hdc
);
1488 /***********************************************************************
1489 * SetBoundsRect (GDI32.@)
1491 UINT WINAPI
SetBoundsRect(HDC hdc
, const RECT
* rect
, UINT flags
)
1496 if ((flags
& DCB_ENABLE
) && (flags
& DCB_DISABLE
)) return 0;
1497 if (!(dc
= DC_GetDCPtr( hdc
))) return 0;
1499 ret
= ((dc
->flags
& DC_BOUNDS_ENABLE
) ? DCB_ENABLE
: DCB_DISABLE
) |
1500 ((dc
->flags
& DC_BOUNDS_SET
) ? DCB_SET
: DCB_RESET
);
1502 if (flags
& DCB_RESET
)
1504 dc
->BoundsRect
.left
= 0;
1505 dc
->BoundsRect
.top
= 0;
1506 dc
->BoundsRect
.right
= 0;
1507 dc
->BoundsRect
.bottom
= 0;
1508 dc
->flags
&= ~DC_BOUNDS_SET
;
1511 if ((flags
& DCB_ACCUMULATE
) && rect
&& rect
->left
< rect
->right
&& rect
->top
< rect
->bottom
)
1513 if (dc
->flags
& DC_BOUNDS_SET
)
1515 dc
->BoundsRect
.left
= min( dc
->BoundsRect
.left
, rect
->left
);
1516 dc
->BoundsRect
.top
= min( dc
->BoundsRect
.top
, rect
->top
);
1517 dc
->BoundsRect
.right
= max( dc
->BoundsRect
.right
, rect
->right
);
1518 dc
->BoundsRect
.bottom
= max( dc
->BoundsRect
.bottom
, rect
->bottom
);
1522 dc
->BoundsRect
= *rect
;
1523 dc
->flags
|= DC_BOUNDS_SET
;
1527 if (flags
& DCB_ENABLE
) dc
->flags
|= DC_BOUNDS_ENABLE
;
1528 if (flags
& DCB_DISABLE
) dc
->flags
&= ~DC_BOUNDS_ENABLE
;
1530 GDI_ReleaseObj( hdc
);
1535 /***********************************************************************
1536 * GetRelAbs (GDI32.@)
1538 INT WINAPI
GetRelAbs( HDC hdc
, DWORD dwIgnore
)
1541 DC
*dc
= DC_GetDCPtr( hdc
);
1542 if (dc
) ret
= dc
->relAbsMode
;
1543 GDI_ReleaseObj( hdc
);
1550 /***********************************************************************
1551 * GetBkMode (GDI32.@)
1553 INT WINAPI
GetBkMode( HDC hdc
)
1556 DC
* dc
= DC_GetDCPtr( hdc
);
1559 ret
= dc
->backgroundMode
;
1560 GDI_ReleaseObj( hdc
);
1566 /***********************************************************************
1567 * SetBkMode (GDI32.@)
1569 INT WINAPI
SetBkMode( HDC hdc
, INT mode
)
1573 if ((mode
<= 0) || (mode
> BKMODE_LAST
))
1575 SetLastError(ERROR_INVALID_PARAMETER
);
1578 if (!(dc
= DC_GetDCPtr( hdc
))) return 0;
1579 if (dc
->funcs
->pSetBkMode
)
1580 ret
= dc
->funcs
->pSetBkMode( dc
->physDev
, mode
);
1583 ret
= dc
->backgroundMode
;
1584 dc
->backgroundMode
= mode
;
1586 GDI_ReleaseObj( hdc
);
1591 /***********************************************************************
1594 INT WINAPI
GetROP2( HDC hdc
)
1597 DC
* dc
= DC_GetDCPtr( hdc
);
1601 GDI_ReleaseObj( hdc
);
1607 /***********************************************************************
1610 INT WINAPI
SetROP2( HDC hdc
, INT mode
)
1614 if ((mode
< R2_BLACK
) || (mode
> R2_WHITE
))
1616 SetLastError(ERROR_INVALID_PARAMETER
);
1619 if (!(dc
= DC_GetDCPtr( hdc
))) return 0;
1620 if (dc
->funcs
->pSetROP2
)
1621 ret
= dc
->funcs
->pSetROP2( dc
->physDev
, mode
);
1627 GDI_ReleaseObj( hdc
);
1632 /***********************************************************************
1633 * SetRelAbs (GDI32.@)
1635 INT WINAPI
SetRelAbs( HDC hdc
, INT mode
)
1639 if ((mode
!= ABSOLUTE
) && (mode
!= RELATIVE
))
1641 SetLastError(ERROR_INVALID_PARAMETER
);
1644 if (!(dc
= DC_GetDCPtr( hdc
))) return 0;
1645 if (dc
->funcs
->pSetRelAbs
)
1646 ret
= dc
->funcs
->pSetRelAbs( dc
->physDev
, mode
);
1649 ret
= dc
->relAbsMode
;
1650 dc
->relAbsMode
= mode
;
1652 GDI_ReleaseObj( hdc
);
1657 /***********************************************************************
1658 * GetPolyFillMode (GDI32.@)
1660 INT WINAPI
GetPolyFillMode( HDC hdc
)
1663 DC
* dc
= DC_GetDCPtr( hdc
);
1666 ret
= dc
->polyFillMode
;
1667 GDI_ReleaseObj( hdc
);
1673 /***********************************************************************
1674 * SetPolyFillMode (GDI32.@)
1676 INT WINAPI
SetPolyFillMode( HDC hdc
, INT mode
)
1680 if ((mode
<= 0) || (mode
> POLYFILL_LAST
))
1682 SetLastError(ERROR_INVALID_PARAMETER
);
1685 if (!(dc
= DC_GetDCPtr( hdc
))) return 0;
1686 if (dc
->funcs
->pSetPolyFillMode
)
1687 ret
= dc
->funcs
->pSetPolyFillMode( dc
->physDev
, mode
);
1690 ret
= dc
->polyFillMode
;
1691 dc
->polyFillMode
= mode
;
1693 GDI_ReleaseObj( hdc
);
1698 /***********************************************************************
1699 * GetStretchBltMode (GDI32.@)
1701 INT WINAPI
GetStretchBltMode( HDC hdc
)
1704 DC
* dc
= DC_GetDCPtr( hdc
);
1707 ret
= dc
->stretchBltMode
;
1708 GDI_ReleaseObj( hdc
);
1714 /***********************************************************************
1715 * SetStretchBltMode (GDI32.@)
1717 INT WINAPI
SetStretchBltMode( HDC hdc
, INT mode
)
1721 if ((mode
<= 0) || (mode
> MAXSTRETCHBLTMODE
))
1723 SetLastError(ERROR_INVALID_PARAMETER
);
1726 if (!(dc
= DC_GetDCPtr( hdc
))) return 0;
1727 if (dc
->funcs
->pSetStretchBltMode
)
1728 ret
= dc
->funcs
->pSetStretchBltMode( dc
->physDev
, mode
);
1731 ret
= dc
->stretchBltMode
;
1732 dc
->stretchBltMode
= mode
;
1734 GDI_ReleaseObj( hdc
);
1739 /***********************************************************************
1740 * GetMapMode (GDI32.@)
1742 INT WINAPI
GetMapMode( HDC hdc
)
1745 DC
* dc
= DC_GetDCPtr( hdc
);
1749 GDI_ReleaseObj( hdc
);
1755 /***********************************************************************
1756 * GetBrushOrgEx (GDI32.@)
1758 BOOL WINAPI
GetBrushOrgEx( HDC hdc
, LPPOINT pt
)
1760 DC
* dc
= DC_GetDCPtr( hdc
);
1761 if (!dc
) return FALSE
;
1762 pt
->x
= dc
->brushOrgX
;
1763 pt
->y
= dc
->brushOrgY
;
1764 GDI_ReleaseObj( hdc
);
1769 /***********************************************************************
1770 * GetCurrentPositionEx (GDI32.@)
1772 BOOL WINAPI
GetCurrentPositionEx( HDC hdc
, LPPOINT pt
)
1774 DC
* dc
= DC_GetDCPtr( hdc
);
1775 if (!dc
) return FALSE
;
1776 pt
->x
= dc
->CursPosX
;
1777 pt
->y
= dc
->CursPosY
;
1778 GDI_ReleaseObj( hdc
);
1783 /***********************************************************************
1784 * GetViewportExtEx (GDI32.@)
1786 BOOL WINAPI
GetViewportExtEx( HDC hdc
, LPSIZE size
)
1788 DC
* dc
= DC_GetDCPtr( hdc
);
1789 if (!dc
) return FALSE
;
1790 size
->cx
= dc
->vportExtX
;
1791 size
->cy
= dc
->vportExtY
;
1792 GDI_ReleaseObj( hdc
);
1797 /***********************************************************************
1798 * GetViewportOrgEx (GDI32.@)
1800 BOOL WINAPI
GetViewportOrgEx( HDC hdc
, LPPOINT pt
)
1802 DC
* dc
= DC_GetDCPtr( hdc
);
1803 if (!dc
) return FALSE
;
1804 pt
->x
= dc
->vportOrgX
;
1805 pt
->y
= dc
->vportOrgY
;
1806 GDI_ReleaseObj( hdc
);
1811 /***********************************************************************
1812 * GetWindowExtEx (GDI32.@)
1814 BOOL WINAPI
GetWindowExtEx( HDC hdc
, LPSIZE size
)
1816 DC
* dc
= DC_GetDCPtr( hdc
);
1817 if (!dc
) return FALSE
;
1818 size
->cx
= dc
->wndExtX
;
1819 size
->cy
= dc
->wndExtY
;
1820 GDI_ReleaseObj( hdc
);
1825 /***********************************************************************
1826 * GetWindowOrgEx (GDI32.@)
1828 BOOL WINAPI
GetWindowOrgEx( HDC hdc
, LPPOINT pt
)
1830 DC
* dc
= DC_GetDCPtr( hdc
);
1831 if (!dc
) return FALSE
;
1832 pt
->x
= dc
->wndOrgX
;
1833 pt
->y
= dc
->wndOrgY
;
1834 GDI_ReleaseObj( hdc
);
1839 /***********************************************************************
1840 * InquireVisRgn (GDI.131)
1842 HRGN16 WINAPI
InquireVisRgn16( HDC16 hdc
)
1845 DC
* dc
= DC_GetDCPtr( HDC_32(hdc
) );
1848 ret
= HRGN_16(dc
->hVisRgn
);
1849 GDI_ReleaseObj( HDC_32(hdc
) );
1855 /***********************************************************************
1856 * GetClipRgn (GDI.173)
1858 HRGN16 WINAPI
GetClipRgn16( HDC16 hdc
)
1861 DC
* dc
= DC_GetDCPtr( HDC_32(hdc
) );
1864 ret
= HRGN_16(dc
->hClipRgn
);
1865 GDI_ReleaseObj( HDC_32(hdc
) );
1871 /***********************************************************************
1872 * GetLayout (GDI32.@)
1874 * Gets left->right or right->left text layout flags of a dc.
1875 * win98 just returns 0 and sets ERROR_CALL_NOT_IMPLEMENTED so we do the same
1878 DWORD WINAPI
GetLayout(HDC hdc
)
1880 FIXME("(%p): stub\n", hdc
);
1881 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
1885 /***********************************************************************
1886 * SetLayout (GDI32.@)
1888 * Sets left->right or right->left text layout flags of a dc.
1889 * win98 just returns 0 and sets ERROR_CALL_NOT_IMPLEMENTED so we do the same
1892 DWORD WINAPI
SetLayout(HDC hdc
, DWORD layout
)
1894 FIXME("(%p,%08lx): stub\n", hdc
, layout
);
1895 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
1899 /***********************************************************************
1900 * GetDCBrushColor (GDI32.@)
1902 * Retrieves the current brush color for the specified device
1906 COLORREF WINAPI
GetDCBrushColor(HDC hdc
)
1909 COLORREF dcBrushColor
= CLR_INVALID
;
1911 TRACE("hdc(%p)\n", hdc
);
1913 dc
= DC_GetDCPtr( hdc
);
1916 dcBrushColor
= dc
->dcBrushColor
;
1917 GDI_ReleaseObj( hdc
);
1920 return dcBrushColor
;
1923 /***********************************************************************
1924 * SetDCBrushColor (GDI32.@)
1926 * Sets the current device context (DC) brush color to the specified
1927 * color value. If the device cannot represent the specified color
1928 * value, the color is set to the nearest physical color.
1931 COLORREF WINAPI
SetDCBrushColor(HDC hdc
, COLORREF crColor
)
1934 COLORREF oldClr
= CLR_INVALID
;
1936 TRACE("hdc(%p) crColor(%08lx)\n", hdc
, crColor
);
1938 dc
= DC_GetDCPtr( hdc
);
1941 if (dc
->funcs
->pSetDCBrushColor
)
1942 crColor
= dc
->funcs
->pSetDCBrushColor( dc
->physDev
, crColor
);
1943 else if (dc
->hBrush
== GetStockObject( DC_BRUSH
))
1945 /* If DC_BRUSH is selected, update driver pen color */
1946 HBRUSH hBrush
= CreateSolidBrush( crColor
);
1947 dc
->funcs
->pSelectBrush( dc
->physDev
, hBrush
);
1948 DeleteObject( hBrush
);
1951 if (crColor
!= CLR_INVALID
)
1953 oldClr
= dc
->dcBrushColor
;
1954 dc
->dcBrushColor
= crColor
;
1957 GDI_ReleaseObj( hdc
);
1963 /***********************************************************************
1964 * GetDCPenColor (GDI32.@)
1966 * Retrieves the current pen color for the specified device
1970 COLORREF WINAPI
GetDCPenColor(HDC hdc
)
1973 COLORREF dcPenColor
= CLR_INVALID
;
1975 TRACE("hdc(%p)\n", hdc
);
1977 dc
= DC_GetDCPtr( hdc
);
1980 dcPenColor
= dc
->dcPenColor
;
1981 GDI_ReleaseObj( hdc
);
1987 /***********************************************************************
1988 * SetDCPenColor (GDI32.@)
1990 * Sets the current device context (DC) pen color to the specified
1991 * color value. If the device cannot represent the specified color
1992 * value, the color is set to the nearest physical color.
1995 COLORREF WINAPI
SetDCPenColor(HDC hdc
, COLORREF crColor
)
1998 COLORREF oldClr
= CLR_INVALID
;
2000 TRACE("hdc(%p) crColor(%08lx)\n", hdc
, crColor
);
2002 dc
= DC_GetDCPtr( hdc
);
2005 if (dc
->funcs
->pSetDCPenColor
)
2006 crColor
= dc
->funcs
->pSetDCPenColor( dc
->physDev
, crColor
);
2007 else if (dc
->hPen
== GetStockObject( DC_PEN
))
2009 /* If DC_PEN is selected, update the driver pen color */
2010 LOGPEN logpen
= { PS_SOLID
, { 0, 0 }, crColor
};
2011 HPEN hPen
= CreatePenIndirect( &logpen
);
2012 dc
->funcs
->pSelectPen( dc
->physDev
, hPen
);
2013 DeleteObject( hPen
);
2016 if (crColor
!= CLR_INVALID
)
2018 oldClr
= dc
->dcPenColor
;
2019 dc
->dcPenColor
= crColor
;
2022 GDI_ReleaseObj( hdc
);
2028 /***********************************************************************
2029 * SetVirtualResolution (GDI32.@)
2031 * Undocumented on msdn. Called when PowerPoint XP saves a file.
2033 DWORD WINAPI
SetVirtualResolution(HDC hdc
, DWORD dw2
, DWORD dw3
, DWORD dw4
, DWORD dw5
)
2035 FIXME("(%p %08lx %08lx %08lx %08lx): stub!\n", hdc
, dw2
, dw3
, dw4
, dw5
);
2039 /*******************************************************************
2040 * GetMiterLimit [GDI32.@]
2044 BOOL WINAPI
GetMiterLimit(HDC hdc
, PFLOAT peLimit
)
2049 TRACE("(%p,%p)\n", hdc
, peLimit
);
2051 dc
= DC_GetDCPtr( hdc
);
2055 *peLimit
= dc
->miterLimit
;
2057 GDI_ReleaseObj( hdc
);
2063 /*******************************************************************
2064 * SetMiterLimit [GDI32.@]
2068 BOOL WINAPI
SetMiterLimit(HDC hdc
, FLOAT eNewLimit
, PFLOAT peOldLimit
)
2073 TRACE("(%p,%f,%p)\n", hdc
, eNewLimit
, peOldLimit
);
2075 dc
= DC_GetDCPtr( hdc
);
2079 *peOldLimit
= dc
->miterLimit
;
2080 dc
->miterLimit
= eNewLimit
;
2081 GDI_ReleaseObj( hdc
);