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_GetDCUpdate( 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 = GDI_GetObjPtr( hdc, DC_MAGIC ))) 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_GetDCUpdate( 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_GetDCPtr( 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 );
610 GDI_ReleaseObj( hdc );
615 /***********************************************************************
616 * CreateDCW (GDI32.@)
618 HDC WINAPI CreateDCW( LPCWSTR driver, LPCWSTR device, LPCWSTR output,
619 const DEVMODEW *initData )
621 LPSTR driverA = HEAP_strdupWtoA( GetProcessHeap(), 0, driver );
622 LPSTR deviceA = HEAP_strdupWtoA( GetProcessHeap(), 0, device );
623 LPSTR outputA = HEAP_strdupWtoA( GetProcessHeap(), 0, output );
624 HDC res = CreateDCA( driverA, deviceA, outputA,
625 (const DEVMODEA *)initData /*FIXME*/ );
626 HeapFree( GetProcessHeap(), 0, driverA );
627 HeapFree( GetProcessHeap(), 0, deviceA );
628 HeapFree( GetProcessHeap(), 0, outputA );
633 /***********************************************************************
636 HDC16 WINAPI CreateIC16( LPCSTR driver, LPCSTR device, LPCSTR output,
637 const DEVMODEA* initData )
639 /* Nothing special yet for ICs */
640 return CreateDC16( driver, device, output, initData );
644 /***********************************************************************
645 * CreateICA (GDI32.@)
647 HDC WINAPI CreateICA( LPCSTR driver, LPCSTR device, LPCSTR output,
648 const DEVMODEA* initData )
650 /* Nothing special yet for ICs */
651 return CreateDCA( driver, device, output, initData );
655 /***********************************************************************
656 * CreateICW (GDI32.@)
658 HDC WINAPI CreateICW( LPCWSTR driver, LPCWSTR device, LPCWSTR output,
659 const DEVMODEW* initData )
661 /* Nothing special yet for ICs */
662 return CreateDCW( driver, device, output, initData );
666 /***********************************************************************
667 * CreateCompatibleDC (GDI.52)
669 HDC16 WINAPI CreateCompatibleDC16( HDC16 hdc )
671 return (HDC16)CreateCompatibleDC( hdc );
675 /***********************************************************************
676 * CreateCompatibleDC (GDI32.@)
678 HDC WINAPI CreateCompatibleDC( HDC hdc )
681 const DC_FUNCTIONS *funcs;
685 if ((origDC = GDI_GetObjPtr( hdc, DC_MAGIC )))
687 funcs = origDC->funcs;
688 GDI_ReleaseObj( hdc ); /* can't hold the lock while loading the driver */
689 funcs = DRIVER_get_driver( funcs );
691 else funcs = DRIVER_load_driver( "DISPLAY" );
693 if (!funcs) return 0;
695 if (!(dc = DC_AllocDC( funcs )))
697 DRIVER_release_driver( funcs );
701 TRACE("(%04x): returning %04x\n",
704 dc->flags = DC_MEMORY;
705 dc->bitsPerPixel = 1;
706 dc->hBitmap = GetStockObject( DEFAULT_BITMAP );
708 /* Copy the driver-specific physical device info into
709 * the new DC. The driver may use this read-only info
710 * while creating the compatible DC below. */
711 if ((origDC = GDI_GetObjPtr( hdc, DC_MAGIC ))) dc->physDev = origDC->physDev;
713 if (dc->funcs->pCreateDC &&
714 !dc->funcs->pCreateDC( dc, NULL, NULL, NULL, NULL ))
716 WARN("creation aborted by device\n");
717 GDI_FreeObject( dc->hSelf, dc );
718 if (origDC) GDI_ReleaseObj( hdc );
719 DRIVER_release_driver( funcs );
724 GDI_ReleaseObj( dc->hSelf );
725 if (origDC) GDI_ReleaseObj( hdc );
730 /***********************************************************************
733 BOOL16 WINAPI DeleteDC16( HDC16 hdc )
735 return DeleteDC( hdc );
739 /***********************************************************************
742 BOOL WINAPI DeleteDC( HDC hdc )
744 const DC_FUNCTIONS *funcs = NULL;
747 TRACE("%04x\n", hdc );
751 if (!(dc = GDI_GetObjPtr( hdc, DC_MAGIC ))) return FALSE;
753 /* Call hook procedure to check whether is it OK to delete this DC */
754 if (dc->hookThunk && !(dc->flags & (DC_SAVED | DC_MEMORY)))
756 DCHOOKPROC proc = dc->hookThunk;
759 DWORD data = dc->dwHookData;
760 GDI_ReleaseObj( hdc );
761 if (!proc( hdc, DCHC_DELETEDC, data, 0 )) return FALSE;
762 if (!(dc = DC_GetDCPtr( hdc ))) return TRUE; /* deleted by the hook */
766 while (dc->saveLevel)
769 HDC16 hdcs = dc->header.hNext;
770 if (!(dcs = GDI_GetObjPtr( hdcs, DC_MAGIC ))) break;
771 dc->header.hNext = dcs->header.hNext;
773 GDI_ReleaseObj( hdcs );
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);
787 if (dc->hClipRgn) DeleteObject( dc->hClipRgn );
788 if (dc->hVisRgn) DeleteObject( dc->hVisRgn );
789 if (dc->hGCClipRgn) DeleteObject( dc->hGCClipRgn );
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 HDC16 WINAPI ResetDC16( HDC16 hdc, const DEVMODEA *devmode )
808 /***********************************************************************
811 HDC WINAPI ResetDCA( HDC hdc, const DEVMODEA *devmode )
818 /***********************************************************************
821 HDC WINAPI ResetDCW( HDC hdc, const DEVMODEW *devmode )
828 /***********************************************************************
829 * GetDeviceCaps (GDI.80)
831 INT16 WINAPI GetDeviceCaps16( HDC16 hdc, INT16 cap )
833 INT16 ret = GetDeviceCaps( hdc, cap );
834 /* some apps don't expect -1 and think it's a B&W screen */
835 if ((cap == NUMCOLORS) && (ret == -1)) ret = 2048;
840 /***********************************************************************
841 * GetDeviceCaps (GDI32.@)
843 INT WINAPI GetDeviceCaps( HDC hdc, INT cap )
848 if ((dc = DC_GetDCPtr( hdc )))
850 if (dc->funcs->pGetDeviceCaps) ret = dc->funcs->pGetDeviceCaps( dc->physDev, cap );
851 GDI_ReleaseObj( hdc );
857 /***********************************************************************
860 COLORREF WINAPI SetBkColor16( HDC16 hdc, COLORREF color )
862 return SetBkColor( hdc, color );
866 /***********************************************************************
867 * SetBkColor (GDI32.@)
869 COLORREF WINAPI SetBkColor( HDC hdc, COLORREF color )
872 DC * dc = DC_GetDCPtr( hdc );
874 if (!dc) return CLR_INVALID;
875 oldColor = dc->backgroundColor;
876 if (dc->funcs->pSetBkColor)
878 color = dc->funcs->pSetBkColor(dc->physDev, color);
879 if (color == CLR_INVALID) /* don't change it */
882 oldColor = CLR_INVALID;
885 dc->backgroundColor = color;
886 GDI_ReleaseObj( hdc );
891 /***********************************************************************
892 * SetTextColor (GDI.9)
894 COLORREF WINAPI SetTextColor16( HDC16 hdc, COLORREF color )
896 return SetTextColor( hdc, color );
900 /***********************************************************************
901 * SetTextColor (GDI32.@)
903 COLORREF WINAPI SetTextColor( HDC hdc, COLORREF color )
906 DC * dc = DC_GetDCPtr( hdc );
908 if (!dc) return CLR_INVALID;
909 oldColor = dc->textColor;
910 if (dc->funcs->pSetTextColor)
912 color = dc->funcs->pSetTextColor(dc->physDev, color);
913 if (color == CLR_INVALID) /* don't change it */
916 oldColor = CLR_INVALID;
919 dc->textColor = color;
920 GDI_ReleaseObj( hdc );
924 /***********************************************************************
925 * SetTextAlign (GDI.346)
927 UINT16 WINAPI SetTextAlign16( HDC16 hdc, UINT16 align )
929 return SetTextAlign( hdc, align );
933 /***********************************************************************
934 * SetTextAlign (GDI32.@)
936 UINT WINAPI SetTextAlign( HDC hdc, UINT align )
939 DC *dc = DC_GetDCPtr( hdc );
941 if (dc->funcs->pSetTextAlign)
942 prevAlign = dc->funcs->pSetTextAlign(dc->physDev, align);
944 prevAlign = dc->textAlign;
945 dc->textAlign = align;
947 GDI_ReleaseObj( hdc );
951 /***********************************************************************
952 * GetDCOrgEx (GDI32.@)
954 BOOL WINAPI GetDCOrgEx( HDC hDC, LPPOINT lpp )
958 if (!lpp) return FALSE;
959 if (!(dc = DC_GetDCPtr( hDC ))) return FALSE;
962 if (dc->funcs->pGetDCOrgEx) dc->funcs->pGetDCOrgEx( dc->physDev, lpp );
963 lpp->x += dc->DCOrgX;
964 lpp->y += dc->DCOrgY;
965 GDI_ReleaseObj( hDC );
970 /***********************************************************************
973 DWORD WINAPI GetDCOrg16( HDC16 hdc )
976 if( GetDCOrgEx( hdc, &pt) )
977 return MAKELONG( (WORD)pt.x, (WORD)pt.y );
982 /***********************************************************************
985 DWORD WINAPI SetDCOrg16( HDC16 hdc, INT16 x, INT16 y )
988 DC *dc = DC_GetDCPtr( hdc );
990 prevOrg = dc->DCOrgX | (dc->DCOrgY << 16);
993 GDI_ReleaseObj( hdc );
998 /***********************************************************************
999 * SetGraphicsMode (GDI32.@)
1001 INT WINAPI SetGraphicsMode( HDC hdc, INT mode )
1004 DC *dc = DC_GetDCPtr( hdc );
1006 /* One would think that setting the graphics mode to GM_COMPATIBLE
1007 * would also reset the world transformation matrix to the unity
1008 * matrix. However, in Windows, this is not the case. This doesn't
1009 * make a lot of sense to me, but that's the way it is.
1012 if ((mode > 0) || (mode <= GM_LAST))
1014 ret = dc->GraphicsMode;
1015 dc->GraphicsMode = mode;
1017 GDI_ReleaseObj( hdc );
1022 /***********************************************************************
1023 * SetArcDirection (GDI.525)
1025 INT16 WINAPI SetArcDirection16( HDC16 hdc, INT16 nDirection )
1027 return SetArcDirection( (HDC)hdc, (INT)nDirection );
1031 /***********************************************************************
1032 * SetArcDirection (GDI32.@)
1034 INT WINAPI SetArcDirection( HDC hdc, INT nDirection )
1037 INT nOldDirection = 0;
1039 if (nDirection!=AD_COUNTERCLOCKWISE && nDirection!=AD_CLOCKWISE)
1041 SetLastError(ERROR_INVALID_PARAMETER);
1045 if ((dc = DC_GetDCPtr( hdc )))
1047 nOldDirection = dc->ArcDirection;
1048 dc->ArcDirection = nDirection;
1049 GDI_ReleaseObj( hdc );
1051 return nOldDirection;
1055 /***********************************************************************
1056 * GetWorldTransform (GDI32.@)
1058 BOOL WINAPI GetWorldTransform( HDC hdc, LPXFORM xform )
1061 if (!xform) return FALSE;
1062 if (!(dc = DC_GetDCPtr( hdc ))) return FALSE;
1063 *xform = dc->xformWorld2Wnd;
1064 GDI_ReleaseObj( hdc );
1069 /***********************************************************************
1070 * SetWorldTransform (GDI32.@)
1072 BOOL WINAPI SetWorldTransform( HDC hdc, const XFORM *xform )
1075 DC *dc = DC_GetDCPtr( hdc );
1077 if (!dc) return FALSE;
1078 if (!xform) goto done;
1080 /* Check that graphics mode is GM_ADVANCED */
1081 if (dc->GraphicsMode!=GM_ADVANCED) goto done;
1083 dc->xformWorld2Wnd = *xform;
1084 DC_UpdateXforms( dc );
1087 GDI_ReleaseObj( hdc );
1092 /****************************************************************************
1093 * ModifyWorldTransform [GDI32.@]
1094 * Modifies the world transformation for a device context.
1097 * hdc [I] Handle to device context
1098 * xform [I] XFORM structure that will be used to modify the world
1100 * iMode [I] Specifies in what way to modify the world transformation
1103 * Resets the world transformation to the identity matrix.
1104 * The parameter xform is ignored.
1106 * Multiplies xform into the world transformation matrix from
1109 * Multiplies xform into the world transformation matrix from
1114 BOOL WINAPI ModifyWorldTransform( HDC hdc, const XFORM *xform,
1118 DC *dc = DC_GetDCPtr( hdc );
1120 /* Check for illegal parameters */
1121 if (!dc) return FALSE;
1122 if (!xform) goto done;
1124 /* Check that graphics mode is GM_ADVANCED */
1125 if (dc->GraphicsMode!=GM_ADVANCED) goto done;
1130 dc->xformWorld2Wnd.eM11 = 1.0f;
1131 dc->xformWorld2Wnd.eM12 = 0.0f;
1132 dc->xformWorld2Wnd.eM21 = 0.0f;
1133 dc->xformWorld2Wnd.eM22 = 1.0f;
1134 dc->xformWorld2Wnd.eDx = 0.0f;
1135 dc->xformWorld2Wnd.eDy = 0.0f;
1137 case MWT_LEFTMULTIPLY:
1138 CombineTransform( &dc->xformWorld2Wnd, xform,
1139 &dc->xformWorld2Wnd );
1141 case MWT_RIGHTMULTIPLY:
1142 CombineTransform( &dc->xformWorld2Wnd, &dc->xformWorld2Wnd,
1149 DC_UpdateXforms( dc );
1152 GDI_ReleaseObj( hdc );
1157 /****************************************************************************
1158 * CombineTransform [GDI32.@]
1159 * Combines two transformation matrices.
1162 * xformResult [O] Stores the result of combining the two matrices
1163 * xform1 [I] Specifies the first matrix to apply
1164 * xform2 [I] Specifies the second matrix to apply
1167 * The same matrix can be passed in for more than one of the parameters.
1171 BOOL WINAPI CombineTransform( LPXFORM xformResult, const XFORM *xform1,
1172 const XFORM *xform2 )
1176 /* Check for illegal parameters */
1177 if (!xformResult || !xform1 || !xform2)
1180 /* Create the result in a temporary XFORM, since xformResult may be
1181 * equal to xform1 or xform2 */
1182 xformTemp.eM11 = xform1->eM11 * xform2->eM11 +
1183 xform1->eM12 * xform2->eM21;
1184 xformTemp.eM12 = xform1->eM11 * xform2->eM12 +
1185 xform1->eM12 * xform2->eM22;
1186 xformTemp.eM21 = xform1->eM21 * xform2->eM11 +
1187 xform1->eM22 * xform2->eM21;
1188 xformTemp.eM22 = xform1->eM21 * xform2->eM12 +
1189 xform1->eM22 * xform2->eM22;
1190 xformTemp.eDx = xform1->eDx * xform2->eM11 +
1191 xform1->eDy * xform2->eM21 +
1193 xformTemp.eDy = xform1->eDx * xform2->eM12 +
1194 xform1->eDy * xform2->eM22 +
1197 /* Copy the result to xformResult */
1198 *xformResult = xformTemp;
1204 /***********************************************************************
1205 * SetDCHook (GDI32.@)
1207 * Note: this doesn't exist in Win32, we add it here because user32 needs it.
1209 BOOL WINAPI SetDCHook( HDC hdc, DCHOOKPROC hookProc, DWORD dwHookData )
1211 DC *dc = DC_GetDCPtr( hdc );
1213 if (!dc) return FALSE;
1214 dc->dwHookData = dwHookData;
1215 dc->hookThunk = hookProc;
1216 GDI_ReleaseObj( hdc );
1221 /* relay function to call the 16-bit DC hook proc */
1222 static BOOL16 WINAPI call_dc_hook16( HDC16 hdc, WORD code, DWORD data, LPARAM lParam )
1224 FARPROC16 proc = NULL;
1225 DC *dc = DC_GetDCPtr( hdc );
1226 if (!dc) return FALSE;
1227 proc = dc->hookProc;
1228 GDI_ReleaseObj( hdc );
1229 if (!proc) return FALSE;
1230 return GDI_CallTo16_word_wwll( proc, hdc, code, data, lParam );
1233 /***********************************************************************
1234 * SetDCHook (GDI.190)
1236 BOOL16 WINAPI SetDCHook16( HDC16 hdc, FARPROC16 hookProc, DWORD dwHookData )
1238 DC *dc = DC_GetDCPtr( hdc );
1239 if (!dc) return FALSE;
1241 dc->hookProc = hookProc;
1242 GDI_ReleaseObj( hdc );
1243 return SetDCHook( hdc, call_dc_hook16, dwHookData );
1247 /***********************************************************************
1248 * GetDCHook (GDI.191)
1250 DWORD WINAPI GetDCHook( HDC16 hdc, FARPROC16 *phookProc )
1252 DC *dc = DC_GetDCPtr( hdc );
1254 *phookProc = dc->hookProc;
1255 GDI_ReleaseObj( hdc );
1256 return dc->dwHookData;
1260 /***********************************************************************
1261 * SetHookFlags (GDI.192)
1263 WORD WINAPI SetHookFlags16(HDC16 hDC, WORD flags)
1265 DC *dc = DC_GetDCPtr( hDC );
1269 WORD wRet = dc->flags & DC_DIRTY;
1271 /* "Undocumented Windows" info is slightly confusing.
1274 TRACE("hDC %04x, flags %04x\n",hDC,flags);
1276 if( flags & DCHF_INVALIDATEVISRGN )
1277 dc->flags |= DC_DIRTY;
1278 else if( flags & DCHF_VALIDATEVISRGN || !flags )
1279 dc->flags &= ~DC_DIRTY;
1280 GDI_ReleaseObj( hDC );
1286 /***********************************************************************
1287 * SetICMMode (GDI32.@)
1289 INT WINAPI SetICMMode(HDC hdc, INT iEnableICM)
1291 /*FIXME Asuming that ICM is always off, and cannot be turned on */
1292 if (iEnableICM == ICM_OFF) return ICM_OFF;
1293 if (iEnableICM == ICM_ON) return 0;
1294 if (iEnableICM == ICM_QUERY) return ICM_OFF;
1298 /***********************************************************************
1299 * GetDeviceGammaRamp (GDI32.@)
1301 BOOL WINAPI GetDeviceGammaRamp(HDC hDC, LPVOID ptr)
1304 DC *dc = DC_GetDCPtr( hDC );
1308 if (dc->funcs->pGetDeviceGammaRamp)
1309 ret = dc->funcs->pGetDeviceGammaRamp(dc->physDev, ptr);
1310 GDI_ReleaseObj( hDC );
1315 /***********************************************************************
1316 * SetDeviceGammaRamp (GDI32.@)
1318 BOOL WINAPI SetDeviceGammaRamp(HDC hDC, LPVOID ptr)
1321 DC *dc = DC_GetDCPtr( hDC );
1325 if (dc->funcs->pSetDeviceGammaRamp)
1326 ret = dc->funcs->pSetDeviceGammaRamp(dc->physDev, ptr);
1327 GDI_ReleaseObj( hDC );
1332 /***********************************************************************
1333 * GetColorSpace (GDI32.@)
1335 HCOLORSPACE WINAPI GetColorSpace(HDC hdc)
1337 /*FIXME Need to to whatever GetColorSpace actually does */
1341 /***********************************************************************
1342 * CreateColorSpaceA (GDI32.@)
1344 HCOLORSPACE WINAPI CreateColorSpaceA( LPLOGCOLORSPACEA lpLogColorSpace )
1350 /***********************************************************************
1351 * CreateColorSpaceW (GDI32.@)
1353 HCOLORSPACE WINAPI CreateColorSpaceW( LPLOGCOLORSPACEW lpLogColorSpace )
1359 /***********************************************************************
1360 * DeleteColorSpace (GDI32.@)
1362 BOOL WINAPI DeleteColorSpace( HCOLORSPACE hColorSpace )
1369 /***********************************************************************
1370 * SetColorSpace (GDI32.@)
1372 HCOLORSPACE WINAPI SetColorSpace( HDC hDC, HCOLORSPACE hColorSpace )
1379 /***********************************************************************
1380 * GetBoundsRect (GDI.194)
1382 UINT16 WINAPI GetBoundsRect16(HDC16 hdc, LPRECT16 rect, UINT16 flags)
1384 return DCB_RESET | DCB_DISABLE; /* bounding rectangle always empty and disabled*/
1387 /***********************************************************************
1388 * GetBoundsRect (GDI32.@)
1390 UINT WINAPI GetBoundsRect(HDC hdc, LPRECT rect, UINT flags)
1392 FIXME("(): stub\n");
1393 return DCB_RESET; /* bounding rectangle always empty */
1396 /***********************************************************************
1397 * SetBoundsRect (GDI.193)
1399 UINT16 WINAPI SetBoundsRect16(HDC16 hdc, const RECT16* rect, UINT16 flags)
1401 if ( (flags & DCB_ACCUMULATE) || (flags & DCB_ENABLE) )
1402 FIXME("(%04x, %p, %04x): stub\n", hdc, rect, flags );
1404 return DCB_RESET | DCB_DISABLE; /* bounding rectangle always empty and disabled*/
1407 /***********************************************************************
1408 * SetBoundsRect (GDI32.@)
1410 UINT WINAPI SetBoundsRect(HDC hdc, const RECT* rect, UINT flags)
1412 FIXME("(): stub\n");
1413 return DCB_DISABLE; /* bounding rectangle always empty */
1417 /***********************************************************************
1418 * GetRelAbs (GDI32.@)
1420 INT WINAPI GetRelAbs( HDC hdc, DWORD dwIgnore )
1423 DC *dc = DC_GetDCPtr( hdc );
1424 if (dc) ret = dc->relAbsMode;
1425 GDI_ReleaseObj( hdc );
1429 /***********************************************************************
1432 * Disables GDI, switches back to text mode.
1433 * We don't have to do anything here,
1434 * just let console support handle everything
1436 void WINAPI Death16(HDC16 hDC)
1438 MESSAGE("Death(%04x) called. Application enters text mode...\n", hDC);
1441 /***********************************************************************
1442 * Resurrection (GDI.122)
1444 * Restores GDI functionality
1446 void WINAPI Resurrection16(HDC16 hDC,
1447 WORD w1, WORD w2, WORD w3, WORD w4, WORD w5, WORD w6)
1449 MESSAGE("Resurrection(%04x, %04x, %04x, %04x, %04x, %04x, %04x) called. Application left text mode.\n", hDC, w1, w2, w3, w4, w5, w6);
1452 /***********************************************************************
1453 * GetLayout (GDI32.@)
1455 * Gets left->right or right->left text layout flags of a dc.
1456 * win98 just returns 0 and sets ERROR_CALL_NOT_IMPLEMENTED so we do the same
1459 DWORD WINAPI GetLayout(HDC hdc)
1461 FIXME("(%08x): stub\n", hdc);
1462 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1466 /***********************************************************************
1467 * SetLayout (GDI32.@)
1469 * Sets left->right or right->left text layout flags of a dc.
1470 * win98 just returns 0 and sets ERROR_CALL_NOT_IMPLEMENTED so we do the same
1473 DWORD WINAPI SetLayout(HDC hdc, DWORD layout)
1475 FIXME("(%08x,%08lx): stub\n", hdc, layout);
1476 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);