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
27 #include "wine/debug.h"
32 #include "wine/winuser16.h"
34 WINE_DEFAULT_DEBUG_CHANNEL(dc
);
36 /* ### start build ### */
37 extern WORD CALLBACK
GDI_CallTo16_word_wwll(FARPROC16
,WORD
,WORD
,LONG
,LONG
);
38 /* ### stop build ### */
40 /***********************************************************************
43 DC
*DC_AllocDC( const DC_FUNCTIONS
*funcs
)
48 if (!(dc
= GDI_AllocObject( sizeof(*dc
), DC_MAGIC
, &hdc
))) return NULL
;
69 dc
->hPen
= GetStockObject( BLACK_PEN
);
70 dc
->hBrush
= GetStockObject( WHITE_BRUSH
);
71 dc
->hFont
= GetStockObject( SYSTEM_FONT
);
74 dc
->hPalette
= GetStockObject( DEFAULT_PALETTE
);
76 dc
->ROPmode
= R2_COPYPEN
;
77 dc
->polyFillMode
= ALTERNATE
;
78 dc
->stretchBltMode
= BLACKONWHITE
;
79 dc
->relAbsMode
= ABSOLUTE
;
80 dc
->backgroundMode
= OPAQUE
;
81 dc
->backgroundColor
= RGB( 255, 255, 255 );
82 dc
->textColor
= RGB( 0, 0, 0 );
85 dc
->textAlign
= TA_LEFT
| TA_TOP
| TA_NOUPDATECP
;
87 dc
->breakTotalExtra
= 0;
91 dc
->totalExtent
.left
= 0;
92 dc
->totalExtent
.top
= 0;
93 dc
->totalExtent
.right
= 0;
94 dc
->totalExtent
.bottom
= 0;
96 dc
->MapMode
= MM_TEXT
;
97 dc
->GraphicsMode
= GM_COMPATIBLE
;
100 dc
->pAbortProc
= NULL
;
103 dc
->ArcDirection
= AD_COUNTERCLOCKWISE
;
104 dc
->xformWorld2Wnd
.eM11
= 1.0f
;
105 dc
->xformWorld2Wnd
.eM12
= 0.0f
;
106 dc
->xformWorld2Wnd
.eM21
= 0.0f
;
107 dc
->xformWorld2Wnd
.eM22
= 1.0f
;
108 dc
->xformWorld2Wnd
.eDx
= 0.0f
;
109 dc
->xformWorld2Wnd
.eDy
= 0.0f
;
110 dc
->xformWorld2Vport
= dc
->xformWorld2Wnd
;
111 dc
->xformVport2World
= dc
->xformWorld2Wnd
;
112 dc
->vport2WorldValid
= TRUE
;
113 PATH_InitGdiPath(&dc
->path
);
119 /***********************************************************************
122 DC
*DC_GetDCPtr( HDC hdc
)
124 GDIOBJHDR
*ptr
= GDI_GetObjPtr( hdc
, MAGIC_DONTCARE
);
125 if (!ptr
) return NULL
;
126 if ((GDIMAGIC(ptr
->wMagic
) == DC_MAGIC
) ||
127 (GDIMAGIC(ptr
->wMagic
) == METAFILE_DC_MAGIC
) ||
128 (GDIMAGIC(ptr
->wMagic
) == ENHMETAFILE_DC_MAGIC
))
130 GDI_ReleaseObj( hdc
);
131 SetLastError( ERROR_INVALID_HANDLE
);
135 /***********************************************************************
138 * Retrieve a DC ptr while making sure the visRgn is updated.
139 * This function may call up to USER so the GDI lock should _not_
140 * be held when calling it.
142 DC
*DC_GetDCUpdate( HDC hdc
)
144 DC
*dc
= DC_GetDCPtr( hdc
);
145 if (!dc
) return NULL
;
146 while (dc
->flags
& DC_DIRTY
)
148 dc
->flags
&= ~DC_DIRTY
;
149 if (!(dc
->flags
& (DC_SAVED
| DC_MEMORY
)))
151 DCHOOKPROC proc
= dc
->hookThunk
;
154 DWORD data
= dc
->dwHookData
;
155 GDI_ReleaseObj( hdc
);
156 proc( hdc
, DCHC_INVALIDVISRGN
, data
, 0 );
157 if (!(dc
= DC_GetDCPtr( hdc
))) break;
158 /* otherwise restart the loop in case it became dirty again in the meantime */
165 /***********************************************************************
168 * Setup device-specific DC values for a newly created DC.
170 void DC_InitDC( DC
* dc
)
172 RealizeDefaultPalette16( dc
->hSelf
);
173 SetTextColor( dc
->hSelf
, dc
->textColor
);
174 SetBkColor( dc
->hSelf
, dc
->backgroundColor
);
175 SelectObject( dc
->hSelf
, dc
->hPen
);
176 SelectObject( dc
->hSelf
, dc
->hBrush
);
177 SelectObject( dc
->hSelf
, dc
->hFont
);
178 CLIPPING_UpdateGCRegion( dc
);
182 /***********************************************************************
185 * Computes the inverse of the transformation xformSrc and stores it to
186 * xformDest. Returns TRUE if successful or FALSE if the xformSrc matrix
189 static BOOL
DC_InvertXform( const XFORM
*xformSrc
, XFORM
*xformDest
)
193 determinant
= xformSrc
->eM11
*xformSrc
->eM22
-
194 xformSrc
->eM12
*xformSrc
->eM21
;
195 if (determinant
> -1e-12 && determinant
< 1e-12)
198 xformDest
->eM11
= xformSrc
->eM22
/ determinant
;
199 xformDest
->eM12
= -xformSrc
->eM12
/ determinant
;
200 xformDest
->eM21
= -xformSrc
->eM21
/ determinant
;
201 xformDest
->eM22
= xformSrc
->eM11
/ determinant
;
202 xformDest
->eDx
= -xformSrc
->eDx
* xformDest
->eM11
-
203 xformSrc
->eDy
* xformDest
->eM21
;
204 xformDest
->eDy
= -xformSrc
->eDx
* xformDest
->eM12
-
205 xformSrc
->eDy
* xformDest
->eM22
;
211 /***********************************************************************
214 * Updates the xformWorld2Vport, xformVport2World and vport2WorldValid
215 * fields of the specified DC by creating a transformation that
216 * represents the current mapping mode and combining it with the DC's
217 * world transform. This function should be called whenever the
218 * parameters associated with the mapping mode (window and viewport
219 * extents and origins) or the world transform change.
221 void DC_UpdateXforms( DC
*dc
)
223 XFORM xformWnd2Vport
;
224 FLOAT scaleX
, scaleY
;
226 /* Construct a transformation to do the window-to-viewport conversion */
227 scaleX
= (FLOAT
)dc
->vportExtX
/ (FLOAT
)dc
->wndExtX
;
228 scaleY
= (FLOAT
)dc
->vportExtY
/ (FLOAT
)dc
->wndExtY
;
229 xformWnd2Vport
.eM11
= scaleX
;
230 xformWnd2Vport
.eM12
= 0.0;
231 xformWnd2Vport
.eM21
= 0.0;
232 xformWnd2Vport
.eM22
= scaleY
;
233 xformWnd2Vport
.eDx
= (FLOAT
)dc
->vportOrgX
-
234 scaleX
* (FLOAT
)dc
->wndOrgX
;
235 xformWnd2Vport
.eDy
= (FLOAT
)dc
->vportOrgY
-
236 scaleY
* (FLOAT
)dc
->wndOrgY
;
238 /* Combine with the world transformation */
239 CombineTransform( &dc
->xformWorld2Vport
, &dc
->xformWorld2Wnd
,
242 /* Create inverse of world-to-viewport transformation */
243 dc
->vport2WorldValid
= DC_InvertXform( &dc
->xformWorld2Vport
,
244 &dc
->xformVport2World
);
248 /***********************************************************************
249 * GetDCState (GDI.179)
251 HDC16 WINAPI
GetDCState16( HDC16 hdc
)
256 if (!(dc
= DC_GetDCPtr( hdc
))) return 0;
257 if (!(newdc
= GDI_AllocObject( sizeof(DC
), DC_MAGIC
, &handle
)))
259 GDI_ReleaseObj( hdc
);
262 TRACE("(%04x): returning %04x\n", hdc
, handle
);
264 newdc
->flags
= dc
->flags
| DC_SAVED
;
265 newdc
->hPen
= dc
->hPen
;
266 newdc
->hBrush
= dc
->hBrush
;
267 newdc
->hFont
= dc
->hFont
;
268 newdc
->hBitmap
= dc
->hBitmap
;
269 newdc
->hDevice
= dc
->hDevice
;
270 newdc
->hPalette
= dc
->hPalette
;
271 newdc
->totalExtent
= dc
->totalExtent
;
272 newdc
->bitsPerPixel
= dc
->bitsPerPixel
;
273 newdc
->ROPmode
= dc
->ROPmode
;
274 newdc
->polyFillMode
= dc
->polyFillMode
;
275 newdc
->stretchBltMode
= dc
->stretchBltMode
;
276 newdc
->relAbsMode
= dc
->relAbsMode
;
277 newdc
->backgroundMode
= dc
->backgroundMode
;
278 newdc
->backgroundColor
= dc
->backgroundColor
;
279 newdc
->textColor
= dc
->textColor
;
280 newdc
->brushOrgX
= dc
->brushOrgX
;
281 newdc
->brushOrgY
= dc
->brushOrgY
;
282 newdc
->textAlign
= dc
->textAlign
;
283 newdc
->charExtra
= dc
->charExtra
;
284 newdc
->breakTotalExtra
= dc
->breakTotalExtra
;
285 newdc
->breakCount
= dc
->breakCount
;
286 newdc
->breakExtra
= dc
->breakExtra
;
287 newdc
->breakRem
= dc
->breakRem
;
288 newdc
->MapMode
= dc
->MapMode
;
289 newdc
->GraphicsMode
= dc
->GraphicsMode
;
291 /* Apparently, the DC origin is not changed by [GS]etDCState */
292 newdc
->DCOrgX
= dc
->DCOrgX
;
293 newdc
->DCOrgY
= dc
->DCOrgY
;
295 newdc
->CursPosX
= dc
->CursPosX
;
296 newdc
->CursPosY
= dc
->CursPosY
;
297 newdc
->ArcDirection
= dc
->ArcDirection
;
298 newdc
->xformWorld2Wnd
= dc
->xformWorld2Wnd
;
299 newdc
->xformWorld2Vport
= dc
->xformWorld2Vport
;
300 newdc
->xformVport2World
= dc
->xformVport2World
;
301 newdc
->vport2WorldValid
= dc
->vport2WorldValid
;
302 newdc
->wndOrgX
= dc
->wndOrgX
;
303 newdc
->wndOrgY
= dc
->wndOrgY
;
304 newdc
->wndExtX
= dc
->wndExtX
;
305 newdc
->wndExtY
= dc
->wndExtY
;
306 newdc
->vportOrgX
= dc
->vportOrgX
;
307 newdc
->vportOrgY
= dc
->vportOrgY
;
308 newdc
->vportExtX
= dc
->vportExtX
;
309 newdc
->vportExtY
= dc
->vportExtY
;
311 newdc
->hSelf
= (HDC
)handle
;
312 newdc
->saveLevel
= 0;
314 PATH_InitGdiPath( &newdc
->path
);
316 newdc
->pAbortProc
= NULL
;
317 newdc
->hookThunk
= NULL
;
320 /* Get/SetDCState() don't change hVisRgn field ("Undoc. Windows" p.559). */
322 newdc
->hGCClipRgn
= newdc
->hVisRgn
= 0;
325 newdc
->hClipRgn
= CreateRectRgn( 0, 0, 0, 0 );
326 CombineRgn( newdc
->hClipRgn
, dc
->hClipRgn
, 0, RGN_COPY
);
332 newdc
->gdiFont
= dc
->gdiFont
;
336 GDI_ReleaseObj( handle
);
337 GDI_ReleaseObj( hdc
);
342 /***********************************************************************
343 * SetDCState (GDI.180)
345 void WINAPI
SetDCState16( HDC16 hdc
, HDC16 hdcs
)
349 if (!(dc
= DC_GetDCUpdate( hdc
))) return;
350 if (!(dcs
= GDI_GetObjPtr( hdcs
, DC_MAGIC
)))
352 GDI_ReleaseObj( hdc
);
355 if (!dcs
->flags
& DC_SAVED
)
357 GDI_ReleaseObj( hdc
);
358 GDI_ReleaseObj( hdcs
);
361 TRACE("%04x %04x\n", hdc
, hdcs
);
363 dc
->flags
= dcs
->flags
& ~DC_SAVED
;
364 dc
->hDevice
= dcs
->hDevice
;
365 dc
->totalExtent
= dcs
->totalExtent
;
366 dc
->ROPmode
= dcs
->ROPmode
;
367 dc
->polyFillMode
= dcs
->polyFillMode
;
368 dc
->stretchBltMode
= dcs
->stretchBltMode
;
369 dc
->relAbsMode
= dcs
->relAbsMode
;
370 dc
->backgroundMode
= dcs
->backgroundMode
;
371 dc
->backgroundColor
= dcs
->backgroundColor
;
372 dc
->textColor
= dcs
->textColor
;
373 dc
->brushOrgX
= dcs
->brushOrgX
;
374 dc
->brushOrgY
= dcs
->brushOrgY
;
375 dc
->textAlign
= dcs
->textAlign
;
376 dc
->charExtra
= dcs
->charExtra
;
377 dc
->breakTotalExtra
= dcs
->breakTotalExtra
;
378 dc
->breakCount
= dcs
->breakCount
;
379 dc
->breakExtra
= dcs
->breakExtra
;
380 dc
->breakRem
= dcs
->breakRem
;
381 dc
->MapMode
= dcs
->MapMode
;
382 dc
->GraphicsMode
= dcs
->GraphicsMode
;
384 /* Apparently, the DC origin is not changed by [GS]etDCState */
385 dc
->DCOrgX
= dcs
->DCOrgX
;
386 dc
->DCOrgY
= dcs
->DCOrgY
;
388 dc
->CursPosX
= dcs
->CursPosX
;
389 dc
->CursPosY
= dcs
->CursPosY
;
390 dc
->ArcDirection
= dcs
->ArcDirection
;
391 dc
->xformWorld2Wnd
= dcs
->xformWorld2Wnd
;
392 dc
->xformWorld2Vport
= dcs
->xformWorld2Vport
;
393 dc
->xformVport2World
= dcs
->xformVport2World
;
394 dc
->vport2WorldValid
= dcs
->vport2WorldValid
;
396 dc
->wndOrgX
= dcs
->wndOrgX
;
397 dc
->wndOrgY
= dcs
->wndOrgY
;
398 dc
->wndExtX
= dcs
->wndExtX
;
399 dc
->wndExtY
= dcs
->wndExtY
;
400 dc
->vportOrgX
= dcs
->vportOrgX
;
401 dc
->vportOrgY
= dcs
->vportOrgY
;
402 dc
->vportExtX
= dcs
->vportExtX
;
403 dc
->vportExtY
= dcs
->vportExtY
;
405 if (!(dc
->flags
& DC_MEMORY
)) dc
->bitsPerPixel
= dcs
->bitsPerPixel
;
409 if (!dc
->hClipRgn
) dc
->hClipRgn
= CreateRectRgn( 0, 0, 0, 0 );
410 CombineRgn( dc
->hClipRgn
, dcs
->hClipRgn
, 0, RGN_COPY
);
414 if (dc
->hClipRgn
) DeleteObject( dc
->hClipRgn
);
417 CLIPPING_UpdateGCRegion( dc
);
419 SelectObject( hdc
, dcs
->hBitmap
);
420 SelectObject( hdc
, dcs
->hBrush
);
421 SelectObject( hdc
, dcs
->hFont
);
422 SelectObject( hdc
, dcs
->hPen
);
423 SetBkColor( hdc
, dcs
->backgroundColor
);
424 SetTextColor( hdc
, dcs
->textColor
);
425 GDISelectPalette16( hdc
, dcs
->hPalette
, FALSE
);
426 GDI_ReleaseObj( hdcs
);
427 GDI_ReleaseObj( hdc
);
431 /***********************************************************************
434 INT16 WINAPI
SaveDC16( HDC16 hdc
)
436 return (INT16
)SaveDC( hdc
);
440 /***********************************************************************
443 INT WINAPI
SaveDC( HDC hdc
)
449 dc
= DC_GetDCPtr( hdc
);
452 if(dc
->funcs
->pSaveDC
)
454 ret
= dc
->funcs
->pSaveDC( dc
->physDev
);
455 GDI_ReleaseObj( hdc
);
459 if (!(hdcs
= GetDCState16( hdc
)))
461 GDI_ReleaseObj( hdc
);
464 dcs
= GDI_GetObjPtr( hdcs
, DC_MAGIC
);
466 /* Copy path. The reason why path saving / restoring is in SaveDC/
467 * RestoreDC and not in GetDCState/SetDCState is that the ...DCState
468 * functions are only in Win16 (which doesn't have paths) and that
469 * SetDCState doesn't allow us to signal an error (which can happen
470 * when copying paths).
472 if (!PATH_AssignGdiPath( &dcs
->path
, &dc
->path
))
474 GDI_ReleaseObj( hdc
);
475 GDI_ReleaseObj( hdcs
);
480 dcs
->header
.hNext
= dc
->header
.hNext
;
481 dc
->header
.hNext
= hdcs
;
482 TRACE("(%04x): returning %d\n", hdc
, dc
->saveLevel
+1 );
483 ret
= ++dc
->saveLevel
;
484 GDI_ReleaseObj( hdcs
);
485 GDI_ReleaseObj( hdc
);
490 /***********************************************************************
493 BOOL16 WINAPI
RestoreDC16( HDC16 hdc
, INT16 level
)
495 return RestoreDC( hdc
, level
);
499 /***********************************************************************
500 * RestoreDC (GDI32.@)
502 BOOL WINAPI
RestoreDC( HDC hdc
, INT level
)
507 TRACE("%04x %d\n", hdc
, level
);
508 dc
= DC_GetDCUpdate( hdc
);
509 if(!dc
) return FALSE
;
510 if(dc
->funcs
->pRestoreDC
)
512 success
= dc
->funcs
->pRestoreDC( dc
->physDev
, level
);
513 GDI_ReleaseObj( hdc
);
517 if (level
== -1) level
= dc
->saveLevel
;
519 /* This pair of checks disagrees with MSDN "Platform SDK:
520 Windows GDI" July 2000 which says all negative values
521 for level will be interpreted as an instance relative
522 to the current state. Restricting it to just -1 does
524 || (level
> dc
->saveLevel
))
526 GDI_ReleaseObj( hdc
);
531 while (dc
->saveLevel
>= level
)
533 HDC16 hdcs
= dc
->header
.hNext
;
534 if (!(dcs
= GDI_GetObjPtr( hdcs
, DC_MAGIC
)))
536 GDI_ReleaseObj( hdc
);
539 dc
->header
.hNext
= dcs
->header
.hNext
;
540 if (--dc
->saveLevel
< level
)
542 SetDCState16( hdc
, hdcs
);
543 if (!PATH_AssignGdiPath( &dc
->path
, &dcs
->path
))
544 /* FIXME: This might not be quite right, since we're
545 * returning FALSE but still destroying the saved DC state */
548 GDI_ReleaseObj( hdcs
);
549 GDI_ReleaseObj( hdc
);
551 if (!(dc
= DC_GetDCPtr( hdc
))) return FALSE
;
553 GDI_ReleaseObj( hdc
);
558 /***********************************************************************
561 HDC16 WINAPI
CreateDC16( LPCSTR driver
, LPCSTR device
, LPCSTR output
,
562 const DEVMODEA
*initData
)
564 return CreateDCA( driver
, device
, output
, initData
);
567 /***********************************************************************
568 * CreateDCA (GDI32.@)
570 HDC WINAPI
CreateDCA( LPCSTR driver
, LPCSTR device
, LPCSTR output
,
571 const DEVMODEA
*initData
)
575 const DC_FUNCTIONS
*funcs
;
580 if (!device
|| !DRIVER_GetDriverName( device
, buf
, sizeof(buf
) ))
583 if (!(funcs
= DRIVER_load_driver( buf
)))
585 ERR( "no driver found for %s\n", buf
);
588 if (!(dc
= DC_AllocDC( funcs
)))
590 DRIVER_release_driver( funcs
);
596 TRACE("(driver=%s, device=%s, output=%s): returning %04x\n",
597 debugstr_a(driver
), debugstr_a(device
), debugstr_a(output
), dc
->hSelf
);
599 if (dc
->funcs
->pCreateDC
&&
600 !dc
->funcs
->pCreateDC( dc
, buf
, device
, output
, initData
))
602 WARN("creation aborted by device\n" );
603 GDI_FreeObject( dc
->hSelf
, dc
);
604 DRIVER_release_driver( funcs
);
608 dc
->totalExtent
.left
= 0;
609 dc
->totalExtent
.top
= 0;
610 dc
->totalExtent
.right
= GetDeviceCaps( dc
->hSelf
, HORZRES
);
611 dc
->totalExtent
.bottom
= GetDeviceCaps( dc
->hSelf
, VERTRES
);
612 dc
->hVisRgn
= CreateRectRgnIndirect( &dc
->totalExtent
);
616 GDI_ReleaseObj( hdc
);
621 /***********************************************************************
622 * CreateDCW (GDI32.@)
624 HDC WINAPI
CreateDCW( LPCWSTR driver
, LPCWSTR device
, LPCWSTR output
,
625 const DEVMODEW
*initData
)
627 LPSTR driverA
= HEAP_strdupWtoA( GetProcessHeap(), 0, driver
);
628 LPSTR deviceA
= HEAP_strdupWtoA( GetProcessHeap(), 0, device
);
629 LPSTR outputA
= HEAP_strdupWtoA( GetProcessHeap(), 0, output
);
630 HDC res
= CreateDCA( driverA
, deviceA
, outputA
,
631 (const DEVMODEA
*)initData
/*FIXME*/ );
632 HeapFree( GetProcessHeap(), 0, driverA
);
633 HeapFree( GetProcessHeap(), 0, deviceA
);
634 HeapFree( GetProcessHeap(), 0, outputA
);
639 /***********************************************************************
642 HDC16 WINAPI
CreateIC16( LPCSTR driver
, LPCSTR device
, LPCSTR output
,
643 const DEVMODEA
* initData
)
645 /* Nothing special yet for ICs */
646 return CreateDC16( driver
, device
, output
, initData
);
650 /***********************************************************************
651 * CreateICA (GDI32.@)
653 HDC WINAPI
CreateICA( LPCSTR driver
, LPCSTR device
, LPCSTR output
,
654 const DEVMODEA
* initData
)
656 /* Nothing special yet for ICs */
657 return CreateDCA( driver
, device
, output
, initData
);
661 /***********************************************************************
662 * CreateICW (GDI32.@)
664 HDC WINAPI
CreateICW( LPCWSTR driver
, LPCWSTR device
, LPCWSTR output
,
665 const DEVMODEW
* initData
)
667 /* Nothing special yet for ICs */
668 return CreateDCW( driver
, device
, output
, initData
);
672 /***********************************************************************
673 * CreateCompatibleDC (GDI.52)
675 HDC16 WINAPI
CreateCompatibleDC16( HDC16 hdc
)
677 return (HDC16
)CreateCompatibleDC( hdc
);
681 /***********************************************************************
682 * CreateCompatibleDC (GDI32.@)
684 HDC WINAPI
CreateCompatibleDC( HDC hdc
)
687 const DC_FUNCTIONS
*funcs
;
691 if ((origDC
= GDI_GetObjPtr( hdc
, DC_MAGIC
)))
693 funcs
= origDC
->funcs
;
694 GDI_ReleaseObj( hdc
); /* can't hold the lock while loading the driver */
695 funcs
= DRIVER_get_driver( funcs
);
697 else funcs
= DRIVER_load_driver( "DISPLAY" );
699 if (!funcs
) return 0;
701 if (!(dc
= DC_AllocDC( funcs
)))
703 DRIVER_release_driver( funcs
);
707 TRACE("(%04x): returning %04x\n",
710 dc
->flags
= DC_MEMORY
;
711 dc
->bitsPerPixel
= 1;
712 dc
->hBitmap
= GetStockObject( DEFAULT_BITMAP
);
714 /* Copy the driver-specific physical device info into
715 * the new DC. The driver may use this read-only info
716 * while creating the compatible DC below. */
717 if ((origDC
= GDI_GetObjPtr( hdc
, DC_MAGIC
))) dc
->physDev
= origDC
->physDev
;
719 if (dc
->funcs
->pCreateDC
&&
720 !dc
->funcs
->pCreateDC( dc
, NULL
, NULL
, NULL
, NULL
))
722 WARN("creation aborted by device\n");
723 GDI_FreeObject( dc
->hSelf
, dc
);
724 if (origDC
) GDI_ReleaseObj( hdc
);
725 DRIVER_release_driver( funcs
);
729 dc
->totalExtent
.left
= 0;
730 dc
->totalExtent
.top
= 0;
731 dc
->totalExtent
.right
= 1; /* default bitmap is 1x1 */
732 dc
->totalExtent
.bottom
= 1;
733 dc
->hVisRgn
= CreateRectRgnIndirect( &dc
->totalExtent
);
736 GDI_ReleaseObj( dc
->hSelf
);
737 if (origDC
) GDI_ReleaseObj( hdc
);
742 /***********************************************************************
745 BOOL16 WINAPI
DeleteDC16( HDC16 hdc
)
747 return DeleteDC( hdc
);
751 /***********************************************************************
754 BOOL WINAPI
DeleteDC( HDC hdc
)
756 const DC_FUNCTIONS
*funcs
= NULL
;
759 TRACE("%04x\n", hdc
);
763 if (!(dc
= GDI_GetObjPtr( hdc
, DC_MAGIC
))) return FALSE
;
765 /* Call hook procedure to check whether is it OK to delete this DC */
766 if (dc
->hookThunk
&& !(dc
->flags
& (DC_SAVED
| DC_MEMORY
)))
768 DCHOOKPROC proc
= dc
->hookThunk
;
771 DWORD data
= dc
->dwHookData
;
772 GDI_ReleaseObj( hdc
);
773 if (!proc( hdc
, DCHC_DELETEDC
, data
, 0 )) return FALSE
;
774 if (!(dc
= DC_GetDCPtr( hdc
))) return TRUE
; /* deleted by the hook */
778 while (dc
->saveLevel
)
781 HDC16 hdcs
= dc
->header
.hNext
;
782 if (!(dcs
= GDI_GetObjPtr( hdcs
, DC_MAGIC
))) break;
783 dc
->header
.hNext
= dcs
->header
.hNext
;
785 if (dcs
->hClipRgn
) DeleteObject( dcs
->hClipRgn
);
786 if (dcs
->hVisRgn
) DeleteObject( dcs
->hVisRgn
);
787 if (dcs
->hGCClipRgn
) DeleteObject( dcs
->hGCClipRgn
);
788 PATH_DestroyGdiPath(&dcs
->path
);
789 GDI_FreeObject( hdcs
, dcs
);
792 if (!(dc
->flags
& DC_SAVED
))
794 SelectObject( hdc
, GetStockObject(BLACK_PEN
) );
795 SelectObject( hdc
, GetStockObject(WHITE_BRUSH
) );
796 SelectObject( hdc
, GetStockObject(SYSTEM_FONT
) );
797 SelectObject( hdc
, GetStockObject(DEFAULT_BITMAP
) );
799 if (dc
->funcs
->pDeleteDC
) dc
->funcs
->pDeleteDC(dc
->physDev
);
802 if (dc
->hClipRgn
) DeleteObject( dc
->hClipRgn
);
803 if (dc
->hVisRgn
) DeleteObject( dc
->hVisRgn
);
804 if (dc
->hGCClipRgn
) DeleteObject( dc
->hGCClipRgn
);
805 PATH_DestroyGdiPath(&dc
->path
);
807 GDI_FreeObject( hdc
, dc
);
808 if (funcs
) DRIVER_release_driver( funcs
); /* do that after releasing the GDI lock */
813 /***********************************************************************
816 HDC16 WINAPI
ResetDC16( HDC16 hdc
, const DEVMODEA
*devmode
)
818 return ResetDCA(hdc
, devmode
);
822 /***********************************************************************
825 HDC WINAPI
ResetDCA( HDC hdc
, const DEVMODEA
*devmode
)
830 if ((dc
= DC_GetDCPtr( hdc
)))
832 if (dc
->funcs
->pResetDC
) ret
= dc
->funcs
->pResetDC( dc
->physDev
, devmode
);
833 GDI_ReleaseObj( hdc
);
839 /***********************************************************************
842 HDC WINAPI
ResetDCW( HDC hdc
, const DEVMODEW
*devmode
)
844 return ResetDCA(hdc
, (const DEVMODEA
*)devmode
); /* FIXME */
848 /***********************************************************************
849 * GetDeviceCaps (GDI.80)
851 INT16 WINAPI
GetDeviceCaps16( HDC16 hdc
, INT16 cap
)
853 INT16 ret
= GetDeviceCaps( hdc
, cap
);
854 /* some apps don't expect -1 and think it's a B&W screen */
855 if ((cap
== NUMCOLORS
) && (ret
== -1)) ret
= 2048;
860 /***********************************************************************
861 * GetDeviceCaps (GDI32.@)
863 INT WINAPI
GetDeviceCaps( HDC hdc
, INT cap
)
868 if ((dc
= DC_GetDCPtr( hdc
)))
870 if (dc
->funcs
->pGetDeviceCaps
) ret
= dc
->funcs
->pGetDeviceCaps( dc
->physDev
, cap
);
871 GDI_ReleaseObj( hdc
);
877 /***********************************************************************
880 COLORREF WINAPI
SetBkColor16( HDC16 hdc
, COLORREF color
)
882 return SetBkColor( hdc
, color
);
886 /***********************************************************************
887 * SetBkColor (GDI32.@)
889 COLORREF WINAPI
SetBkColor( HDC hdc
, COLORREF color
)
892 DC
* dc
= DC_GetDCPtr( hdc
);
894 if (!dc
) return CLR_INVALID
;
895 oldColor
= dc
->backgroundColor
;
896 if (dc
->funcs
->pSetBkColor
)
898 color
= dc
->funcs
->pSetBkColor(dc
->physDev
, color
);
899 if (color
== CLR_INVALID
) /* don't change it */
902 oldColor
= CLR_INVALID
;
905 dc
->backgroundColor
= color
;
906 GDI_ReleaseObj( hdc
);
911 /***********************************************************************
912 * SetTextColor (GDI.9)
914 COLORREF WINAPI
SetTextColor16( HDC16 hdc
, COLORREF color
)
916 return SetTextColor( hdc
, color
);
920 /***********************************************************************
921 * SetTextColor (GDI32.@)
923 COLORREF WINAPI
SetTextColor( HDC hdc
, COLORREF color
)
926 DC
* dc
= DC_GetDCPtr( hdc
);
928 if (!dc
) return CLR_INVALID
;
929 oldColor
= dc
->textColor
;
930 if (dc
->funcs
->pSetTextColor
)
932 color
= dc
->funcs
->pSetTextColor(dc
->physDev
, color
);
933 if (color
== CLR_INVALID
) /* don't change it */
936 oldColor
= CLR_INVALID
;
939 dc
->textColor
= color
;
940 GDI_ReleaseObj( hdc
);
944 /***********************************************************************
945 * SetTextAlign (GDI.346)
947 UINT16 WINAPI
SetTextAlign16( HDC16 hdc
, UINT16 align
)
949 return SetTextAlign( hdc
, align
);
953 /***********************************************************************
954 * SetTextAlign (GDI32.@)
956 UINT WINAPI
SetTextAlign( HDC hdc
, UINT align
)
959 DC
*dc
= DC_GetDCPtr( hdc
);
961 if (dc
->funcs
->pSetTextAlign
)
962 prevAlign
= dc
->funcs
->pSetTextAlign(dc
->physDev
, align
);
964 prevAlign
= dc
->textAlign
;
965 dc
->textAlign
= align
;
967 GDI_ReleaseObj( hdc
);
971 /***********************************************************************
972 * GetDCOrgEx (GDI32.@)
974 BOOL WINAPI
GetDCOrgEx( HDC hDC
, LPPOINT lpp
)
978 if (!lpp
) return FALSE
;
979 if (!(dc
= DC_GetDCPtr( hDC
))) return FALSE
;
982 if (dc
->funcs
->pGetDCOrgEx
) dc
->funcs
->pGetDCOrgEx( dc
->physDev
, lpp
);
983 lpp
->x
+= dc
->DCOrgX
;
984 lpp
->y
+= dc
->DCOrgY
;
985 GDI_ReleaseObj( hDC
);
990 /***********************************************************************
993 DWORD WINAPI
GetDCOrg16( HDC16 hdc
)
996 if( GetDCOrgEx( hdc
, &pt
) )
997 return MAKELONG( (WORD
)pt
.x
, (WORD
)pt
.y
);
1002 /***********************************************************************
1003 * SetDCOrg (GDI.117)
1005 DWORD WINAPI
SetDCOrg16( HDC16 hdc
, INT16 x
, INT16 y
)
1008 DC
*dc
= DC_GetDCPtr( hdc
);
1010 prevOrg
= dc
->DCOrgX
| (dc
->DCOrgY
<< 16);
1013 GDI_ReleaseObj( hdc
);
1018 /***********************************************************************
1019 * SetGraphicsMode (GDI32.@)
1021 INT WINAPI
SetGraphicsMode( HDC hdc
, INT mode
)
1024 DC
*dc
= DC_GetDCPtr( hdc
);
1026 /* One would think that setting the graphics mode to GM_COMPATIBLE
1027 * would also reset the world transformation matrix to the unity
1028 * matrix. However, in Windows, this is not the case. This doesn't
1029 * make a lot of sense to me, but that's the way it is.
1032 if ((mode
> 0) || (mode
<= GM_LAST
))
1034 ret
= dc
->GraphicsMode
;
1035 dc
->GraphicsMode
= mode
;
1037 GDI_ReleaseObj( hdc
);
1042 /***********************************************************************
1043 * SetArcDirection (GDI.525)
1045 INT16 WINAPI
SetArcDirection16( HDC16 hdc
, INT16 nDirection
)
1047 return SetArcDirection( (HDC
)hdc
, (INT
)nDirection
);
1051 /***********************************************************************
1052 * SetArcDirection (GDI32.@)
1054 INT WINAPI
SetArcDirection( HDC hdc
, INT nDirection
)
1057 INT nOldDirection
= 0;
1059 if (nDirection
!=AD_COUNTERCLOCKWISE
&& nDirection
!=AD_CLOCKWISE
)
1061 SetLastError(ERROR_INVALID_PARAMETER
);
1065 if ((dc
= DC_GetDCPtr( hdc
)))
1067 nOldDirection
= dc
->ArcDirection
;
1068 dc
->ArcDirection
= nDirection
;
1069 GDI_ReleaseObj( hdc
);
1071 return nOldDirection
;
1075 /***********************************************************************
1076 * GetWorldTransform (GDI32.@)
1078 BOOL WINAPI
GetWorldTransform( HDC hdc
, LPXFORM xform
)
1081 if (!xform
) return FALSE
;
1082 if (!(dc
= DC_GetDCPtr( hdc
))) return FALSE
;
1083 *xform
= dc
->xformWorld2Wnd
;
1084 GDI_ReleaseObj( hdc
);
1089 /***********************************************************************
1090 * SetWorldTransform (GDI32.@)
1092 BOOL WINAPI
SetWorldTransform( HDC hdc
, const XFORM
*xform
)
1095 DC
*dc
= DC_GetDCPtr( hdc
);
1097 if (!dc
) return FALSE
;
1098 if (!xform
) goto done
;
1100 /* Check that graphics mode is GM_ADVANCED */
1101 if (dc
->GraphicsMode
!=GM_ADVANCED
) goto done
;
1103 dc
->xformWorld2Wnd
= *xform
;
1104 DC_UpdateXforms( dc
);
1107 GDI_ReleaseObj( hdc
);
1112 /****************************************************************************
1113 * ModifyWorldTransform [GDI32.@]
1114 * Modifies the world transformation for a device context.
1117 * hdc [I] Handle to device context
1118 * xform [I] XFORM structure that will be used to modify the world
1120 * iMode [I] Specifies in what way to modify the world transformation
1123 * Resets the world transformation to the identity matrix.
1124 * The parameter xform is ignored.
1126 * Multiplies xform into the world transformation matrix from
1129 * Multiplies xform into the world transformation matrix from
1134 BOOL WINAPI
ModifyWorldTransform( HDC hdc
, const XFORM
*xform
,
1138 DC
*dc
= DC_GetDCPtr( hdc
);
1140 /* Check for illegal parameters */
1141 if (!dc
) return FALSE
;
1142 if (!xform
) goto done
;
1144 /* Check that graphics mode is GM_ADVANCED */
1145 if (dc
->GraphicsMode
!=GM_ADVANCED
) goto done
;
1150 dc
->xformWorld2Wnd
.eM11
= 1.0f
;
1151 dc
->xformWorld2Wnd
.eM12
= 0.0f
;
1152 dc
->xformWorld2Wnd
.eM21
= 0.0f
;
1153 dc
->xformWorld2Wnd
.eM22
= 1.0f
;
1154 dc
->xformWorld2Wnd
.eDx
= 0.0f
;
1155 dc
->xformWorld2Wnd
.eDy
= 0.0f
;
1157 case MWT_LEFTMULTIPLY
:
1158 CombineTransform( &dc
->xformWorld2Wnd
, xform
,
1159 &dc
->xformWorld2Wnd
);
1161 case MWT_RIGHTMULTIPLY
:
1162 CombineTransform( &dc
->xformWorld2Wnd
, &dc
->xformWorld2Wnd
,
1169 DC_UpdateXforms( dc
);
1172 GDI_ReleaseObj( hdc
);
1177 /****************************************************************************
1178 * CombineTransform [GDI32.@]
1179 * Combines two transformation matrices.
1182 * xformResult [O] Stores the result of combining the two matrices
1183 * xform1 [I] Specifies the first matrix to apply
1184 * xform2 [I] Specifies the second matrix to apply
1187 * The same matrix can be passed in for more than one of the parameters.
1191 BOOL WINAPI
CombineTransform( LPXFORM xformResult
, const XFORM
*xform1
,
1192 const XFORM
*xform2
)
1196 /* Check for illegal parameters */
1197 if (!xformResult
|| !xform1
|| !xform2
)
1200 /* Create the result in a temporary XFORM, since xformResult may be
1201 * equal to xform1 or xform2 */
1202 xformTemp
.eM11
= xform1
->eM11
* xform2
->eM11
+
1203 xform1
->eM12
* xform2
->eM21
;
1204 xformTemp
.eM12
= xform1
->eM11
* xform2
->eM12
+
1205 xform1
->eM12
* xform2
->eM22
;
1206 xformTemp
.eM21
= xform1
->eM21
* xform2
->eM11
+
1207 xform1
->eM22
* xform2
->eM21
;
1208 xformTemp
.eM22
= xform1
->eM21
* xform2
->eM12
+
1209 xform1
->eM22
* xform2
->eM22
;
1210 xformTemp
.eDx
= xform1
->eDx
* xform2
->eM11
+
1211 xform1
->eDy
* xform2
->eM21
+
1213 xformTemp
.eDy
= xform1
->eDx
* xform2
->eM12
+
1214 xform1
->eDy
* xform2
->eM22
+
1217 /* Copy the result to xformResult */
1218 *xformResult
= xformTemp
;
1224 /***********************************************************************
1225 * SetDCHook (GDI32.@)
1227 * Note: this doesn't exist in Win32, we add it here because user32 needs it.
1229 BOOL WINAPI
SetDCHook( HDC hdc
, DCHOOKPROC hookProc
, DWORD dwHookData
)
1231 DC
*dc
= DC_GetDCPtr( hdc
);
1233 if (!dc
) return FALSE
;
1234 dc
->dwHookData
= dwHookData
;
1235 dc
->hookThunk
= hookProc
;
1236 GDI_ReleaseObj( hdc
);
1241 /* relay function to call the 16-bit DC hook proc */
1242 static BOOL16 WINAPI
call_dc_hook16( HDC16 hdc
, WORD code
, DWORD data
, LPARAM lParam
)
1244 FARPROC16 proc
= NULL
;
1245 DC
*dc
= DC_GetDCPtr( hdc
);
1246 if (!dc
) return FALSE
;
1247 proc
= dc
->hookProc
;
1248 GDI_ReleaseObj( hdc
);
1249 if (!proc
) return FALSE
;
1250 return GDI_CallTo16_word_wwll( proc
, hdc
, code
, data
, lParam
);
1253 /***********************************************************************
1254 * SetDCHook (GDI.190)
1256 BOOL16 WINAPI
SetDCHook16( HDC16 hdc
, FARPROC16 hookProc
, DWORD dwHookData
)
1258 DC
*dc
= DC_GetDCPtr( hdc
);
1259 if (!dc
) return FALSE
;
1261 dc
->hookProc
= hookProc
;
1262 GDI_ReleaseObj( hdc
);
1263 return SetDCHook( hdc
, call_dc_hook16
, dwHookData
);
1267 /***********************************************************************
1268 * GetDCHook (GDI.191)
1270 DWORD WINAPI
GetDCHook( HDC16 hdc
, FARPROC16
*phookProc
)
1272 DC
*dc
= DC_GetDCPtr( hdc
);
1274 *phookProc
= dc
->hookProc
;
1275 GDI_ReleaseObj( hdc
);
1276 return dc
->dwHookData
;
1280 /***********************************************************************
1281 * SetHookFlags (GDI.192)
1283 WORD WINAPI
SetHookFlags16(HDC16 hDC
, WORD flags
)
1285 DC
*dc
= DC_GetDCPtr( hDC
);
1289 WORD wRet
= dc
->flags
& DC_DIRTY
;
1291 /* "Undocumented Windows" info is slightly confusing.
1294 TRACE("hDC %04x, flags %04x\n",hDC
,flags
);
1296 if( flags
& DCHF_INVALIDATEVISRGN
)
1297 dc
->flags
|= DC_DIRTY
;
1298 else if( flags
& DCHF_VALIDATEVISRGN
|| !flags
)
1299 dc
->flags
&= ~DC_DIRTY
;
1300 GDI_ReleaseObj( hDC
);
1306 /***********************************************************************
1307 * SetICMMode (GDI32.@)
1309 INT WINAPI
SetICMMode(HDC hdc
, INT iEnableICM
)
1311 /*FIXME Asuming that ICM is always off, and cannot be turned on */
1312 if (iEnableICM
== ICM_OFF
) return ICM_OFF
;
1313 if (iEnableICM
== ICM_ON
) return 0;
1314 if (iEnableICM
== ICM_QUERY
) return ICM_OFF
;
1318 /***********************************************************************
1319 * GetDeviceGammaRamp (GDI32.@)
1321 BOOL WINAPI
GetDeviceGammaRamp(HDC hDC
, LPVOID ptr
)
1324 DC
*dc
= DC_GetDCPtr( hDC
);
1328 if (dc
->funcs
->pGetDeviceGammaRamp
)
1329 ret
= dc
->funcs
->pGetDeviceGammaRamp(dc
->physDev
, ptr
);
1330 GDI_ReleaseObj( hDC
);
1335 /***********************************************************************
1336 * SetDeviceGammaRamp (GDI32.@)
1338 BOOL WINAPI
SetDeviceGammaRamp(HDC hDC
, LPVOID ptr
)
1341 DC
*dc
= DC_GetDCPtr( hDC
);
1345 if (dc
->funcs
->pSetDeviceGammaRamp
)
1346 ret
= dc
->funcs
->pSetDeviceGammaRamp(dc
->physDev
, ptr
);
1347 GDI_ReleaseObj( hDC
);
1352 /***********************************************************************
1353 * GetColorSpace (GDI32.@)
1355 HCOLORSPACE WINAPI
GetColorSpace(HDC hdc
)
1357 /*FIXME Need to to whatever GetColorSpace actually does */
1361 /***********************************************************************
1362 * CreateColorSpaceA (GDI32.@)
1364 HCOLORSPACE WINAPI
CreateColorSpaceA( LPLOGCOLORSPACEA lpLogColorSpace
)
1370 /***********************************************************************
1371 * CreateColorSpaceW (GDI32.@)
1373 HCOLORSPACE WINAPI
CreateColorSpaceW( LPLOGCOLORSPACEW lpLogColorSpace
)
1379 /***********************************************************************
1380 * DeleteColorSpace (GDI32.@)
1382 BOOL WINAPI
DeleteColorSpace( HCOLORSPACE hColorSpace
)
1389 /***********************************************************************
1390 * SetColorSpace (GDI32.@)
1392 HCOLORSPACE WINAPI
SetColorSpace( HDC hDC
, HCOLORSPACE hColorSpace
)
1399 /***********************************************************************
1400 * GetBoundsRect (GDI.194)
1402 UINT16 WINAPI
GetBoundsRect16(HDC16 hdc
, LPRECT16 rect
, UINT16 flags
)
1404 return DCB_RESET
| DCB_DISABLE
; /* bounding rectangle always empty and disabled*/
1407 /***********************************************************************
1408 * GetBoundsRect (GDI32.@)
1410 UINT WINAPI
GetBoundsRect(HDC hdc
, LPRECT rect
, UINT flags
)
1412 FIXME("(): stub\n");
1413 return DCB_RESET
; /* bounding rectangle always empty */
1416 /***********************************************************************
1417 * SetBoundsRect (GDI.193)
1419 UINT16 WINAPI
SetBoundsRect16(HDC16 hdc
, const RECT16
* rect
, UINT16 flags
)
1421 if ( (flags
& DCB_ACCUMULATE
) || (flags
& DCB_ENABLE
) )
1422 FIXME("(%04x, %p, %04x): stub\n", hdc
, rect
, flags
);
1424 return DCB_RESET
| DCB_DISABLE
; /* bounding rectangle always empty and disabled*/
1427 /***********************************************************************
1428 * SetBoundsRect (GDI32.@)
1430 UINT WINAPI
SetBoundsRect(HDC hdc
, const RECT
* rect
, UINT flags
)
1432 FIXME("(): stub\n");
1433 return DCB_DISABLE
; /* bounding rectangle always empty */
1437 /***********************************************************************
1438 * GetRelAbs (GDI32.@)
1440 INT WINAPI
GetRelAbs( HDC hdc
, DWORD dwIgnore
)
1443 DC
*dc
= DC_GetDCPtr( hdc
);
1444 if (dc
) ret
= dc
->relAbsMode
;
1445 GDI_ReleaseObj( hdc
);
1449 /***********************************************************************
1452 * Disables GDI, switches back to text mode.
1453 * We don't have to do anything here,
1454 * just let console support handle everything
1456 void WINAPI
Death16(HDC16 hDC
)
1458 MESSAGE("Death(%04x) called. Application enters text mode...\n", hDC
);
1461 /***********************************************************************
1462 * Resurrection (GDI.122)
1464 * Restores GDI functionality
1466 void WINAPI
Resurrection16(HDC16 hDC
,
1467 WORD w1
, WORD w2
, WORD w3
, WORD w4
, WORD w5
, WORD w6
)
1469 MESSAGE("Resurrection(%04x, %04x, %04x, %04x, %04x, %04x, %04x) called. Application left text mode.\n", hDC
, w1
, w2
, w3
, w4
, w5
, w6
);
1472 /***********************************************************************
1473 * GetLayout (GDI32.@)
1475 * Gets left->right or right->left text layout flags of a dc.
1476 * win98 just returns 0 and sets ERROR_CALL_NOT_IMPLEMENTED so we do the same
1479 DWORD WINAPI
GetLayout(HDC hdc
)
1481 FIXME("(%08x): stub\n", hdc
);
1482 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
1486 /***********************************************************************
1487 * SetLayout (GDI32.@)
1489 * Sets left->right or right->left text layout flags of a dc.
1490 * win98 just returns 0 and sets ERROR_CALL_NOT_IMPLEMENTED so we do the same
1493 DWORD WINAPI
SetLayout(HDC hdc
, DWORD layout
)
1495 FIXME("(%08x,%08lx): stub\n", hdc
, layout
);
1496 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);