Added YUV routines needed for v4l driver, and in the future possibly
[wine/gsoc-2012-control.git] / dlls / gdi / dc.c
blob3cddbe80fdd02f87358e3eacc204085af56bb02a
1 /*
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
21 #include "config.h"
23 #include <stdarg.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include "windef.h"
27 #include "winbase.h"
28 #include "wingdi.h"
29 #include "winreg.h"
30 #include "winternl.h"
31 #include "winerror.h"
32 #include "wownt32.h"
33 #include "wine/winuser16.h"
34 #include "gdi.h"
35 #include "gdi_private.h"
36 #include "wine/unicode.h"
37 #include "wine/debug.h"
39 WINE_DEFAULT_DEBUG_CHANNEL(dc);
41 static const WCHAR displayW[] = { 'd','i','s','p','l','a','y',0 };
43 static BOOL DC_DeleteObject( HGDIOBJ handle, void *obj );
45 static const struct gdi_obj_funcs dc_funcs =
47 NULL, /* pSelectObject */
48 NULL, /* pGetObject16 */
49 NULL, /* pGetObjectA */
50 NULL, /* pGetObjectW */
51 NULL, /* pUnrealizeObject */
52 DC_DeleteObject /* pDeleteObject */
55 /***********************************************************************
56 * DC_AllocDC
58 DC *DC_AllocDC( const DC_FUNCTIONS *funcs, WORD magic )
60 HDC hdc;
61 DC *dc;
63 if (!(dc = GDI_AllocObject( sizeof(*dc), magic, (HGDIOBJ*)&hdc, &dc_funcs ))) return NULL;
65 dc->hSelf = hdc;
66 dc->funcs = funcs;
67 dc->physDev = NULL;
68 dc->saveLevel = 0;
69 dc->saved_dc = 0;
70 dc->dwHookData = 0;
71 dc->hookProc = NULL;
72 dc->hookThunk = NULL;
73 dc->wndOrgX = 0;
74 dc->wndOrgY = 0;
75 dc->wndExtX = 1;
76 dc->wndExtY = 1;
77 dc->vportOrgX = 0;
78 dc->vportOrgY = 0;
79 dc->vportExtX = 1;
80 dc->vportExtY = 1;
81 dc->miterLimit = 10.0f; /* 10.0 is the default, from MSDN */
82 dc->flags = 0;
83 dc->layout = 0;
84 dc->hClipRgn = 0;
85 dc->hMetaRgn = 0;
86 dc->hMetaClipRgn = 0;
87 dc->hVisRgn = 0;
88 dc->hPen = GetStockObject( BLACK_PEN );
89 dc->hBrush = GetStockObject( WHITE_BRUSH );
90 dc->hFont = GetStockObject( SYSTEM_FONT );
91 dc->hBitmap = 0;
92 dc->hDevice = 0;
93 dc->hPalette = GetStockObject( DEFAULT_PALETTE );
94 dc->gdiFont = 0;
95 dc->ROPmode = R2_COPYPEN;
96 dc->polyFillMode = ALTERNATE;
97 dc->stretchBltMode = BLACKONWHITE;
98 dc->relAbsMode = ABSOLUTE;
99 dc->backgroundMode = OPAQUE;
100 dc->backgroundColor = RGB( 255, 255, 255 );
101 dc->dcBrushColor = RGB( 255, 255, 255 );
102 dc->dcPenColor = RGB( 0, 0, 0 );
103 dc->textColor = RGB( 0, 0, 0 );
104 dc->brushOrgX = 0;
105 dc->brushOrgY = 0;
106 dc->textAlign = TA_LEFT | TA_TOP | TA_NOUPDATECP;
107 dc->charExtra = 0;
108 dc->breakExtra = 0;
109 dc->breakRem = 0;
110 dc->MapMode = MM_TEXT;
111 dc->GraphicsMode = GM_COMPATIBLE;
112 dc->pAbortProc = NULL;
113 dc->CursPosX = 0;
114 dc->CursPosY = 0;
115 dc->ArcDirection = AD_COUNTERCLOCKWISE;
116 dc->xformWorld2Wnd.eM11 = 1.0f;
117 dc->xformWorld2Wnd.eM12 = 0.0f;
118 dc->xformWorld2Wnd.eM21 = 0.0f;
119 dc->xformWorld2Wnd.eM22 = 1.0f;
120 dc->xformWorld2Wnd.eDx = 0.0f;
121 dc->xformWorld2Wnd.eDy = 0.0f;
122 dc->xformWorld2Vport = dc->xformWorld2Wnd;
123 dc->xformVport2World = dc->xformWorld2Wnd;
124 dc->vport2WorldValid = TRUE;
125 dc->BoundsRect.left = 0;
126 dc->BoundsRect.top = 0;
127 dc->BoundsRect.right = 0;
128 dc->BoundsRect.bottom = 0;
129 dc->saved_visrgn = NULL;
130 PATH_InitGdiPath(&dc->path);
131 return dc;
136 /***********************************************************************
137 * DC_GetDCPtr
139 DC *DC_GetDCPtr( HDC hdc )
141 GDIOBJHDR *ptr = GDI_GetObjPtr( hdc, MAGIC_DONTCARE );
142 if (!ptr) return NULL;
143 if ((GDIMAGIC(ptr->wMagic) == DC_MAGIC) ||
144 (GDIMAGIC(ptr->wMagic) == MEMORY_DC_MAGIC) ||
145 (GDIMAGIC(ptr->wMagic) == METAFILE_DC_MAGIC) ||
146 (GDIMAGIC(ptr->wMagic) == ENHMETAFILE_DC_MAGIC))
147 return (DC *)ptr;
148 GDI_ReleaseObj( hdc );
149 SetLastError( ERROR_INVALID_HANDLE );
150 return NULL;
153 /***********************************************************************
154 * DC_GetDCUpdate
156 * Retrieve a DC ptr while making sure the visRgn is updated.
157 * This function may call up to USER so the GDI lock should _not_
158 * be held when calling it.
160 DC *DC_GetDCUpdate( HDC hdc )
162 DC *dc = DC_GetDCPtr( hdc );
163 if (!dc) return NULL;
164 while (dc->flags & DC_DIRTY)
166 DCHOOKPROC proc = dc->hookThunk;
167 dc->flags &= ~DC_DIRTY;
168 if (proc)
170 DWORD data = dc->dwHookData;
171 GDI_ReleaseObj( hdc );
172 proc( HDC_16(hdc), DCHC_INVALIDVISRGN, data, 0 );
173 if (!(dc = DC_GetDCPtr( hdc ))) break;
174 /* otherwise restart the loop in case it became dirty again in the meantime */
177 return dc;
181 /***********************************************************************
182 * DC_DeleteObject
184 static BOOL DC_DeleteObject( HGDIOBJ handle, void *obj )
186 GDI_ReleaseObj( handle );
187 return DeleteDC( handle );
191 /***********************************************************************
192 * DC_InitDC
194 * Setup device-specific DC values for a newly created DC.
196 void DC_InitDC( DC* dc )
198 if (dc->funcs->pRealizeDefaultPalette) dc->funcs->pRealizeDefaultPalette( dc->physDev );
199 SetTextColor( dc->hSelf, dc->textColor );
200 SetBkColor( dc->hSelf, dc->backgroundColor );
201 SelectObject( dc->hSelf, dc->hPen );
202 SelectObject( dc->hSelf, dc->hBrush );
203 SelectObject( dc->hSelf, dc->hFont );
204 CLIPPING_UpdateGCRegion( dc );
208 /***********************************************************************
209 * DC_InvertXform
211 * Computes the inverse of the transformation xformSrc and stores it to
212 * xformDest. Returns TRUE if successful or FALSE if the xformSrc matrix
213 * is singular.
215 static BOOL DC_InvertXform( const XFORM *xformSrc, XFORM *xformDest )
217 FLOAT determinant;
219 determinant = xformSrc->eM11*xformSrc->eM22 -
220 xformSrc->eM12*xformSrc->eM21;
221 if (determinant > -1e-12 && determinant < 1e-12)
222 return FALSE;
224 xformDest->eM11 = xformSrc->eM22 / determinant;
225 xformDest->eM12 = -xformSrc->eM12 / determinant;
226 xformDest->eM21 = -xformSrc->eM21 / determinant;
227 xformDest->eM22 = xformSrc->eM11 / determinant;
228 xformDest->eDx = -xformSrc->eDx * xformDest->eM11 -
229 xformSrc->eDy * xformDest->eM21;
230 xformDest->eDy = -xformSrc->eDx * xformDest->eM12 -
231 xformSrc->eDy * xformDest->eM22;
233 return TRUE;
237 /***********************************************************************
238 * DC_UpdateXforms
240 * Updates the xformWorld2Vport, xformVport2World and vport2WorldValid
241 * fields of the specified DC by creating a transformation that
242 * represents the current mapping mode and combining it with the DC's
243 * world transform. This function should be called whenever the
244 * parameters associated with the mapping mode (window and viewport
245 * extents and origins) or the world transform change.
247 void DC_UpdateXforms( DC *dc )
249 XFORM xformWnd2Vport, oldworld2vport;
250 FLOAT scaleX, scaleY;
252 /* Construct a transformation to do the window-to-viewport conversion */
253 scaleX = (FLOAT)dc->vportExtX / (FLOAT)dc->wndExtX;
254 scaleY = (FLOAT)dc->vportExtY / (FLOAT)dc->wndExtY;
255 xformWnd2Vport.eM11 = scaleX;
256 xformWnd2Vport.eM12 = 0.0;
257 xformWnd2Vport.eM21 = 0.0;
258 xformWnd2Vport.eM22 = scaleY;
259 xformWnd2Vport.eDx = (FLOAT)dc->vportOrgX -
260 scaleX * (FLOAT)dc->wndOrgX;
261 xformWnd2Vport.eDy = (FLOAT)dc->vportOrgY -
262 scaleY * (FLOAT)dc->wndOrgY;
264 oldworld2vport = dc->xformWorld2Vport;
265 /* Combine with the world transformation */
266 CombineTransform( &dc->xformWorld2Vport, &dc->xformWorld2Wnd,
267 &xformWnd2Vport );
269 /* Create inverse of world-to-viewport transformation */
270 dc->vport2WorldValid = DC_InvertXform( &dc->xformWorld2Vport,
271 &dc->xformVport2World );
273 /* Reselect the font and pen back into the dc so that the size
274 gets updated. */
275 if(memcmp(&oldworld2vport, &dc->xformWorld2Vport, sizeof(oldworld2vport)))
277 SelectObject(dc->hSelf, GetCurrentObject(dc->hSelf, OBJ_FONT));
278 SelectObject(dc->hSelf, GetCurrentObject(dc->hSelf, OBJ_PEN));
283 /***********************************************************************
284 * GetDCState (Not a Windows API)
286 HDC WINAPI GetDCState( HDC hdc )
288 DC * newdc, * dc;
289 HGDIOBJ handle;
291 if (!(dc = DC_GetDCPtr( hdc ))) return 0;
292 if (!(newdc = GDI_AllocObject( sizeof(DC), GDIMAGIC(dc->header.wMagic), &handle, &dc_funcs )))
294 GDI_ReleaseObj( hdc );
295 return 0;
297 TRACE("(%p): returning %p\n", hdc, handle );
299 newdc->flags = dc->flags | DC_SAVED;
300 newdc->layout = dc->layout;
301 newdc->hPen = dc->hPen;
302 newdc->hBrush = dc->hBrush;
303 newdc->hFont = dc->hFont;
304 newdc->hBitmap = dc->hBitmap;
305 newdc->hDevice = dc->hDevice;
306 newdc->hPalette = dc->hPalette;
307 newdc->ROPmode = dc->ROPmode;
308 newdc->polyFillMode = dc->polyFillMode;
309 newdc->stretchBltMode = dc->stretchBltMode;
310 newdc->relAbsMode = dc->relAbsMode;
311 newdc->backgroundMode = dc->backgroundMode;
312 newdc->backgroundColor = dc->backgroundColor;
313 newdc->textColor = dc->textColor;
314 newdc->dcBrushColor = dc->dcBrushColor;
315 newdc->dcPenColor = dc->dcPenColor;
316 newdc->brushOrgX = dc->brushOrgX;
317 newdc->brushOrgY = dc->brushOrgY;
318 newdc->textAlign = dc->textAlign;
319 newdc->charExtra = dc->charExtra;
320 newdc->breakExtra = dc->breakExtra;
321 newdc->breakRem = dc->breakRem;
322 newdc->MapMode = dc->MapMode;
323 newdc->GraphicsMode = dc->GraphicsMode;
324 newdc->CursPosX = dc->CursPosX;
325 newdc->CursPosY = dc->CursPosY;
326 newdc->ArcDirection = dc->ArcDirection;
327 newdc->xformWorld2Wnd = dc->xformWorld2Wnd;
328 newdc->xformWorld2Vport = dc->xformWorld2Vport;
329 newdc->xformVport2World = dc->xformVport2World;
330 newdc->vport2WorldValid = dc->vport2WorldValid;
331 newdc->wndOrgX = dc->wndOrgX;
332 newdc->wndOrgY = dc->wndOrgY;
333 newdc->wndExtX = dc->wndExtX;
334 newdc->wndExtY = dc->wndExtY;
335 newdc->vportOrgX = dc->vportOrgX;
336 newdc->vportOrgY = dc->vportOrgY;
337 newdc->vportExtX = dc->vportExtX;
338 newdc->vportExtY = dc->vportExtY;
339 newdc->BoundsRect = dc->BoundsRect;
341 newdc->hSelf = (HDC)handle;
342 newdc->saveLevel = 0;
343 newdc->saved_dc = 0;
345 PATH_InitGdiPath( &newdc->path );
347 newdc->pAbortProc = NULL;
348 newdc->hookThunk = NULL;
349 newdc->hookProc = 0;
350 newdc->saved_visrgn = NULL;
352 /* Get/SetDCState() don't change hVisRgn field ("Undoc. Windows" p.559). */
354 newdc->hVisRgn = 0;
355 newdc->hClipRgn = 0;
356 newdc->hMetaRgn = 0;
357 newdc->hMetaClipRgn = 0;
358 if (dc->hClipRgn)
360 newdc->hClipRgn = CreateRectRgn( 0, 0, 0, 0 );
361 CombineRgn( newdc->hClipRgn, dc->hClipRgn, 0, RGN_COPY );
363 if (dc->hMetaRgn)
365 newdc->hMetaRgn = CreateRectRgn( 0, 0, 0, 0 );
366 CombineRgn( newdc->hMetaRgn, dc->hMetaRgn, 0, RGN_COPY );
368 /* don't bother recomputing hMetaClipRgn, we'll do that in SetDCState */
370 if(dc->gdiFont) {
371 newdc->gdiFont = dc->gdiFont;
372 } else
373 newdc->gdiFont = 0;
375 GDI_ReleaseObj( handle );
376 GDI_ReleaseObj( hdc );
377 return handle;
381 /***********************************************************************
382 * SetDCState (Not a Windows API)
384 void WINAPI SetDCState( HDC hdc, HDC hdcs )
386 DC *dc, *dcs;
388 if (!(dc = DC_GetDCUpdate( hdc ))) return;
389 if (!(dcs = DC_GetDCPtr( hdcs )))
391 GDI_ReleaseObj( hdc );
392 return;
394 if (!dcs->flags & DC_SAVED)
396 GDI_ReleaseObj( hdc );
397 GDI_ReleaseObj( hdcs );
398 return;
400 TRACE("%p %p\n", hdc, hdcs );
402 dc->flags = dcs->flags & ~(DC_SAVED | DC_DIRTY);
403 dc->layout = dcs->layout;
404 dc->hDevice = dcs->hDevice;
405 dc->ROPmode = dcs->ROPmode;
406 dc->polyFillMode = dcs->polyFillMode;
407 dc->stretchBltMode = dcs->stretchBltMode;
408 dc->relAbsMode = dcs->relAbsMode;
409 dc->backgroundMode = dcs->backgroundMode;
410 dc->backgroundColor = dcs->backgroundColor;
411 dc->textColor = dcs->textColor;
412 dc->dcBrushColor = dcs->dcBrushColor;
413 dc->dcPenColor = dcs->dcPenColor;
414 dc->brushOrgX = dcs->brushOrgX;
415 dc->brushOrgY = dcs->brushOrgY;
416 dc->textAlign = dcs->textAlign;
417 dc->charExtra = dcs->charExtra;
418 dc->breakExtra = dcs->breakExtra;
419 dc->breakRem = dcs->breakRem;
420 dc->MapMode = dcs->MapMode;
421 dc->GraphicsMode = dcs->GraphicsMode;
422 dc->CursPosX = dcs->CursPosX;
423 dc->CursPosY = dcs->CursPosY;
424 dc->ArcDirection = dcs->ArcDirection;
425 dc->xformWorld2Wnd = dcs->xformWorld2Wnd;
426 dc->xformWorld2Vport = dcs->xformWorld2Vport;
427 dc->xformVport2World = dcs->xformVport2World;
428 dc->vport2WorldValid = dcs->vport2WorldValid;
429 dc->BoundsRect = dcs->BoundsRect;
431 dc->wndOrgX = dcs->wndOrgX;
432 dc->wndOrgY = dcs->wndOrgY;
433 dc->wndExtX = dcs->wndExtX;
434 dc->wndExtY = dcs->wndExtY;
435 dc->vportOrgX = dcs->vportOrgX;
436 dc->vportOrgY = dcs->vportOrgY;
437 dc->vportExtX = dcs->vportExtX;
438 dc->vportExtY = dcs->vportExtY;
440 if (dcs->hClipRgn)
442 if (!dc->hClipRgn) dc->hClipRgn = CreateRectRgn( 0, 0, 0, 0 );
443 CombineRgn( dc->hClipRgn, dcs->hClipRgn, 0, RGN_COPY );
445 else
447 if (dc->hClipRgn) DeleteObject( dc->hClipRgn );
448 dc->hClipRgn = 0;
450 if (dcs->hMetaRgn)
452 if (!dc->hMetaRgn) dc->hMetaRgn = CreateRectRgn( 0, 0, 0, 0 );
453 CombineRgn( dc->hMetaRgn, dcs->hMetaRgn, 0, RGN_COPY );
455 else
457 if (dc->hMetaRgn) DeleteObject( dc->hMetaRgn );
458 dc->hMetaRgn = 0;
460 CLIPPING_UpdateGCRegion( dc );
462 SelectObject( hdc, dcs->hBitmap );
463 SelectObject( hdc, dcs->hBrush );
464 SelectObject( hdc, dcs->hFont );
465 SelectObject( hdc, dcs->hPen );
466 SetBkColor( hdc, dcs->backgroundColor);
467 SetTextColor( hdc, dcs->textColor);
468 GDISelectPalette( hdc, dcs->hPalette, FALSE );
469 GDI_ReleaseObj( hdcs );
470 GDI_ReleaseObj( hdc );
474 /***********************************************************************
475 * GetDCState (GDI.179)
477 HDC16 WINAPI GetDCState16( HDC16 hdc )
479 return HDC_16( GetDCState( HDC_32(hdc) ));
483 /***********************************************************************
484 * SetDCState (GDI.180)
486 void WINAPI SetDCState16( HDC16 hdc, HDC16 hdcs )
488 SetDCState( HDC_32(hdc), HDC_32(hdcs) );
492 /***********************************************************************
493 * SaveDC (GDI32.@)
495 INT WINAPI SaveDC( HDC hdc )
497 HDC hdcs;
498 DC * dc, * dcs;
499 INT ret;
501 dc = DC_GetDCPtr( hdc );
502 if (!dc) return 0;
504 if(dc->funcs->pSaveDC)
506 ret = dc->funcs->pSaveDC( dc->physDev );
507 GDI_ReleaseObj( hdc );
508 return ret;
511 if (!(hdcs = GetDCState( hdc )))
513 GDI_ReleaseObj( hdc );
514 return 0;
516 dcs = DC_GetDCPtr( hdcs );
518 /* Copy path. The reason why path saving / restoring is in SaveDC/
519 * RestoreDC and not in GetDCState/SetDCState is that the ...DCState
520 * functions are only in Win16 (which doesn't have paths) and that
521 * SetDCState doesn't allow us to signal an error (which can happen
522 * when copying paths).
524 if (!PATH_AssignGdiPath( &dcs->path, &dc->path ))
526 GDI_ReleaseObj( hdc );
527 GDI_ReleaseObj( hdcs );
528 DeleteDC( hdcs );
529 return 0;
532 dcs->saved_dc = dc->saved_dc;
533 dc->saved_dc = hdcs;
534 TRACE("(%p): returning %d\n", hdc, dc->saveLevel+1 );
535 ret = ++dc->saveLevel;
536 GDI_ReleaseObj( hdcs );
537 GDI_ReleaseObj( hdc );
538 return ret;
542 /***********************************************************************
543 * RestoreDC (GDI32.@)
545 BOOL WINAPI RestoreDC( HDC hdc, INT level )
547 DC * dc, * dcs;
548 BOOL success;
550 TRACE("%p %d\n", hdc, level );
551 dc = DC_GetDCUpdate( hdc );
552 if(!dc) return FALSE;
553 if(dc->funcs->pRestoreDC)
555 success = dc->funcs->pRestoreDC( dc->physDev, level );
556 GDI_ReleaseObj( hdc );
557 return success;
560 if (level == -1) level = dc->saveLevel;
561 if ((level < 1)
562 /* This pair of checks disagrees with MSDN "Platform SDK:
563 Windows GDI" July 2000 which says all negative values
564 for level will be interpreted as an instance relative
565 to the current state. Restricting it to just -1 does
566 not satisfy this */
567 || (level > dc->saveLevel))
569 GDI_ReleaseObj( hdc );
570 return FALSE;
573 success=TRUE;
574 while (dc->saveLevel >= level)
576 HDC hdcs = dc->saved_dc;
577 if (!(dcs = DC_GetDCPtr( hdcs )))
579 GDI_ReleaseObj( hdc );
580 return FALSE;
582 dc->saved_dc = dcs->saved_dc;
583 dcs->saved_dc = 0;
584 if (--dc->saveLevel < level)
586 SetDCState( hdc, hdcs );
587 if (!PATH_AssignGdiPath( &dc->path, &dcs->path ))
588 /* FIXME: This might not be quite right, since we're
589 * returning FALSE but still destroying the saved DC state */
590 success=FALSE;
592 GDI_ReleaseObj( hdcs );
593 GDI_ReleaseObj( hdc );
594 DeleteDC( hdcs );
595 if (!(dc = DC_GetDCPtr( hdc ))) return FALSE;
597 GDI_ReleaseObj( hdc );
598 return success;
602 /***********************************************************************
603 * CreateDCW (GDI32.@)
605 HDC WINAPI CreateDCW( LPCWSTR driver, LPCWSTR device, LPCWSTR output,
606 const DEVMODEW *initData )
608 HDC hdc;
609 DC * dc;
610 const DC_FUNCTIONS *funcs;
611 WCHAR buf[300];
613 GDI_CheckNotLock();
615 if (!device || !DRIVER_GetDriverName( device, buf, 300 ))
617 if (!driver) return 0;
618 strcpyW(buf, driver);
621 if (!(funcs = DRIVER_load_driver( buf )))
623 ERR( "no driver found for %s\n", debugstr_w(buf) );
624 return 0;
626 if (!(dc = DC_AllocDC( funcs, DC_MAGIC )))
628 DRIVER_release_driver( funcs );
629 return 0;
631 hdc = dc->hSelf;
633 dc->hBitmap = GetStockObject( DEFAULT_BITMAP );
635 TRACE("(driver=%s, device=%s, output=%s): returning %p\n",
636 debugstr_w(driver), debugstr_w(device), debugstr_w(output), dc->hSelf );
638 if (dc->funcs->pCreateDC &&
639 !dc->funcs->pCreateDC( hdc, &dc->physDev, buf, device, output, initData ))
641 WARN("creation aborted by device\n" );
642 GDI_FreeObject( dc->hSelf, dc );
643 DRIVER_release_driver( funcs );
644 return 0;
647 dc->hVisRgn = CreateRectRgn( 0, 0, GetDeviceCaps( hdc, HORZRES ),
648 GetDeviceCaps( hdc, VERTRES ) );
650 DC_InitDC( dc );
651 GDI_ReleaseObj( hdc );
652 return hdc;
656 /***********************************************************************
657 * CreateDCA (GDI32.@)
659 HDC WINAPI CreateDCA( LPCSTR driver, LPCSTR device, LPCSTR output,
660 const DEVMODEA *initData )
662 UNICODE_STRING driverW, deviceW, outputW;
663 DEVMODEW *initDataW;
664 HDC ret;
666 if (driver) RtlCreateUnicodeStringFromAsciiz(&driverW, driver);
667 else driverW.Buffer = NULL;
669 if (device) RtlCreateUnicodeStringFromAsciiz(&deviceW, device);
670 else deviceW.Buffer = NULL;
672 if (output) RtlCreateUnicodeStringFromAsciiz(&outputW, output);
673 else outputW.Buffer = NULL;
675 initDataW = NULL;
676 if (initData)
678 /* don't convert initData for DISPLAY driver, it's not used */
679 if (!driverW.Buffer || strcmpiW( driverW.Buffer, displayW ))
680 initDataW = GdiConvertToDevmodeW(initData);
683 ret = CreateDCW( driverW.Buffer, deviceW.Buffer, outputW.Buffer, initDataW );
685 RtlFreeUnicodeString(&driverW);
686 RtlFreeUnicodeString(&deviceW);
687 RtlFreeUnicodeString(&outputW);
688 HeapFree(GetProcessHeap(), 0, initDataW);
689 return ret;
693 /***********************************************************************
694 * CreateICA (GDI32.@)
696 HDC WINAPI CreateICA( LPCSTR driver, LPCSTR device, LPCSTR output,
697 const DEVMODEA* initData )
699 /* Nothing special yet for ICs */
700 return CreateDCA( driver, device, output, initData );
704 /***********************************************************************
705 * CreateICW (GDI32.@)
707 HDC WINAPI CreateICW( LPCWSTR driver, LPCWSTR device, LPCWSTR output,
708 const DEVMODEW* initData )
710 /* Nothing special yet for ICs */
711 return CreateDCW( driver, device, output, initData );
715 /***********************************************************************
716 * CreateCompatibleDC (GDI32.@)
718 HDC WINAPI CreateCompatibleDC( HDC hdc )
720 DC *dc, *origDC;
721 const DC_FUNCTIONS *funcs;
722 PHYSDEV physDev;
724 GDI_CheckNotLock();
726 if ((origDC = GDI_GetObjPtr( hdc, DC_MAGIC )))
728 funcs = origDC->funcs;
729 physDev = origDC->physDev;
730 GDI_ReleaseObj( hdc ); /* can't hold the lock while loading the driver */
731 funcs = DRIVER_get_driver( funcs );
733 else
735 funcs = DRIVER_load_driver( displayW );
736 physDev = NULL;
739 if (!funcs) return 0;
741 if (!(dc = DC_AllocDC( funcs, MEMORY_DC_MAGIC )))
743 DRIVER_release_driver( funcs );
744 return 0;
747 TRACE("(%p): returning %p\n", hdc, dc->hSelf );
749 dc->hBitmap = GetStockObject( DEFAULT_BITMAP );
751 /* Copy the driver-specific physical device info into
752 * the new DC. The driver may use this read-only info
753 * while creating the compatible DC below. */
754 dc->physDev = physDev;
756 if (dc->funcs->pCreateDC &&
757 !dc->funcs->pCreateDC( dc->hSelf, &dc->physDev, NULL, NULL, NULL, NULL ))
759 WARN("creation aborted by device\n");
760 GDI_FreeObject( dc->hSelf, dc );
761 DRIVER_release_driver( funcs );
762 return 0;
765 dc->hVisRgn = CreateRectRgn( 0, 0, 1, 1 ); /* default bitmap is 1x1 */
767 DC_InitDC( dc );
768 GDI_ReleaseObj( dc->hSelf );
769 return dc->hSelf;
773 /***********************************************************************
774 * DeleteDC (GDI32.@)
776 BOOL WINAPI DeleteDC( HDC hdc )
778 const DC_FUNCTIONS *funcs = NULL;
779 DC * dc;
781 TRACE("%p\n", hdc );
783 GDI_CheckNotLock();
785 if (!(dc = DC_GetDCPtr( hdc ))) return FALSE;
787 /* Call hook procedure to check whether is it OK to delete this DC */
788 if (dc->hookThunk)
790 DCHOOKPROC proc = dc->hookThunk;
791 DWORD data = dc->dwHookData;
792 GDI_ReleaseObj( hdc );
793 if (!proc( HDC_16(hdc), DCHC_DELETEDC, data, 0 )) return FALSE;
794 if (!(dc = DC_GetDCPtr( hdc ))) return TRUE; /* deleted by the hook */
797 while (dc->saveLevel)
799 DC * dcs;
800 HDC hdcs = dc->saved_dc;
801 if (!(dcs = DC_GetDCPtr( hdcs ))) break;
802 dc->saved_dc = dcs->saved_dc;
803 dc->saveLevel--;
804 if (dcs->hClipRgn) DeleteObject( dcs->hClipRgn );
805 if (dcs->hMetaRgn) DeleteObject( dcs->hMetaRgn );
806 if (dcs->hMetaClipRgn) DeleteObject( dcs->hMetaClipRgn );
807 if (dcs->hVisRgn) DeleteObject( dcs->hVisRgn );
808 PATH_DestroyGdiPath(&dcs->path);
809 GDI_FreeObject( hdcs, dcs );
812 if (!(dc->flags & DC_SAVED))
814 SelectObject( hdc, GetStockObject(BLACK_PEN) );
815 SelectObject( hdc, GetStockObject(WHITE_BRUSH) );
816 SelectObject( hdc, GetStockObject(SYSTEM_FONT) );
817 SelectObject( hdc, GetStockObject(DEFAULT_BITMAP) );
818 funcs = dc->funcs;
819 if (dc->funcs->pDeleteDC) dc->funcs->pDeleteDC(dc->physDev);
820 dc->physDev = NULL;
823 while (dc->saved_visrgn)
825 struct saved_visrgn *next = dc->saved_visrgn->next;
826 DeleteObject( dc->saved_visrgn->hrgn );
827 HeapFree( GetProcessHeap(), 0, dc->saved_visrgn );
828 dc->saved_visrgn = next;
830 if (dc->hClipRgn) DeleteObject( dc->hClipRgn );
831 if (dc->hMetaRgn) DeleteObject( dc->hMetaRgn );
832 if (dc->hMetaClipRgn) DeleteObject( dc->hMetaClipRgn );
833 if (dc->hVisRgn) DeleteObject( dc->hVisRgn );
834 PATH_DestroyGdiPath(&dc->path);
836 GDI_FreeObject( hdc, dc );
837 if (funcs) DRIVER_release_driver( funcs ); /* do that after releasing the GDI lock */
838 return TRUE;
842 /***********************************************************************
843 * ResetDCW (GDI32.@)
845 HDC WINAPI ResetDCW( HDC hdc, const DEVMODEW *devmode )
847 DC *dc;
848 HDC ret = hdc;
850 if ((dc = DC_GetDCPtr( hdc )))
852 if (dc->funcs->pResetDC) ret = dc->funcs->pResetDC( dc->physDev, devmode );
853 GDI_ReleaseObj( hdc );
855 return ret;
859 /***********************************************************************
860 * ResetDCA (GDI32.@)
862 HDC WINAPI ResetDCA( HDC hdc, const DEVMODEA *devmode )
864 DEVMODEW *devmodeW;
865 HDC ret;
867 if (devmode) devmodeW = GdiConvertToDevmodeW(devmode);
868 else devmodeW = NULL;
870 ret = ResetDCW(hdc, devmodeW);
872 HeapFree(GetProcessHeap(), 0, devmodeW);
873 return ret;
877 /***********************************************************************
878 * GetDeviceCaps (GDI32.@)
880 INT WINAPI GetDeviceCaps( HDC hdc, INT cap )
882 DC *dc;
883 INT ret = 0;
885 if ((dc = DC_GetDCPtr( hdc )))
887 if (dc->funcs->pGetDeviceCaps) ret = dc->funcs->pGetDeviceCaps( dc->physDev, cap );
888 GDI_ReleaseObj( hdc );
890 return ret;
894 /***********************************************************************
895 * GetBkColor (GDI32.@)
897 COLORREF WINAPI GetBkColor( HDC hdc )
899 COLORREF ret = 0;
900 DC * dc = DC_GetDCPtr( hdc );
901 if (dc)
903 ret = dc->backgroundColor;
904 GDI_ReleaseObj( hdc );
906 return ret;
910 /***********************************************************************
911 * SetBkColor (GDI32.@)
913 COLORREF WINAPI SetBkColor( HDC hdc, COLORREF color )
915 COLORREF oldColor;
916 DC * dc = DC_GetDCPtr( hdc );
918 TRACE("hdc=%p color=0x%08lx\n", hdc, color);
920 if (!dc) return CLR_INVALID;
921 oldColor = dc->backgroundColor;
922 if (dc->funcs->pSetBkColor)
924 color = dc->funcs->pSetBkColor(dc->physDev, color);
925 if (color == CLR_INVALID) /* don't change it */
927 color = oldColor;
928 oldColor = CLR_INVALID;
931 dc->backgroundColor = color;
932 GDI_ReleaseObj( hdc );
933 return oldColor;
937 /***********************************************************************
938 * GetTextColor (GDI32.@)
940 COLORREF WINAPI GetTextColor( HDC hdc )
942 COLORREF ret = 0;
943 DC * dc = DC_GetDCPtr( hdc );
944 if (dc)
946 ret = dc->textColor;
947 GDI_ReleaseObj( hdc );
949 return ret;
953 /***********************************************************************
954 * SetTextColor (GDI32.@)
956 COLORREF WINAPI SetTextColor( HDC hdc, COLORREF color )
958 COLORREF oldColor;
959 DC * dc = DC_GetDCPtr( hdc );
961 TRACE(" hdc=%p color=0x%08lx\n", hdc, color);
963 if (!dc) return CLR_INVALID;
964 oldColor = dc->textColor;
965 if (dc->funcs->pSetTextColor)
967 color = dc->funcs->pSetTextColor(dc->physDev, color);
968 if (color == CLR_INVALID) /* don't change it */
970 color = oldColor;
971 oldColor = CLR_INVALID;
974 dc->textColor = color;
975 GDI_ReleaseObj( hdc );
976 return oldColor;
980 /***********************************************************************
981 * GetTextAlign (GDI32.@)
983 UINT WINAPI GetTextAlign( HDC hdc )
985 UINT ret = 0;
986 DC * dc = DC_GetDCPtr( hdc );
987 if (dc)
989 ret = dc->textAlign;
990 GDI_ReleaseObj( hdc );
992 return ret;
996 /***********************************************************************
997 * SetTextAlign (GDI32.@)
999 UINT WINAPI SetTextAlign( HDC hdc, UINT align )
1001 UINT prevAlign;
1002 DC *dc = DC_GetDCPtr( hdc );
1004 TRACE("hdc=%p align=%d\n", hdc, align);
1006 if (!dc) return 0x0;
1007 if (dc->funcs->pSetTextAlign)
1008 prevAlign = dc->funcs->pSetTextAlign(dc->physDev, align);
1009 else {
1010 prevAlign = dc->textAlign;
1011 dc->textAlign = align;
1013 GDI_ReleaseObj( hdc );
1014 return prevAlign;
1017 /***********************************************************************
1018 * GetDCOrgEx (GDI32.@)
1020 BOOL WINAPI GetDCOrgEx( HDC hDC, LPPOINT lpp )
1022 DC * dc;
1024 if (!lpp) return FALSE;
1025 if (!(dc = DC_GetDCPtr( hDC ))) return FALSE;
1027 lpp->x = lpp->y = 0;
1028 if (dc->funcs->pGetDCOrgEx) dc->funcs->pGetDCOrgEx( dc->physDev, lpp );
1029 GDI_ReleaseObj( hDC );
1030 return TRUE;
1034 /***********************************************************************
1035 * SetDCOrg (GDI.117)
1037 DWORD WINAPI SetDCOrg16( HDC16 hdc16, INT16 x, INT16 y )
1039 DWORD prevOrg = 0;
1040 HDC hdc = HDC_32( hdc16 );
1041 DC *dc = DC_GetDCPtr( hdc );
1042 if (!dc) return 0;
1043 if (dc->funcs->pSetDCOrg) prevOrg = dc->funcs->pSetDCOrg( dc->physDev, x, y );
1044 GDI_ReleaseObj( hdc );
1045 return prevOrg;
1049 /***********************************************************************
1050 * GetGraphicsMode (GDI32.@)
1052 INT WINAPI GetGraphicsMode( HDC hdc )
1054 INT ret = 0;
1055 DC * dc = DC_GetDCPtr( hdc );
1056 if (dc)
1058 ret = dc->GraphicsMode;
1059 GDI_ReleaseObj( hdc );
1061 return ret;
1065 /***********************************************************************
1066 * SetGraphicsMode (GDI32.@)
1068 INT WINAPI SetGraphicsMode( HDC hdc, INT mode )
1070 INT ret = 0;
1071 DC *dc = DC_GetDCPtr( hdc );
1073 /* One would think that setting the graphics mode to GM_COMPATIBLE
1074 * would also reset the world transformation matrix to the unity
1075 * matrix. However, in Windows, this is not the case. This doesn't
1076 * make a lot of sense to me, but that's the way it is.
1078 if (!dc) return 0;
1079 if ((mode > 0) && (mode <= GM_LAST))
1081 ret = dc->GraphicsMode;
1082 dc->GraphicsMode = mode;
1084 GDI_ReleaseObj( hdc );
1085 return ret;
1089 /***********************************************************************
1090 * GetArcDirection (GDI32.@)
1092 INT WINAPI GetArcDirection( HDC hdc )
1094 INT ret = 0;
1095 DC * dc = DC_GetDCPtr( hdc );
1096 if (dc)
1098 ret = dc->ArcDirection;
1099 GDI_ReleaseObj( hdc );
1101 return ret;
1105 /***********************************************************************
1106 * SetArcDirection (GDI32.@)
1108 INT WINAPI SetArcDirection( HDC hdc, INT nDirection )
1110 DC * dc;
1111 INT nOldDirection = 0;
1113 if (nDirection!=AD_COUNTERCLOCKWISE && nDirection!=AD_CLOCKWISE)
1115 SetLastError(ERROR_INVALID_PARAMETER);
1116 return 0;
1119 if ((dc = DC_GetDCPtr( hdc )))
1121 if (dc->funcs->pSetArcDirection)
1123 dc->funcs->pSetArcDirection(dc->physDev, nDirection);
1125 nOldDirection = dc->ArcDirection;
1126 dc->ArcDirection = nDirection;
1127 GDI_ReleaseObj( hdc );
1129 return nOldDirection;
1133 /***********************************************************************
1134 * GetWorldTransform (GDI32.@)
1136 BOOL WINAPI GetWorldTransform( HDC hdc, LPXFORM xform )
1138 DC * dc;
1139 if (!xform) return FALSE;
1140 if (!(dc = DC_GetDCPtr( hdc ))) return FALSE;
1141 *xform = dc->xformWorld2Wnd;
1142 GDI_ReleaseObj( hdc );
1143 return TRUE;
1147 /***********************************************************************
1148 * GetTransform (GDI32.@)
1150 BOOL WINAPI GetTransform( HDC hdc, DWORD unknown, LPXFORM xform )
1152 if (unknown == 0x0203) return GetWorldTransform( hdc, xform );
1153 FIXME("stub: don't know what to do for code %lx\n", unknown );
1154 return FALSE;
1158 /***********************************************************************
1159 * SetWorldTransform (GDI32.@)
1161 BOOL WINAPI SetWorldTransform( HDC hdc, const XFORM *xform )
1163 BOOL ret = FALSE;
1164 DC *dc = DC_GetDCPtr( hdc );
1166 if (!dc) return FALSE;
1167 if (!xform) goto done;
1169 /* Check that graphics mode is GM_ADVANCED */
1170 if (dc->GraphicsMode!=GM_ADVANCED) goto done;
1172 if (dc->funcs->pSetWorldTransform)
1174 ret = dc->funcs->pSetWorldTransform(dc->physDev, xform);
1175 if (!ret) goto done;
1178 dc->xformWorld2Wnd = *xform;
1179 DC_UpdateXforms( dc );
1180 ret = TRUE;
1181 done:
1182 GDI_ReleaseObj( hdc );
1183 return ret;
1187 /****************************************************************************
1188 * ModifyWorldTransform [GDI32.@]
1189 * Modifies the world transformation for a device context.
1191 * PARAMS
1192 * hdc [I] Handle to device context
1193 * xform [I] XFORM structure that will be used to modify the world
1194 * transformation
1195 * iMode [I] Specifies in what way to modify the world transformation
1196 * Possible values:
1197 * MWT_IDENTITY
1198 * Resets the world transformation to the identity matrix.
1199 * The parameter xform is ignored.
1200 * MWT_LEFTMULTIPLY
1201 * Multiplies xform into the world transformation matrix from
1202 * the left.
1203 * MWT_RIGHTMULTIPLY
1204 * Multiplies xform into the world transformation matrix from
1205 * the right.
1207 * RETURNS
1208 * Success: TRUE.
1209 * Failure: FALSE. Use GetLastError() to determine the cause.
1211 BOOL WINAPI ModifyWorldTransform( HDC hdc, const XFORM *xform,
1212 DWORD iMode )
1214 BOOL ret = FALSE;
1215 DC *dc = DC_GetDCPtr( hdc );
1217 /* Check for illegal parameters */
1218 if (!dc) return FALSE;
1219 if (!xform) goto done;
1221 /* Check that graphics mode is GM_ADVANCED */
1222 if (dc->GraphicsMode!=GM_ADVANCED) goto done;
1224 if (dc->funcs->pModifyWorldTransform)
1226 ret = dc->funcs->pModifyWorldTransform(dc->physDev, xform, iMode);
1227 if (!ret) goto done;
1230 switch (iMode)
1232 case MWT_IDENTITY:
1233 dc->xformWorld2Wnd.eM11 = 1.0f;
1234 dc->xformWorld2Wnd.eM12 = 0.0f;
1235 dc->xformWorld2Wnd.eM21 = 0.0f;
1236 dc->xformWorld2Wnd.eM22 = 1.0f;
1237 dc->xformWorld2Wnd.eDx = 0.0f;
1238 dc->xformWorld2Wnd.eDy = 0.0f;
1239 break;
1240 case MWT_LEFTMULTIPLY:
1241 CombineTransform( &dc->xformWorld2Wnd, xform,
1242 &dc->xformWorld2Wnd );
1243 break;
1244 case MWT_RIGHTMULTIPLY:
1245 CombineTransform( &dc->xformWorld2Wnd, &dc->xformWorld2Wnd,
1246 xform );
1247 break;
1248 default:
1249 goto done;
1252 DC_UpdateXforms( dc );
1253 ret = TRUE;
1254 done:
1255 GDI_ReleaseObj( hdc );
1256 return ret;
1260 /****************************************************************************
1261 * CombineTransform [GDI32.@]
1262 * Combines two transformation matrices.
1264 * PARAMS
1265 * xformResult [O] Stores the result of combining the two matrices
1266 * xform1 [I] Specifies the first matrix to apply
1267 * xform2 [I] Specifies the second matrix to apply
1269 * REMARKS
1270 * The same matrix can be passed in for more than one of the parameters.
1272 * RETURNS
1273 * Success: TRUE.
1274 * Failure: FALSE. Use GetLastError() to determine the cause.
1276 BOOL WINAPI CombineTransform( LPXFORM xformResult, const XFORM *xform1,
1277 const XFORM *xform2 )
1279 XFORM xformTemp;
1281 /* Check for illegal parameters */
1282 if (!xformResult || !xform1 || !xform2)
1283 return FALSE;
1285 /* Create the result in a temporary XFORM, since xformResult may be
1286 * equal to xform1 or xform2 */
1287 xformTemp.eM11 = xform1->eM11 * xform2->eM11 +
1288 xform1->eM12 * xform2->eM21;
1289 xformTemp.eM12 = xform1->eM11 * xform2->eM12 +
1290 xform1->eM12 * xform2->eM22;
1291 xformTemp.eM21 = xform1->eM21 * xform2->eM11 +
1292 xform1->eM22 * xform2->eM21;
1293 xformTemp.eM22 = xform1->eM21 * xform2->eM12 +
1294 xform1->eM22 * xform2->eM22;
1295 xformTemp.eDx = xform1->eDx * xform2->eM11 +
1296 xform1->eDy * xform2->eM21 +
1297 xform2->eDx;
1298 xformTemp.eDy = xform1->eDx * xform2->eM12 +
1299 xform1->eDy * xform2->eM22 +
1300 xform2->eDy;
1302 /* Copy the result to xformResult */
1303 *xformResult = xformTemp;
1305 return TRUE;
1309 /***********************************************************************
1310 * SetDCHook (GDI32.@)
1312 * Note: this doesn't exist in Win32, we add it here because user32 needs it.
1314 BOOL WINAPI SetDCHook( HDC hdc, DCHOOKPROC hookProc, DWORD dwHookData )
1316 DC *dc = GDI_GetObjPtr( hdc, DC_MAGIC );
1318 if (!dc) return FALSE;
1320 if (!(dc->flags & DC_SAVED))
1322 dc->dwHookData = dwHookData;
1323 dc->hookThunk = hookProc;
1325 GDI_ReleaseObj( hdc );
1326 return TRUE;
1330 /* relay function to call the 16-bit DC hook proc */
1331 static BOOL16 WINAPI call_dc_hook16( HDC16 hdc16, WORD code, DWORD data, LPARAM lParam )
1333 WORD args[6];
1334 DWORD ret;
1335 FARPROC16 proc = NULL;
1336 HDC hdc = HDC_32( hdc16 );
1337 DC *dc = DC_GetDCPtr( hdc );
1339 if (!dc) return FALSE;
1340 proc = dc->hookProc;
1341 GDI_ReleaseObj( hdc );
1342 if (!proc) return FALSE;
1343 args[5] = hdc16;
1344 args[4] = code;
1345 args[3] = HIWORD(data);
1346 args[2] = LOWORD(data);
1347 args[1] = HIWORD(lParam);
1348 args[0] = LOWORD(lParam);
1349 WOWCallback16Ex( (DWORD)proc, WCB16_PASCAL, sizeof(args), args, &ret );
1350 return LOWORD(ret);
1353 /***********************************************************************
1354 * SetDCHook (GDI.190)
1356 BOOL16 WINAPI SetDCHook16( HDC16 hdc16, FARPROC16 hookProc, DWORD dwHookData )
1358 HDC hdc = HDC_32( hdc16 );
1359 DC *dc = DC_GetDCPtr( hdc );
1360 if (!dc) return FALSE;
1362 dc->hookProc = hookProc;
1363 GDI_ReleaseObj( hdc );
1364 return SetDCHook( hdc, call_dc_hook16, dwHookData );
1368 /***********************************************************************
1369 * GetDCHook (GDI.191)
1371 DWORD WINAPI GetDCHook16( HDC16 hdc16, FARPROC16 *phookProc )
1373 HDC hdc = HDC_32( hdc16 );
1374 DC *dc = DC_GetDCPtr( hdc );
1375 DWORD ret;
1377 if (!dc) return 0;
1378 *phookProc = dc->hookProc;
1379 ret = dc->dwHookData;
1380 GDI_ReleaseObj( hdc );
1381 return ret;
1385 /***********************************************************************
1386 * SetHookFlags (GDI.192)
1388 WORD WINAPI SetHookFlags16(HDC16 hdc16, WORD flags)
1390 HDC hdc = HDC_32( hdc16 );
1391 DC *dc = DC_GetDCPtr( hdc );
1393 if( dc )
1395 WORD wRet = dc->flags & DC_DIRTY;
1397 /* "Undocumented Windows" info is slightly confusing.
1400 TRACE("hDC %p, flags %04x\n",hdc,flags);
1402 if( flags & DCHF_INVALIDATEVISRGN )
1403 dc->flags |= DC_DIRTY;
1404 else if( flags & DCHF_VALIDATEVISRGN || !flags )
1405 dc->flags &= ~DC_DIRTY;
1406 GDI_ReleaseObj( hdc );
1407 return wRet;
1409 return 0;
1412 /***********************************************************************
1413 * SetICMMode (GDI32.@)
1415 INT WINAPI SetICMMode(HDC hdc, INT iEnableICM)
1417 /*FIXME Asuming that ICM is always off, and cannot be turned on */
1418 if (iEnableICM == ICM_OFF) return ICM_OFF;
1419 if (iEnableICM == ICM_ON) return 0;
1420 if (iEnableICM == ICM_QUERY) return ICM_OFF;
1421 return 0;
1424 /***********************************************************************
1425 * GetDeviceGammaRamp (GDI32.@)
1427 BOOL WINAPI GetDeviceGammaRamp(HDC hDC, LPVOID ptr)
1429 BOOL ret = FALSE;
1430 DC *dc = DC_GetDCPtr( hDC );
1432 if( dc )
1434 if (dc->funcs->pGetDeviceGammaRamp)
1435 ret = dc->funcs->pGetDeviceGammaRamp(dc->physDev, ptr);
1436 GDI_ReleaseObj( hDC );
1438 return ret;
1441 /***********************************************************************
1442 * SetDeviceGammaRamp (GDI32.@)
1444 BOOL WINAPI SetDeviceGammaRamp(HDC hDC, LPVOID ptr)
1446 BOOL ret = FALSE;
1447 DC *dc = DC_GetDCPtr( hDC );
1449 if( dc )
1451 if (dc->funcs->pSetDeviceGammaRamp)
1452 ret = dc->funcs->pSetDeviceGammaRamp(dc->physDev, ptr);
1453 GDI_ReleaseObj( hDC );
1455 return ret;
1458 /***********************************************************************
1459 * GetColorSpace (GDI32.@)
1461 HCOLORSPACE WINAPI GetColorSpace(HDC hdc)
1463 /*FIXME Need to to whatever GetColorSpace actually does */
1464 return 0;
1467 /***********************************************************************
1468 * CreateColorSpaceA (GDI32.@)
1470 HCOLORSPACE WINAPI CreateColorSpaceA( LPLOGCOLORSPACEA lpLogColorSpace )
1472 FIXME( "stub\n" );
1473 return 0;
1476 /***********************************************************************
1477 * CreateColorSpaceW (GDI32.@)
1479 HCOLORSPACE WINAPI CreateColorSpaceW( LPLOGCOLORSPACEW lpLogColorSpace )
1481 FIXME( "stub\n" );
1482 return 0;
1485 /***********************************************************************
1486 * DeleteColorSpace (GDI32.@)
1488 BOOL WINAPI DeleteColorSpace( HCOLORSPACE hColorSpace )
1490 FIXME( "stub\n" );
1492 return TRUE;
1495 /***********************************************************************
1496 * SetColorSpace (GDI32.@)
1498 HCOLORSPACE WINAPI SetColorSpace( HDC hDC, HCOLORSPACE hColorSpace )
1500 FIXME( "stub\n" );
1502 return hColorSpace;
1505 /***********************************************************************
1506 * GetBoundsRect (GDI32.@)
1508 UINT WINAPI GetBoundsRect(HDC hdc, LPRECT rect, UINT flags)
1510 UINT ret;
1511 DC *dc = DC_GetDCPtr( hdc );
1513 if ( !dc ) return 0;
1515 if (rect) *rect = dc->BoundsRect;
1517 ret = ((dc->flags & DC_BOUNDS_SET) ? DCB_SET : DCB_RESET);
1519 if (flags & DCB_RESET)
1521 dc->BoundsRect.left = 0;
1522 dc->BoundsRect.top = 0;
1523 dc->BoundsRect.right = 0;
1524 dc->BoundsRect.bottom = 0;
1525 dc->flags &= ~DC_BOUNDS_SET;
1527 GDI_ReleaseObj( hdc );
1528 return ret;
1532 /***********************************************************************
1533 * SetBoundsRect (GDI32.@)
1535 UINT WINAPI SetBoundsRect(HDC hdc, const RECT* rect, UINT flags)
1537 UINT ret;
1538 DC *dc;
1540 if ((flags & DCB_ENABLE) && (flags & DCB_DISABLE)) return 0;
1541 if (!(dc = DC_GetDCPtr( hdc ))) return 0;
1543 ret = ((dc->flags & DC_BOUNDS_ENABLE) ? DCB_ENABLE : DCB_DISABLE) |
1544 ((dc->flags & DC_BOUNDS_SET) ? DCB_SET : DCB_RESET);
1546 if (flags & DCB_RESET)
1548 dc->BoundsRect.left = 0;
1549 dc->BoundsRect.top = 0;
1550 dc->BoundsRect.right = 0;
1551 dc->BoundsRect.bottom = 0;
1552 dc->flags &= ~DC_BOUNDS_SET;
1555 if ((flags & DCB_ACCUMULATE) && rect && rect->left < rect->right && rect->top < rect->bottom)
1557 if (dc->flags & DC_BOUNDS_SET)
1559 dc->BoundsRect.left = min( dc->BoundsRect.left, rect->left );
1560 dc->BoundsRect.top = min( dc->BoundsRect.top, rect->top );
1561 dc->BoundsRect.right = max( dc->BoundsRect.right, rect->right );
1562 dc->BoundsRect.bottom = max( dc->BoundsRect.bottom, rect->bottom );
1564 else
1566 dc->BoundsRect = *rect;
1567 dc->flags |= DC_BOUNDS_SET;
1571 if (flags & DCB_ENABLE) dc->flags |= DC_BOUNDS_ENABLE;
1572 if (flags & DCB_DISABLE) dc->flags &= ~DC_BOUNDS_ENABLE;
1574 GDI_ReleaseObj( hdc );
1575 return ret;
1579 /***********************************************************************
1580 * GetRelAbs (GDI32.@)
1582 INT WINAPI GetRelAbs( HDC hdc, DWORD dwIgnore )
1584 INT ret = 0;
1585 DC *dc = DC_GetDCPtr( hdc );
1586 if (dc) ret = dc->relAbsMode;
1587 GDI_ReleaseObj( hdc );
1588 return ret;
1594 /***********************************************************************
1595 * GetBkMode (GDI32.@)
1597 INT WINAPI GetBkMode( HDC hdc )
1599 INT ret = 0;
1600 DC * dc = DC_GetDCPtr( hdc );
1601 if (dc)
1603 ret = dc->backgroundMode;
1604 GDI_ReleaseObj( hdc );
1606 return ret;
1610 /***********************************************************************
1611 * SetBkMode (GDI32.@)
1613 INT WINAPI SetBkMode( HDC hdc, INT mode )
1615 INT ret;
1616 DC *dc;
1617 if ((mode <= 0) || (mode > BKMODE_LAST))
1619 SetLastError(ERROR_INVALID_PARAMETER);
1620 return 0;
1622 if (!(dc = DC_GetDCPtr( hdc ))) return 0;
1623 if (dc->funcs->pSetBkMode)
1624 ret = dc->funcs->pSetBkMode( dc->physDev, mode );
1625 else
1627 ret = dc->backgroundMode;
1628 dc->backgroundMode = mode;
1630 GDI_ReleaseObj( hdc );
1631 return ret;
1635 /***********************************************************************
1636 * GetROP2 (GDI32.@)
1638 INT WINAPI GetROP2( HDC hdc )
1640 INT ret = 0;
1641 DC * dc = DC_GetDCPtr( hdc );
1642 if (dc)
1644 ret = dc->ROPmode;
1645 GDI_ReleaseObj( hdc );
1647 return ret;
1651 /***********************************************************************
1652 * SetROP2 (GDI32.@)
1654 INT WINAPI SetROP2( HDC hdc, INT mode )
1656 INT ret;
1657 DC *dc;
1658 if ((mode < R2_BLACK) || (mode > R2_WHITE))
1660 SetLastError(ERROR_INVALID_PARAMETER);
1661 return 0;
1663 if (!(dc = DC_GetDCPtr( hdc ))) return 0;
1664 if (dc->funcs->pSetROP2)
1665 ret = dc->funcs->pSetROP2( dc->physDev, mode );
1666 else
1668 ret = dc->ROPmode;
1669 dc->ROPmode = mode;
1671 GDI_ReleaseObj( hdc );
1672 return ret;
1676 /***********************************************************************
1677 * SetRelAbs (GDI32.@)
1679 INT WINAPI SetRelAbs( HDC hdc, INT mode )
1681 INT ret;
1682 DC *dc;
1683 if ((mode != ABSOLUTE) && (mode != RELATIVE))
1685 SetLastError(ERROR_INVALID_PARAMETER);
1686 return 0;
1688 if (!(dc = DC_GetDCPtr( hdc ))) return 0;
1689 if (dc->funcs->pSetRelAbs)
1690 ret = dc->funcs->pSetRelAbs( dc->physDev, mode );
1691 else
1693 ret = dc->relAbsMode;
1694 dc->relAbsMode = mode;
1696 GDI_ReleaseObj( hdc );
1697 return ret;
1701 /***********************************************************************
1702 * GetPolyFillMode (GDI32.@)
1704 INT WINAPI GetPolyFillMode( HDC hdc )
1706 INT ret = 0;
1707 DC * dc = DC_GetDCPtr( hdc );
1708 if (dc)
1710 ret = dc->polyFillMode;
1711 GDI_ReleaseObj( hdc );
1713 return ret;
1717 /***********************************************************************
1718 * SetPolyFillMode (GDI32.@)
1720 INT WINAPI SetPolyFillMode( HDC hdc, INT mode )
1722 INT ret;
1723 DC *dc;
1724 if ((mode <= 0) || (mode > POLYFILL_LAST))
1726 SetLastError(ERROR_INVALID_PARAMETER);
1727 return 0;
1729 if (!(dc = DC_GetDCPtr( hdc ))) return 0;
1730 if (dc->funcs->pSetPolyFillMode)
1731 ret = dc->funcs->pSetPolyFillMode( dc->physDev, mode );
1732 else
1734 ret = dc->polyFillMode;
1735 dc->polyFillMode = mode;
1737 GDI_ReleaseObj( hdc );
1738 return ret;
1742 /***********************************************************************
1743 * GetStretchBltMode (GDI32.@)
1745 INT WINAPI GetStretchBltMode( HDC hdc )
1747 INT ret = 0;
1748 DC * dc = DC_GetDCPtr( hdc );
1749 if (dc)
1751 ret = dc->stretchBltMode;
1752 GDI_ReleaseObj( hdc );
1754 return ret;
1758 /***********************************************************************
1759 * SetStretchBltMode (GDI32.@)
1761 INT WINAPI SetStretchBltMode( HDC hdc, INT mode )
1763 INT ret;
1764 DC *dc;
1765 if ((mode <= 0) || (mode > MAXSTRETCHBLTMODE))
1767 SetLastError(ERROR_INVALID_PARAMETER);
1768 return 0;
1770 if (!(dc = DC_GetDCPtr( hdc ))) return 0;
1771 if (dc->funcs->pSetStretchBltMode)
1772 ret = dc->funcs->pSetStretchBltMode( dc->physDev, mode );
1773 else
1775 ret = dc->stretchBltMode;
1776 dc->stretchBltMode = mode;
1778 GDI_ReleaseObj( hdc );
1779 return ret;
1783 /***********************************************************************
1784 * GetMapMode (GDI32.@)
1786 INT WINAPI GetMapMode( HDC hdc )
1788 INT ret = 0;
1789 DC * dc = DC_GetDCPtr( hdc );
1790 if (dc)
1792 ret = dc->MapMode;
1793 GDI_ReleaseObj( hdc );
1795 return ret;
1799 /***********************************************************************
1800 * GetBrushOrgEx (GDI32.@)
1802 BOOL WINAPI GetBrushOrgEx( HDC hdc, LPPOINT pt )
1804 DC * dc = DC_GetDCPtr( hdc );
1805 if (!dc) return FALSE;
1806 pt->x = dc->brushOrgX;
1807 pt->y = dc->brushOrgY;
1808 GDI_ReleaseObj( hdc );
1809 return TRUE;
1813 /***********************************************************************
1814 * GetCurrentPositionEx (GDI32.@)
1816 BOOL WINAPI GetCurrentPositionEx( HDC hdc, LPPOINT pt )
1818 DC * dc = DC_GetDCPtr( hdc );
1819 if (!dc) return FALSE;
1820 pt->x = dc->CursPosX;
1821 pt->y = dc->CursPosY;
1822 GDI_ReleaseObj( hdc );
1823 return TRUE;
1827 /***********************************************************************
1828 * GetViewportExtEx (GDI32.@)
1830 BOOL WINAPI GetViewportExtEx( HDC hdc, LPSIZE size )
1832 DC * dc = DC_GetDCPtr( hdc );
1833 if (!dc) return FALSE;
1834 size->cx = dc->vportExtX;
1835 size->cy = dc->vportExtY;
1836 GDI_ReleaseObj( hdc );
1837 return TRUE;
1841 /***********************************************************************
1842 * GetViewportOrgEx (GDI32.@)
1844 BOOL WINAPI GetViewportOrgEx( HDC hdc, LPPOINT pt )
1846 DC * dc = DC_GetDCPtr( hdc );
1847 if (!dc) return FALSE;
1848 pt->x = dc->vportOrgX;
1849 pt->y = dc->vportOrgY;
1850 GDI_ReleaseObj( hdc );
1851 return TRUE;
1855 /***********************************************************************
1856 * GetWindowExtEx (GDI32.@)
1858 BOOL WINAPI GetWindowExtEx( HDC hdc, LPSIZE size )
1860 DC * dc = DC_GetDCPtr( hdc );
1861 if (!dc) return FALSE;
1862 size->cx = dc->wndExtX;
1863 size->cy = dc->wndExtY;
1864 GDI_ReleaseObj( hdc );
1865 return TRUE;
1869 /***********************************************************************
1870 * GetWindowOrgEx (GDI32.@)
1872 BOOL WINAPI GetWindowOrgEx( HDC hdc, LPPOINT pt )
1874 DC * dc = DC_GetDCPtr( hdc );
1875 if (!dc) return FALSE;
1876 pt->x = dc->wndOrgX;
1877 pt->y = dc->wndOrgY;
1878 GDI_ReleaseObj( hdc );
1879 return TRUE;
1883 /***********************************************************************
1884 * InquireVisRgn (GDI.131)
1886 HRGN16 WINAPI InquireVisRgn16( HDC16 hdc )
1888 HRGN16 ret = 0;
1889 DC * dc = DC_GetDCPtr( HDC_32(hdc) );
1890 if (dc)
1892 ret = HRGN_16(dc->hVisRgn);
1893 GDI_ReleaseObj( HDC_32(hdc) );
1895 return ret;
1899 /***********************************************************************
1900 * GetClipRgn (GDI.173)
1902 HRGN16 WINAPI GetClipRgn16( HDC16 hdc )
1904 HRGN16 ret = 0;
1905 DC * dc = DC_GetDCPtr( HDC_32(hdc) );
1906 if (dc)
1908 ret = HRGN_16(dc->hClipRgn);
1909 GDI_ReleaseObj( HDC_32(hdc) );
1911 return ret;
1915 /***********************************************************************
1916 * GetLayout (GDI32.@)
1918 * Gets left->right or right->left text layout flags of a dc.
1921 DWORD WINAPI GetLayout(HDC hdc)
1923 DWORD layout = GDI_ERROR;
1925 DC * dc = DC_GetDCPtr( hdc );
1926 if (dc)
1928 layout = dc->layout;
1929 GDI_ReleaseObj( hdc );
1932 TRACE("hdc : %p, layout : %08lx\n", hdc, layout);
1934 return layout;
1937 /***********************************************************************
1938 * SetLayout (GDI32.@)
1940 * Sets left->right or right->left text layout flags of a dc.
1943 DWORD WINAPI SetLayout(HDC hdc, DWORD layout)
1945 DWORD oldlayout = GDI_ERROR;
1947 DC * dc = DC_GetDCPtr( hdc );
1948 if (dc)
1950 oldlayout = dc->layout;
1951 dc->layout = layout;
1952 GDI_ReleaseObj( hdc );
1955 TRACE("hdc : %p, old layout : %08lx, new layout : %08lx\n", hdc, oldlayout, layout);
1957 return oldlayout;
1960 /***********************************************************************
1961 * GetDCBrushColor (GDI32.@)
1963 * Retrieves the current brush color for the specified device
1964 * context (DC).
1967 COLORREF WINAPI GetDCBrushColor(HDC hdc)
1969 DC *dc;
1970 COLORREF dcBrushColor = CLR_INVALID;
1972 TRACE("hdc(%p)\n", hdc);
1974 dc = DC_GetDCPtr( hdc );
1975 if (dc)
1977 dcBrushColor = dc->dcBrushColor;
1978 GDI_ReleaseObj( hdc );
1981 return dcBrushColor;
1984 /***********************************************************************
1985 * SetDCBrushColor (GDI32.@)
1987 * Sets the current device context (DC) brush color to the specified
1988 * color value. If the device cannot represent the specified color
1989 * value, the color is set to the nearest physical color.
1992 COLORREF WINAPI SetDCBrushColor(HDC hdc, COLORREF crColor)
1994 DC *dc;
1995 COLORREF oldClr = CLR_INVALID;
1997 TRACE("hdc(%p) crColor(%08lx)\n", hdc, crColor);
1999 dc = DC_GetDCPtr( hdc );
2000 if (dc)
2002 if (dc->funcs->pSetDCBrushColor)
2003 crColor = dc->funcs->pSetDCBrushColor( dc->physDev, crColor );
2004 else if (dc->hBrush == GetStockObject( DC_BRUSH ))
2006 /* If DC_BRUSH is selected, update driver pen color */
2007 HBRUSH hBrush = CreateSolidBrush( crColor );
2008 dc->funcs->pSelectBrush( dc->physDev, hBrush );
2009 DeleteObject( hBrush );
2012 if (crColor != CLR_INVALID)
2014 oldClr = dc->dcBrushColor;
2015 dc->dcBrushColor = crColor;
2018 GDI_ReleaseObj( hdc );
2021 return oldClr;
2024 /***********************************************************************
2025 * GetDCPenColor (GDI32.@)
2027 * Retrieves the current pen color for the specified device
2028 * context (DC).
2031 COLORREF WINAPI GetDCPenColor(HDC hdc)
2033 DC *dc;
2034 COLORREF dcPenColor = CLR_INVALID;
2036 TRACE("hdc(%p)\n", hdc);
2038 dc = DC_GetDCPtr( hdc );
2039 if (dc)
2041 dcPenColor = dc->dcPenColor;
2042 GDI_ReleaseObj( hdc );
2045 return dcPenColor;
2048 /***********************************************************************
2049 * SetDCPenColor (GDI32.@)
2051 * Sets the current device context (DC) pen color to the specified
2052 * color value. If the device cannot represent the specified color
2053 * value, the color is set to the nearest physical color.
2056 COLORREF WINAPI SetDCPenColor(HDC hdc, COLORREF crColor)
2058 DC *dc;
2059 COLORREF oldClr = CLR_INVALID;
2061 TRACE("hdc(%p) crColor(%08lx)\n", hdc, crColor);
2063 dc = DC_GetDCPtr( hdc );
2064 if (dc)
2066 if (dc->funcs->pSetDCPenColor)
2067 crColor = dc->funcs->pSetDCPenColor( dc->physDev, crColor );
2068 else if (dc->hPen == GetStockObject( DC_PEN ))
2070 /* If DC_PEN is selected, update the driver pen color */
2071 LOGPEN logpen = { PS_SOLID, { 0, 0 }, crColor };
2072 HPEN hPen = CreatePenIndirect( &logpen );
2073 dc->funcs->pSelectPen( dc->physDev, hPen );
2074 DeleteObject( hPen );
2077 if (crColor != CLR_INVALID)
2079 oldClr = dc->dcPenColor;
2080 dc->dcPenColor = crColor;
2083 GDI_ReleaseObj( hdc );
2086 return oldClr;
2089 /***********************************************************************
2090 * SetVirtualResolution (GDI32.@)
2092 * Undocumented on msdn. Called when PowerPoint XP saves a file.
2094 DWORD WINAPI SetVirtualResolution(HDC hdc, DWORD dw2, DWORD dw3, DWORD dw4, DWORD dw5)
2096 FIXME("(%p %08lx %08lx %08lx %08lx): stub!\n", hdc, dw2, dw3, dw4, dw5);
2097 return FALSE;
2100 /*******************************************************************
2101 * GetMiterLimit [GDI32.@]
2105 BOOL WINAPI GetMiterLimit(HDC hdc, PFLOAT peLimit)
2107 BOOL bRet = FALSE;
2108 DC *dc;
2110 TRACE("(%p,%p)\n", hdc, peLimit);
2112 dc = DC_GetDCPtr( hdc );
2113 if (dc)
2115 if (peLimit)
2116 *peLimit = dc->miterLimit;
2118 GDI_ReleaseObj( hdc );
2119 bRet = TRUE;
2121 return bRet;
2124 /*******************************************************************
2125 * SetMiterLimit [GDI32.@]
2129 BOOL WINAPI SetMiterLimit(HDC hdc, FLOAT eNewLimit, PFLOAT peOldLimit)
2131 BOOL bRet = FALSE;
2132 DC *dc;
2134 TRACE("(%p,%f,%p)\n", hdc, eNewLimit, peOldLimit);
2136 dc = DC_GetDCPtr( hdc );
2137 if (dc)
2139 if (peOldLimit)
2140 *peOldLimit = dc->miterLimit;
2141 dc->miterLimit = eNewLimit;
2142 GDI_ReleaseObj( hdc );
2143 bRet = TRUE;
2145 return bRet;
2148 /*******************************************************************
2149 * GdiIsMetaPrintDC [GDI32.@]
2151 BOOL WINAPI GdiIsMetaPrintDC(HDC hdc)
2153 FIXME("%p\n", hdc);
2154 return FALSE;
2157 /*******************************************************************
2158 * GdiIsMetaFileDC [GDI32.@]
2160 BOOL WINAPI GdiIsMetaFileDC(HDC hdc)
2162 TRACE("%p\n", hdc);
2164 switch( GetObjectType( hdc ) )
2166 case OBJ_METADC:
2167 case OBJ_ENHMETADC:
2168 return TRUE;
2170 return FALSE;
2173 /*******************************************************************
2174 * GdiIsPlayMetafileDC [GDI32.@]
2176 BOOL WINAPI GdiIsPlayMetafileDC(HDC hdc)
2178 FIXME("%p\n", hdc);
2179 return FALSE;