2 * GDI Device Context functions
4 * Copyright 1993 Alexandre Julliard
20 /* ROP code to GC function conversion */
21 const int DC_XROPfunction
[16] =
23 GXclear
, /* R2_BLACK */
24 GXnor
, /* R2_NOTMERGEPEN */
25 GXandInverted
, /* R2_MASKNOTPEN */
26 GXcopyInverted
, /* R2_NOTCOPYPEN */
27 GXandReverse
, /* R2_MASKPENNOT */
28 GXinvert
, /* R2_NOT */
29 GXxor
, /* R2_XORPEN */
30 GXnand
, /* R2_NOTMASKPEN */
31 GXand
, /* R2_MASKPEN */
32 GXequiv
, /* R2_NOTXORPEN */
34 GXorInverted
, /* R2_MERGENOTPEN */
35 GXcopy
, /* R2_COPYPEN */
36 GXorReverse
, /* R2_MERGEPENNOT */
37 GXor
, /* R2_MERGEPEN */
42 /***********************************************************************
45 * Fill the device caps structure.
47 void DC_FillDevCaps( DeviceCaps
* caps
)
49 caps
->version
= 0x300;
50 caps
->technology
= DT_RASDISPLAY
;
51 caps
->horzSize
= WidthMMOfScreen(screen
) * screenWidth
/ WidthOfScreen(screen
);
52 caps
->vertSize
= HeightMMOfScreen(screen
) * screenHeight
/ HeightOfScreen(screen
);
53 caps
->horzRes
= screenWidth
;
54 caps
->vertRes
= screenHeight
;
55 caps
->bitsPixel
= screenDepth
;
57 caps
->numBrushes
= 16+6; /* 16 solid + 6 hatched brushes */
58 caps
->numPens
= 16; /* 16 solid pens */
61 caps
->numColors
= 100;
62 caps
->pdeviceSize
= 0;
63 caps
->curveCaps
= CC_CIRCLES
| CC_PIE
| CC_CHORD
| CC_ELLIPSES
|
64 CC_WIDE
| CC_STYLED
| CC_WIDESTYLED
|
65 CC_INTERIORS
| CC_ROUNDRECT
;
66 caps
->lineCaps
= LC_POLYLINE
| LC_MARKER
| LC_POLYMARKER
| LC_WIDE
|
67 LC_STYLED
| LC_WIDESTYLED
| LC_INTERIORS
;
68 caps
->polygonalCaps
= PC_POLYGON
| PC_RECTANGLE
| PC_WINDPOLYGON
|
69 PC_SCANLINE
| PC_WIDE
| PC_STYLED
|
70 PC_WIDESTYLED
| PC_INTERIORS
;
71 caps
->textCaps
= TC_OP_CHARACTER
| TC_OP_STROKE
| TC_CP_STROKE
|
72 TC_IA_ABLE
| TC_UA_ABLE
| TC_SO_ABLE
| TC_RA_ABLE
;
73 caps
->clipCaps
= CP_REGION
;
74 caps
->rasterCaps
= RC_BITBLT
| RC_BANDING
| RC_SCALING
| RC_BITMAP64
|
75 RC_DI_BITMAP
| RC_DIBTODEV
| RC_BIGFONT
|
76 RC_STRETCHBLT
| RC_STRETCHDIB
| RC_DEVBITS
;
78 if( !(COLOR_GetSystemPaletteFlags() & COLOR_VIRTUAL
) )
79 caps
->rasterCaps
|= RC_PALETTE
;
81 caps
->aspectX
= 36; /* ?? */
82 caps
->aspectY
= 36; /* ?? */
84 caps
->logPixelsX
= (int)(caps
->horzRes
* 25.4 / caps
->horzSize
);
85 caps
->logPixelsY
= (int)(caps
->vertRes
* 25.4 / caps
->vertSize
);
86 caps
->sizePalette
= (caps
->rasterCaps
& RC_PALETTE
)
87 ? DefaultVisual(display
,DefaultScreen(display
))->map_entries
89 caps
->numReserved
= 0;
94 /***********************************************************************
97 * Fill the WIN_DC_INFO structure.
99 static void DC_Init_DC_INFO( WIN_DC_INFO
*win_dc_info
)
101 win_dc_info
->flags
= 0;
102 win_dc_info
->devCaps
= NULL
;
103 win_dc_info
->hClipRgn
= 0;
104 win_dc_info
->hVisRgn
= 0;
105 win_dc_info
->hGCClipRgn
= 0;
106 win_dc_info
->hPen
= STOCK_BLACK_PEN
;
107 win_dc_info
->hBrush
= STOCK_WHITE_BRUSH
;
108 win_dc_info
->hFont
= STOCK_SYSTEM_FONT
;
109 win_dc_info
->hBitmap
= 0;
110 win_dc_info
->hFirstBitmap
= 0;
111 win_dc_info
->hDevice
= 0;
112 win_dc_info
->hPalette
= STOCK_DEFAULT_PALETTE
;
113 win_dc_info
->ROPmode
= R2_COPYPEN
;
114 win_dc_info
->polyFillMode
= ALTERNATE
;
115 win_dc_info
->stretchBltMode
= BLACKONWHITE
;
116 win_dc_info
->relAbsMode
= ABSOLUTE
;
117 win_dc_info
->backgroundMode
= OPAQUE
;
118 win_dc_info
->backgroundColor
= RGB( 255, 255, 255 );
119 win_dc_info
->textColor
= RGB( 0, 0, 0 );
120 win_dc_info
->brushOrgX
= 0;
121 win_dc_info
->brushOrgY
= 0;
122 win_dc_info
->textAlign
= TA_LEFT
| TA_TOP
| TA_NOUPDATECP
;
123 win_dc_info
->charExtra
= 0;
124 win_dc_info
->breakTotalExtra
= 0;
125 win_dc_info
->breakCount
= 0;
126 win_dc_info
->breakExtra
= 0;
127 win_dc_info
->breakRem
= 0;
128 win_dc_info
->bitsPerPixel
= 1;
129 win_dc_info
->MapMode
= MM_TEXT
;
130 win_dc_info
->GraphicsMode
= GM_COMPATIBLE
;
131 win_dc_info
->DCOrgX
= 0;
132 win_dc_info
->DCOrgY
= 0;
133 win_dc_info
->lpfnPrint
= NULL
;
134 win_dc_info
->CursPosX
= 0;
135 win_dc_info
->CursPosY
= 0;
136 win_dc_info
->ArcDirection
= AD_COUNTERCLOCKWISE
;
137 win_dc_info
->xformWorld2Wnd
.eM11
= 1.0f
;
138 win_dc_info
->xformWorld2Wnd
.eM12
= 0.0f
;
139 win_dc_info
->xformWorld2Wnd
.eM21
= 0.0f
;
140 win_dc_info
->xformWorld2Wnd
.eM22
= 1.0f
;
141 win_dc_info
->xformWorld2Wnd
.eDx
= 0.0f
;
142 win_dc_info
->xformWorld2Wnd
.eDy
= 0.0f
;
143 win_dc_info
->xformWorld2Vport
= win_dc_info
->xformWorld2Wnd
;
144 win_dc_info
->xformVport2World
= win_dc_info
->xformWorld2Wnd
;
145 win_dc_info
->vport2WorldValid
= TRUE
;
147 PATH_InitGdiPath(&win_dc_info
->path
);
151 /***********************************************************************
154 DC
*DC_AllocDC( const DC_FUNCTIONS
*funcs
)
159 if (!(hdc
= GDI_AllocObject( sizeof(DC
), DC_MAGIC
))) return NULL
;
160 dc
= (DC
*) GDI_HEAP_LOCK( hdc
);
177 DC_Init_DC_INFO( &dc
->w
);
184 /***********************************************************************
187 DC
*DC_GetDCPtr( HDC32 hdc
)
189 GDIOBJHDR
*ptr
= (GDIOBJHDR
*)GDI_HEAP_LOCK( hdc
);
190 if (!ptr
) return NULL
;
191 if ((ptr
->wMagic
== DC_MAGIC
) || (ptr
->wMagic
== METAFILE_DC_MAGIC
))
193 GDI_HEAP_UNLOCK( hdc
);
198 /***********************************************************************
201 * Setup device-specific DC values for a newly created DC.
203 void DC_InitDC( DC
* dc
)
205 RealizeDefaultPalette( dc
->hSelf
);
206 SetTextColor32( dc
->hSelf
, dc
->w
.textColor
);
207 SetBkColor32( dc
->hSelf
, dc
->w
.backgroundColor
);
208 SelectObject32( dc
->hSelf
, dc
->w
.hPen
);
209 SelectObject32( dc
->hSelf
, dc
->w
.hBrush
);
210 SelectObject32( dc
->hSelf
, dc
->w
.hFont
);
211 CLIPPING_UpdateGCRegion( dc
);
215 /***********************************************************************
216 * DC_SetupGCForPatBlt
218 * Setup the GC for a PatBlt operation using current brush.
219 * If fMapColors is TRUE, X pixels are mapped to Windows colors.
220 * Return FALSE if brush is BS_NULL, TRUE otherwise.
222 BOOL32
DC_SetupGCForPatBlt( DC
* dc
, GC gc
, BOOL32 fMapColors
)
228 if (dc
->u
.x
.brush
.style
== BS_NULL
) return FALSE
;
229 if (dc
->u
.x
.brush
.pixel
== -1)
231 /* Special case used for monochrome pattern brushes.
232 * We need to swap foreground and background because
233 * Windows does it the wrong way...
235 val
.foreground
= dc
->u
.x
.backgroundPixel
;
236 val
.background
= dc
->u
.x
.textPixel
;
240 val
.foreground
= dc
->u
.x
.brush
.pixel
;
241 val
.background
= dc
->u
.x
.backgroundPixel
;
243 if (fMapColors
&& COLOR_PixelToPalette
)
245 val
.foreground
= COLOR_PixelToPalette
[val
.foreground
];
246 val
.background
= COLOR_PixelToPalette
[val
.background
];
249 if (dc
->w
.flags
& DC_DIRTY
) CLIPPING_UpdateGCRegion(dc
);
251 val
.function
= DC_XROPfunction
[dc
->w
.ROPmode
-1];
253 ** Let's replace GXinvert by GXxor with (black xor white)
254 ** This solves the selection color and leak problems in excel
255 ** FIXME : Let's do that only if we work with X-pixels, not with Win-pixels
257 if (val
.function
== GXinvert
)
259 val
.foreground
= BlackPixelOfScreen(screen
) ^ WhitePixelOfScreen(screen
);
260 val
.function
= GXxor
;
262 val
.fill_style
= dc
->u
.x
.brush
.fillStyle
;
263 switch(val
.fill_style
)
266 case FillOpaqueStippled
:
267 if (dc
->w
.backgroundMode
==OPAQUE
) val
.fill_style
= FillOpaqueStippled
;
268 val
.stipple
= dc
->u
.x
.brush
.pixmap
;
273 if (fMapColors
&& COLOR_PixelToPalette
)
277 EnterCriticalSection( &X11DRV_CritSection
);
278 pixmap
= XCreatePixmap( display
, rootWindow
, 8, 8, screenDepth
);
279 image
= XGetImage( display
, dc
->u
.x
.brush
.pixmap
, 0, 0, 8, 8,
280 AllPlanes
, ZPixmap
);
281 for (y
= 0; y
< 8; y
++)
282 for (x
= 0; x
< 8; x
++)
283 XPutPixel( image
, x
, y
,
284 COLOR_PixelToPalette
[XGetPixel( image
, x
, y
)] );
285 XPutImage( display
, pixmap
, gc
, image
, 0, 0, 0, 0, 8, 8 );
286 XDestroyImage( image
);
287 LeaveCriticalSection( &X11DRV_CritSection
);
290 else val
.tile
= dc
->u
.x
.brush
.pixmap
;
298 val
.ts_x_origin
= dc
->w
.DCOrgX
+ dc
->w
.brushOrgX
;
299 val
.ts_y_origin
= dc
->w
.DCOrgY
+ dc
->w
.brushOrgY
;
300 val
.fill_rule
= (dc
->w
.polyFillMode
==WINDING
) ? WindingRule
: EvenOddRule
;
301 TSXChangeGC( display
, gc
,
302 GCFunction
| GCForeground
| GCBackground
| GCFillStyle
|
303 GCFillRule
| GCTileStipXOrigin
| GCTileStipYOrigin
| mask
,
305 if (pixmap
) TSXFreePixmap( display
, pixmap
);
310 /***********************************************************************
313 * Setup dc->u.x.gc for drawing operations using current brush.
314 * Return FALSE if brush is BS_NULL, TRUE otherwise.
316 BOOL32
DC_SetupGCForBrush( DC
* dc
)
318 return DC_SetupGCForPatBlt( dc
, dc
->u
.x
.gc
, FALSE
);
322 /***********************************************************************
325 * Setup dc->u.x.gc for drawing operations using current pen.
326 * Return FALSE if pen is PS_NULL, TRUE otherwise.
328 BOOL32
DC_SetupGCForPen( DC
* dc
)
332 if (dc
->u
.x
.pen
.style
== PS_NULL
) return FALSE
;
334 if (dc
->w
.flags
& DC_DIRTY
) CLIPPING_UpdateGCRegion(dc
);
336 switch (dc
->w
.ROPmode
)
339 val
.foreground
= BlackPixelOfScreen( screen
);
340 val
.function
= GXcopy
;
343 val
.foreground
= WhitePixelOfScreen( screen
);
344 val
.function
= GXcopy
;
347 val
.foreground
= dc
->u
.x
.pen
.pixel
;
348 /* It is very unlikely someone wants to XOR with 0 */
349 /* This fixes the rubber-drawings in paintbrush */
350 if (val
.foreground
== 0)
351 val
.foreground
= BlackPixelOfScreen( screen
)
352 ^ WhitePixelOfScreen( screen
);
353 val
.function
= GXxor
;
356 val
.foreground
= dc
->u
.x
.pen
.pixel
;
357 val
.function
= DC_XROPfunction
[dc
->w
.ROPmode
-1];
359 val
.background
= dc
->u
.x
.backgroundPixel
;
360 val
.fill_style
= FillSolid
;
361 if ((dc
->u
.x
.pen
.style
!=PS_SOLID
) && (dc
->u
.x
.pen
.style
!=PS_INSIDEFRAME
))
363 TSXSetDashes( display
, dc
->u
.x
.gc
, 0,
364 dc
->u
.x
.pen
.dashes
, dc
->u
.x
.pen
.dash_len
);
365 val
.line_style
= (dc
->w
.backgroundMode
== OPAQUE
) ?
366 LineDoubleDash
: LineOnOffDash
;
368 else val
.line_style
= LineSolid
;
369 val
.line_width
= dc
->u
.x
.pen
.width
;
370 if (val
.line_width
<= 1) {
371 val
.cap_style
= CapNotLast
;
373 switch (dc
->u
.x
.pen
.endcap
)
375 case PS_ENDCAP_SQUARE
:
376 val
.cap_style
= CapProjecting
;
379 val
.cap_style
= CapButt
;
381 case PS_ENDCAP_ROUND
:
383 val
.cap_style
= CapRound
;
386 switch (dc
->u
.x
.pen
.linejoin
)
389 val
.join_style
= JoinBevel
;
392 val
.join_style
= JoinMiter
;
396 val
.join_style
= JoinRound
;
398 TSXChangeGC( display
, dc
->u
.x
.gc
,
399 GCFunction
| GCForeground
| GCBackground
| GCLineWidth
|
400 GCLineStyle
| GCCapStyle
| GCJoinStyle
| GCFillStyle
, &val
);
405 /***********************************************************************
408 * Setup dc->u.x.gc for text drawing operations.
409 * Return FALSE if the font is null, TRUE otherwise.
411 BOOL32
DC_SetupGCForText( DC
* dc
)
413 XFontStruct
* xfs
= XFONT_GetFontStruct( dc
->u
.x
.font
);
419 if (dc
->w
.flags
& DC_DIRTY
) CLIPPING_UpdateGCRegion(dc
);
421 val
.function
= GXcopy
; /* Text is always GXcopy */
422 val
.foreground
= dc
->u
.x
.textPixel
;
423 val
.background
= dc
->u
.x
.backgroundPixel
;
424 val
.fill_style
= FillSolid
;
427 TSXChangeGC( display
, dc
->u
.x
.gc
,
428 GCFunction
| GCForeground
| GCBackground
| GCFillStyle
|
432 WARN(dc
, "Physical font failure\n" );
437 /***********************************************************************
440 * Computes the inverse of the transformation xformSrc and stores it to
441 * xformDest. Returns TRUE if successful or FALSE if the xformSrc matrix
444 static BOOL32
DC_InvertXform( const XFORM
*xformSrc
, XFORM
*xformDest
)
448 determinant
= xformSrc
->eM11
*xformSrc
->eM22
-
449 xformSrc
->eM12
*xformSrc
->eM21
;
450 if (determinant
> -1e-12 && determinant
< 1e-12)
453 xformDest
->eM11
= xformSrc
->eM22
/ determinant
;
454 xformDest
->eM12
= -xformSrc
->eM12
/ determinant
;
455 xformDest
->eM21
= -xformSrc
->eM21
/ determinant
;
456 xformDest
->eM22
= xformSrc
->eM11
/ determinant
;
457 xformDest
->eDx
= -xformSrc
->eDx
* xformDest
->eM11
-
458 xformSrc
->eDy
* xformDest
->eM21
;
459 xformDest
->eDy
= -xformSrc
->eDx
* xformDest
->eM12
-
460 xformSrc
->eDy
* xformDest
->eM22
;
466 /***********************************************************************
469 * Updates the xformWorld2Vport, xformVport2World and vport2WorldValid
470 * fields of the specified DC by creating a transformation that
471 * represents the current mapping mode and combining it with the DC's
472 * world transform. This function should be called whenever the
473 * parameters associated with the mapping mode (window and viewport
474 * extents and origins) or the world transform change.
476 void DC_UpdateXforms( DC
*dc
)
478 XFORM xformWnd2Vport
;
479 FLOAT scaleX
, scaleY
;
481 /* Construct a transformation to do the window-to-viewport conversion */
482 scaleX
= (FLOAT
)dc
->vportExtX
/ (FLOAT
)dc
->wndExtX
;
483 scaleY
= (FLOAT
)dc
->vportExtY
/ (FLOAT
)dc
->wndExtY
;
484 xformWnd2Vport
.eM11
= scaleX
;
485 xformWnd2Vport
.eM12
= 0.0;
486 xformWnd2Vport
.eM21
= 0.0;
487 xformWnd2Vport
.eM22
= scaleY
;
488 xformWnd2Vport
.eDx
= (FLOAT
)dc
->vportOrgX
-
489 scaleX
* (FLOAT
)dc
->wndOrgX
;
490 xformWnd2Vport
.eDy
= (FLOAT
)dc
->vportOrgY
-
491 scaleY
* (FLOAT
)dc
->wndOrgY
;
493 /* Combine with the world transformation */
494 CombineTransform( &dc
->w
.xformWorld2Vport
, &dc
->w
.xformWorld2Wnd
,
497 /* Create inverse of world-to-viewport transformation */
498 dc
->w
.vport2WorldValid
= DC_InvertXform( &dc
->w
.xformWorld2Vport
,
499 &dc
->w
.xformVport2World
);
503 /***********************************************************************
504 * GetDCState (GDI.179)
506 HDC16 WINAPI
GetDCState( HDC16 hdc
)
511 if (!(dc
= (DC
*) GDI_GetObjPtr( hdc
, DC_MAGIC
))) return 0;
512 if (!(handle
= GDI_AllocObject( sizeof(DC
), DC_MAGIC
)))
514 GDI_HEAP_UNLOCK( hdc
);
517 newdc
= (DC
*) GDI_HEAP_LOCK( handle
);
519 TRACE(dc
, "(%04x): returning %04x\n", hdc
, handle
);
521 memset( &newdc
->u
.x
, 0, sizeof(newdc
->u
.x
) );
522 newdc
->w
.flags
= dc
->w
.flags
| DC_SAVED
;
523 newdc
->w
.devCaps
= dc
->w
.devCaps
;
524 newdc
->w
.hPen
= dc
->w
.hPen
;
525 newdc
->w
.hBrush
= dc
->w
.hBrush
;
526 newdc
->w
.hFont
= dc
->w
.hFont
;
527 newdc
->w
.hBitmap
= dc
->w
.hBitmap
;
528 newdc
->w
.hFirstBitmap
= dc
->w
.hFirstBitmap
;
529 newdc
->w
.hDevice
= dc
->w
.hDevice
;
530 newdc
->w
.hPalette
= dc
->w
.hPalette
;
531 newdc
->w
.totalExtent
= dc
->w
.totalExtent
;
532 newdc
->w
.bitsPerPixel
= dc
->w
.bitsPerPixel
;
533 newdc
->w
.ROPmode
= dc
->w
.ROPmode
;
534 newdc
->w
.polyFillMode
= dc
->w
.polyFillMode
;
535 newdc
->w
.stretchBltMode
= dc
->w
.stretchBltMode
;
536 newdc
->w
.relAbsMode
= dc
->w
.relAbsMode
;
537 newdc
->w
.backgroundMode
= dc
->w
.backgroundMode
;
538 newdc
->w
.backgroundColor
= dc
->w
.backgroundColor
;
539 newdc
->w
.textColor
= dc
->w
.textColor
;
540 newdc
->w
.brushOrgX
= dc
->w
.brushOrgX
;
541 newdc
->w
.brushOrgY
= dc
->w
.brushOrgY
;
542 newdc
->w
.textAlign
= dc
->w
.textAlign
;
543 newdc
->w
.charExtra
= dc
->w
.charExtra
;
544 newdc
->w
.breakTotalExtra
= dc
->w
.breakTotalExtra
;
545 newdc
->w
.breakCount
= dc
->w
.breakCount
;
546 newdc
->w
.breakExtra
= dc
->w
.breakExtra
;
547 newdc
->w
.breakRem
= dc
->w
.breakRem
;
548 newdc
->w
.MapMode
= dc
->w
.MapMode
;
549 newdc
->w
.GraphicsMode
= dc
->w
.GraphicsMode
;
551 /* Apparently, the DC origin is not changed by [GS]etDCState */
552 newdc
->w
.DCOrgX
= dc
->w
.DCOrgX
;
553 newdc
->w
.DCOrgY
= dc
->w
.DCOrgY
;
555 newdc
->w
.CursPosX
= dc
->w
.CursPosX
;
556 newdc
->w
.CursPosY
= dc
->w
.CursPosY
;
557 newdc
->w
.ArcDirection
= dc
->w
.ArcDirection
;
558 newdc
->w
.xformWorld2Wnd
= dc
->w
.xformWorld2Wnd
;
559 newdc
->w
.xformWorld2Vport
= dc
->w
.xformWorld2Vport
;
560 newdc
->w
.xformVport2World
= dc
->w
.xformVport2World
;
561 newdc
->w
.vport2WorldValid
= dc
->w
.vport2WorldValid
;
562 newdc
->wndOrgX
= dc
->wndOrgX
;
563 newdc
->wndOrgY
= dc
->wndOrgY
;
564 newdc
->wndExtX
= dc
->wndExtX
;
565 newdc
->wndExtY
= dc
->wndExtY
;
566 newdc
->vportOrgX
= dc
->vportOrgX
;
567 newdc
->vportOrgY
= dc
->vportOrgY
;
568 newdc
->vportExtX
= dc
->vportExtX
;
569 newdc
->vportExtY
= dc
->vportExtY
;
571 newdc
->hSelf
= (HDC32
)handle
;
572 newdc
->saveLevel
= 0;
574 PATH_InitGdiPath( &newdc
->w
.path
);
576 /* Get/SetDCState() don't change hVisRgn field ("Undoc. Windows" p.559). */
578 newdc
->w
.hGCClipRgn
= newdc
->w
.hVisRgn
= 0;
581 newdc
->w
.hClipRgn
= CreateRectRgn32( 0, 0, 0, 0 );
582 CombineRgn32( newdc
->w
.hClipRgn
, dc
->w
.hClipRgn
, 0, RGN_COPY
);
585 newdc
->w
.hClipRgn
= 0;
586 GDI_HEAP_UNLOCK( handle
);
587 GDI_HEAP_UNLOCK( hdc
);
592 /***********************************************************************
593 * SetDCState (GDI.180)
595 void WINAPI
SetDCState( HDC16 hdc
, HDC16 hdcs
)
599 if (!(dc
= (DC
*) GDI_GetObjPtr( hdc
, DC_MAGIC
))) return;
600 if (!(dcs
= (DC
*) GDI_GetObjPtr( hdcs
, DC_MAGIC
)))
602 GDI_HEAP_UNLOCK( hdc
);
605 if (!dcs
->w
.flags
& DC_SAVED
)
607 GDI_HEAP_UNLOCK( hdc
);
608 GDI_HEAP_UNLOCK( hdcs
);
611 TRACE(dc
, "%04x %04x\n", hdc
, hdcs
);
613 dc
->w
.flags
= dcs
->w
.flags
& ~DC_SAVED
;
614 dc
->w
.devCaps
= dcs
->w
.devCaps
;
615 dc
->w
.hFirstBitmap
= dcs
->w
.hFirstBitmap
;
616 dc
->w
.hDevice
= dcs
->w
.hDevice
;
617 dc
->w
.totalExtent
= dcs
->w
.totalExtent
;
618 dc
->w
.ROPmode
= dcs
->w
.ROPmode
;
619 dc
->w
.polyFillMode
= dcs
->w
.polyFillMode
;
620 dc
->w
.stretchBltMode
= dcs
->w
.stretchBltMode
;
621 dc
->w
.relAbsMode
= dcs
->w
.relAbsMode
;
622 dc
->w
.backgroundMode
= dcs
->w
.backgroundMode
;
623 dc
->w
.backgroundColor
= dcs
->w
.backgroundColor
;
624 dc
->w
.textColor
= dcs
->w
.textColor
;
625 dc
->w
.brushOrgX
= dcs
->w
.brushOrgX
;
626 dc
->w
.brushOrgY
= dcs
->w
.brushOrgY
;
627 dc
->w
.textAlign
= dcs
->w
.textAlign
;
628 dc
->w
.charExtra
= dcs
->w
.charExtra
;
629 dc
->w
.breakTotalExtra
= dcs
->w
.breakTotalExtra
;
630 dc
->w
.breakCount
= dcs
->w
.breakCount
;
631 dc
->w
.breakExtra
= dcs
->w
.breakExtra
;
632 dc
->w
.breakRem
= dcs
->w
.breakRem
;
633 dc
->w
.MapMode
= dcs
->w
.MapMode
;
634 dc
->w
.GraphicsMode
= dcs
->w
.GraphicsMode
;
636 /* Apparently, the DC origin is not changed by [GS]etDCState */
637 dc
->w
.DCOrgX
= dcs
->w
.DCOrgX
;
638 dc
->w
.DCOrgY
= dcs
->w
.DCOrgY
;
640 dc
->w
.CursPosX
= dcs
->w
.CursPosX
;
641 dc
->w
.CursPosY
= dcs
->w
.CursPosY
;
642 dc
->w
.ArcDirection
= dcs
->w
.ArcDirection
;
643 dc
->w
.xformWorld2Wnd
= dcs
->w
.xformWorld2Wnd
;
644 dc
->w
.xformWorld2Vport
= dcs
->w
.xformWorld2Vport
;
645 dc
->w
.xformVport2World
= dcs
->w
.xformVport2World
;
646 dc
->w
.vport2WorldValid
= dcs
->w
.vport2WorldValid
;
648 dc
->wndOrgX
= dcs
->wndOrgX
;
649 dc
->wndOrgY
= dcs
->wndOrgY
;
650 dc
->wndExtX
= dcs
->wndExtX
;
651 dc
->wndExtY
= dcs
->wndExtY
;
652 dc
->vportOrgX
= dcs
->vportOrgX
;
653 dc
->vportOrgY
= dcs
->vportOrgY
;
654 dc
->vportExtX
= dcs
->vportExtX
;
655 dc
->vportExtY
= dcs
->vportExtY
;
657 if (!(dc
->w
.flags
& DC_MEMORY
)) dc
->w
.bitsPerPixel
= dcs
->w
.bitsPerPixel
;
661 if (!dc
->w
.hClipRgn
) dc
->w
.hClipRgn
= CreateRectRgn32( 0, 0, 0, 0 );
662 CombineRgn32( dc
->w
.hClipRgn
, dcs
->w
.hClipRgn
, 0, RGN_COPY
);
663 CLIPPING_UpdateGCRegion( dc
);
668 SelectObject32( hdc
, dcs
->w
.hBitmap
);
669 SelectObject32( hdc
, dcs
->w
.hBrush
);
670 SelectObject32( hdc
, dcs
->w
.hFont
);
671 SelectObject32( hdc
, dcs
->w
.hPen
);
672 SetBkColor32( hdc
, dcs
->w
.backgroundColor
);
673 SetTextColor32( hdc
, dcs
->w
.textColor
);
674 GDISelectPalette( hdc
, dcs
->w
.hPalette
, FALSE
);
675 GDI_HEAP_UNLOCK( hdc
);
676 GDI_HEAP_UNLOCK( hdcs
);
680 /***********************************************************************
683 INT16 WINAPI
SaveDC16( HDC16 hdc
)
685 return (INT16
)SaveDC32( hdc
);
689 /***********************************************************************
690 * SaveDC32 (GDI32.292)
692 INT32 WINAPI
SaveDC32( HDC32 hdc
)
698 dc
= (DC
*) GDI_GetObjPtr( hdc
, DC_MAGIC
);
701 dc
= (DC
*)GDI_GetObjPtr(hdc
, METAFILE_DC_MAGIC
);
703 MF_MetaParam0(dc
, META_SAVEDC
);
704 GDI_HEAP_UNLOCK( hdc
);
707 if (!(hdcs
= GetDCState( hdc
)))
709 GDI_HEAP_UNLOCK( hdc
);
712 dcs
= (DC
*) GDI_HEAP_LOCK( hdcs
);
714 /* Copy path. The reason why path saving / restoring is in SaveDC/
715 * RestoreDC and not in GetDCState/SetDCState is that the ...DCState
716 * functions are only in Win16 (which doesn't have paths) and that
717 * SetDCState doesn't allow us to signal an error (which can happen
718 * when copying paths).
720 if (!PATH_AssignGdiPath( &dcs
->w
.path
, &dc
->w
.path
))
722 GDI_HEAP_UNLOCK( hdc
);
723 GDI_HEAP_UNLOCK( hdcs
);
728 dcs
->header
.hNext
= dc
->header
.hNext
;
729 dc
->header
.hNext
= hdcs
;
730 TRACE(dc
, "(%04x): returning %d\n", hdc
, dc
->saveLevel
+1 );
731 ret
= ++dc
->saveLevel
;
732 GDI_HEAP_UNLOCK( hdcs
);
733 GDI_HEAP_UNLOCK( hdc
);
738 /***********************************************************************
739 * RestoreDC16 (GDI.39)
741 BOOL16 WINAPI
RestoreDC16( HDC16 hdc
, INT16 level
)
743 return RestoreDC32( hdc
, level
);
747 /***********************************************************************
748 * RestoreDC32 (GDI32.290)
750 BOOL32 WINAPI
RestoreDC32( HDC32 hdc
, INT32 level
)
755 TRACE(dc
, "%04x %d\n", hdc
, level
);
756 dc
= (DC
*) GDI_GetObjPtr( hdc
, DC_MAGIC
);
759 dc
= (DC
*)GDI_GetObjPtr(hdc
, METAFILE_DC_MAGIC
);
760 if (!dc
) return FALSE
;
763 GDI_HEAP_UNLOCK( hdc
);
766 MF_MetaParam1(dc
, META_RESTOREDC
, level
);
767 GDI_HEAP_UNLOCK( hdc
);
770 if (level
== -1) level
= dc
->saveLevel
;
771 if ((level
< 1) || (level
> dc
->saveLevel
))
773 GDI_HEAP_UNLOCK( hdc
);
778 while (dc
->saveLevel
>= level
)
780 HDC16 hdcs
= dc
->header
.hNext
;
781 if (!(dcs
= (DC
*) GDI_GetObjPtr( hdcs
, DC_MAGIC
)))
783 GDI_HEAP_UNLOCK( hdc
);
786 dc
->header
.hNext
= dcs
->header
.hNext
;
787 if (--dc
->saveLevel
< level
)
789 SetDCState( hdc
, hdcs
);
790 if (!PATH_AssignGdiPath( &dc
->w
.path
, &dcs
->w
.path
))
791 /* FIXME: This might not be quite right, since we're
792 * returning FALSE but still destroying the saved DC state */
797 GDI_HEAP_UNLOCK( hdc
);
802 /***********************************************************************
803 * CreateDC16 (GDI.53)
805 HDC16 WINAPI
CreateDC16( LPCSTR driver
, LPCSTR device
, LPCSTR output
,
806 const DEVMODE16
*initData
)
809 const DC_FUNCTIONS
*funcs
;
811 if (!(funcs
= DRIVER_FindDriver( driver
))) return 0;
812 if (!(dc
= DC_AllocDC( funcs
))) return 0;
815 TRACE(dc
, "(driver=%s, device=%s, output=%s): returning %04x\n",
816 debugstr_a(driver
), debugstr_a(device
), debugstr_a(output
), dc
->hSelf
);
818 if (dc
->funcs
->pCreateDC
&&
819 !dc
->funcs
->pCreateDC( dc
, driver
, device
, output
, initData
))
821 WARN(dc
, "creation aborted by device\n" );
822 GDI_HEAP_FREE( dc
->hSelf
);
827 GDI_HEAP_UNLOCK( dc
->hSelf
);
832 /***********************************************************************
833 * CreateDC32A (GDI32.)
835 HDC32 WINAPI
CreateDC32A( LPCSTR driver
, LPCSTR device
, LPCSTR output
,
836 const DEVMODE32A
*initData
)
838 return CreateDC16( driver
, device
, output
, (const DEVMODE16
*)initData
);
842 /***********************************************************************
843 * CreateDC32W (GDI32.)
845 HDC32 WINAPI
CreateDC32W( LPCWSTR driver
, LPCWSTR device
, LPCWSTR output
,
846 const DEVMODE32W
*initData
)
848 LPSTR driverA
= HEAP_strdupWtoA( GetProcessHeap(), 0, driver
);
849 LPSTR deviceA
= HEAP_strdupWtoA( GetProcessHeap(), 0, device
);
850 LPSTR outputA
= HEAP_strdupWtoA( GetProcessHeap(), 0, output
);
851 HDC32 res
= CreateDC16( driverA
, deviceA
, outputA
,
852 (const DEVMODE16
*)initData
/*FIXME*/ );
853 HeapFree( GetProcessHeap(), 0, driverA
);
854 HeapFree( GetProcessHeap(), 0, deviceA
);
855 HeapFree( GetProcessHeap(), 0, outputA
);
860 /***********************************************************************
861 * CreateIC16 (GDI.153)
863 HDC16 WINAPI
CreateIC16( LPCSTR driver
, LPCSTR device
, LPCSTR output
,
864 const DEVMODE16
* initData
)
866 /* Nothing special yet for ICs */
867 return CreateDC16( driver
, device
, output
, initData
);
871 /***********************************************************************
872 * CreateIC32A (GDI32.49)
874 HDC32 WINAPI
CreateIC32A( LPCSTR driver
, LPCSTR device
, LPCSTR output
,
875 const DEVMODE32A
* initData
)
877 /* Nothing special yet for ICs */
878 return CreateDC32A( driver
, device
, output
, initData
);
882 /***********************************************************************
883 * CreateIC32W (GDI32.50)
885 HDC32 WINAPI
CreateIC32W( LPCWSTR driver
, LPCWSTR device
, LPCWSTR output
,
886 const DEVMODE32W
* initData
)
888 /* Nothing special yet for ICs */
889 return CreateDC32W( driver
, device
, output
, initData
);
893 /***********************************************************************
894 * CreateCompatibleDC16 (GDI.52)
896 HDC16 WINAPI
CreateCompatibleDC16( HDC16 hdc
)
898 return (HDC16
)CreateCompatibleDC32( hdc
);
902 /***********************************************************************
903 * CreateCompatibleDC32 (GDI32.31)
905 HDC32 WINAPI
CreateCompatibleDC32( HDC32 hdc
)
909 const DC_FUNCTIONS
*funcs
;
911 if ((origDC
= (DC
*)GDI_GetObjPtr( hdc
, DC_MAGIC
))) funcs
= origDC
->funcs
;
912 else funcs
= DRIVER_FindDriver( "DISPLAY" );
913 if (!funcs
) return 0;
915 if (!(dc
= DC_AllocDC( funcs
))) return 0;
917 TRACE(dc
, "(%04x): returning %04x\n",
920 /* Create default bitmap */
921 if (!(hbitmap
= CreateBitmap32( 1, 1, 1, 1, NULL
)))
923 GDI_HEAP_FREE( dc
->hSelf
);
926 dc
->w
.flags
= DC_MEMORY
;
927 dc
->w
.bitsPerPixel
= 1;
928 dc
->w
.hBitmap
= hbitmap
;
929 dc
->w
.hFirstBitmap
= hbitmap
;
931 if (dc
->funcs
->pCreateDC
&&
932 !dc
->funcs
->pCreateDC( dc
, NULL
, NULL
, NULL
, NULL
))
934 WARN(dc
, "creation aborted by device\n");
935 DeleteObject32( hbitmap
);
936 GDI_HEAP_FREE( dc
->hSelf
);
941 GDI_HEAP_UNLOCK( dc
->hSelf
);
946 /***********************************************************************
947 * DeleteDC16 (GDI.68)
949 BOOL16 WINAPI
DeleteDC16( HDC16 hdc
)
951 return DeleteDC32( hdc
);
955 /***********************************************************************
956 * DeleteDC32 (GDI32.67)
958 BOOL32 WINAPI
DeleteDC32( HDC32 hdc
)
960 DC
* dc
= (DC
*) GDI_GetObjPtr( hdc
, DC_MAGIC
);
961 if (!dc
) return FALSE
;
963 TRACE(dc
, "%04x\n", hdc
);
965 while (dc
->saveLevel
)
968 HDC16 hdcs
= dc
->header
.hNext
;
969 if (!(dcs
= (DC
*) GDI_GetObjPtr( hdcs
, DC_MAGIC
))) break;
970 dc
->header
.hNext
= dcs
->header
.hNext
;
975 if (!(dc
->w
.flags
& DC_SAVED
))
977 SelectObject32( hdc
, STOCK_BLACK_PEN
);
978 SelectObject32( hdc
, STOCK_WHITE_BRUSH
);
979 SelectObject32( hdc
, STOCK_SYSTEM_FONT
);
980 if (dc
->w
.flags
& DC_MEMORY
) DeleteObject32( dc
->w
.hFirstBitmap
);
981 if (dc
->funcs
->pDeleteDC
) dc
->funcs
->pDeleteDC(dc
);
984 if (dc
->w
.hClipRgn
) DeleteObject32( dc
->w
.hClipRgn
);
985 if (dc
->w
.hVisRgn
) DeleteObject32( dc
->w
.hVisRgn
);
986 if (dc
->w
.hGCClipRgn
) DeleteObject32( dc
->w
.hGCClipRgn
);
988 PATH_DestroyGdiPath(&dc
->w
.path
);
990 return GDI_FreeObject( hdc
);
994 /***********************************************************************
995 * ResetDC16 (GDI.376)
997 HDC16 WINAPI
ResetDC16( HDC16 hdc
, const DEVMODE16
*devmode
)
999 FIXME(dc
, "stub\n" );
1004 /***********************************************************************
1005 * ResetDC32A (GDI32.287)
1007 HDC32 WINAPI
ResetDC32A( HDC32 hdc
, const DEVMODE32A
*devmode
)
1009 FIXME(dc
, "stub\n" );
1014 /***********************************************************************
1015 * ResetDC32W (GDI32.288)
1017 HDC32 WINAPI
ResetDC32W( HDC32 hdc
, const DEVMODE32W
*devmode
)
1019 FIXME(dc
, "stub\n" );
1024 /***********************************************************************
1025 * GetDeviceCaps16 (GDI.80)
1027 INT16 WINAPI
GetDeviceCaps16( HDC16 hdc
, INT16 cap
)
1029 return GetDeviceCaps32( hdc
, cap
);
1033 /***********************************************************************
1034 * GetDeviceCaps32 (GDI32.171)
1036 INT32 WINAPI
GetDeviceCaps32( HDC32 hdc
, INT32 cap
)
1038 DC
* dc
= (DC
*) GDI_GetObjPtr( hdc
, DC_MAGIC
);
1043 if ((cap
< 0) || (cap
> sizeof(DeviceCaps
)-sizeof(WORD
)))
1045 GDI_HEAP_UNLOCK( hdc
);
1049 TRACE(dc
, "(%04x,%d): returning %d\n",
1050 hdc
, cap
, *(WORD
*)(((char *)dc
->w
.devCaps
) + cap
) );
1051 ret
= *(WORD
*)(((char *)dc
->w
.devCaps
) + cap
);
1052 GDI_HEAP_UNLOCK( hdc
);
1057 /***********************************************************************
1058 * SetBkColor16 (GDI.1)
1060 COLORREF WINAPI
SetBkColor16( HDC16 hdc
, COLORREF color
)
1062 return SetBkColor32( hdc
, color
);
1066 /***********************************************************************
1067 * SetBkColor32 (GDI32.305)
1069 COLORREF WINAPI
SetBkColor32( HDC32 hdc
, COLORREF color
)
1072 DC
* dc
= DC_GetDCPtr( hdc
);
1074 if (!dc
) return 0x80000000;
1075 if (dc
->funcs
->pSetBkColor
)
1076 oldColor
= dc
->funcs
->pSetBkColor(dc
, color
);
1078 oldColor
= dc
->w
.backgroundColor
;
1079 dc
->w
.backgroundColor
= color
;
1081 GDI_HEAP_UNLOCK( hdc
);
1086 /***********************************************************************
1087 * SetTextColor16 (GDI.9)
1089 COLORREF WINAPI
SetTextColor16( HDC16 hdc
, COLORREF color
)
1091 return SetTextColor32( hdc
, color
);
1095 /***********************************************************************
1096 * SetTextColor32 (GDI32.338)
1098 COLORREF WINAPI
SetTextColor32( HDC32 hdc
, COLORREF color
)
1101 DC
* dc
= DC_GetDCPtr( hdc
);
1103 if (!dc
) return 0x80000000;
1104 if (dc
->funcs
->pSetTextColor
)
1105 oldColor
= dc
->funcs
->pSetTextColor(dc
, color
);
1107 oldColor
= dc
->w
.textColor
;
1108 dc
->w
.textColor
= color
;
1110 GDI_HEAP_UNLOCK( hdc
);
1115 /***********************************************************************
1116 * SetTextAlign16 (GDI.346)
1118 UINT16 WINAPI
SetTextAlign16( HDC16 hdc
, UINT16 textAlign
)
1120 return SetTextAlign32( hdc
, textAlign
);
1124 /***********************************************************************
1125 * SetTextAlign32 (GDI32.336)
1127 UINT32 WINAPI
SetTextAlign32( HDC32 hdc
, UINT32 textAlign
)
1130 DC
* dc
= (DC
*) GDI_GetObjPtr( hdc
, DC_MAGIC
);
1133 if (!(dc
= (DC
*)GDI_GetObjPtr( hdc
, METAFILE_DC_MAGIC
))) return 0;
1134 MF_MetaParam1( dc
, META_SETTEXTALIGN
, textAlign
);
1135 GDI_HEAP_UNLOCK( hdc
);
1138 prevAlign
= dc
->w
.textAlign
;
1139 dc
->w
.textAlign
= textAlign
;
1140 GDI_HEAP_UNLOCK( hdc
);
1145 /***********************************************************************
1146 * GetDCOrgEx (GDI32.168)
1148 BOOL32 WINAPI
GetDCOrgEx( HDC32 hDC
, LPPOINT32 lpp
)
1151 if (!lpp
) return FALSE
;
1152 if (!(dc
= (DC
*) GDI_GetObjPtr( hDC
, DC_MAGIC
))) return FALSE
;
1154 if (!(dc
->w
.flags
& DC_MEMORY
))
1157 int w
, h
, border
, depth
;
1158 /* FIXME: this is not correct for managed windows */
1159 TSXGetGeometry( display
, dc
->u
.x
.drawable
, &root
,
1160 &lpp
->x
, &lpp
->y
, &w
, &h
, &border
, &depth
);
1162 else lpp
->x
= lpp
->y
= 0;
1163 lpp
->x
+= dc
->w
.DCOrgX
; lpp
->y
+= dc
->w
.DCOrgY
;
1164 GDI_HEAP_UNLOCK( hDC
);
1169 /***********************************************************************
1172 DWORD WINAPI
GetDCOrg( HDC16 hdc
)
1175 if( GetDCOrgEx( hdc
, &pt
) )
1176 return MAKELONG( (WORD
)pt
.x
, (WORD
)pt
.y
);
1181 /***********************************************************************
1182 * SetDCOrg (GDI.117)
1184 DWORD WINAPI
SetDCOrg( HDC16 hdc
, INT16 x
, INT16 y
)
1187 DC
* dc
= (DC
*) GDI_GetObjPtr( hdc
, DC_MAGIC
);
1189 prevOrg
= dc
->w
.DCOrgX
| (dc
->w
.DCOrgY
<< 16);
1192 GDI_HEAP_UNLOCK( hdc
);
1197 /***********************************************************************
1198 * GetGraphicsMode (GDI32.188)
1200 INT32 WINAPI
GetGraphicsMode( HDC32 hdc
)
1202 DC
* dc
= (DC
*) GDI_GetObjPtr( hdc
, DC_MAGIC
);
1204 return dc
->w
.GraphicsMode
;
1208 /***********************************************************************
1209 * SetGraphicsMode (GDI32.317)
1211 INT32 WINAPI
SetGraphicsMode( HDC32 hdc
, INT32 mode
)
1214 DC
* dc
= (DC
*) GDI_GetObjPtr( hdc
, DC_MAGIC
);
1216 /* One would think that setting the graphics mode to GM_COMPATIBLE
1217 * would also reset the world transformation matrix to the unity
1218 * matrix. However, in Windows, this is not the case. This doesn't
1219 * make a lot of sense to me, but that's the way it is.
1223 if ((mode
<= 0) || (mode
> GM_LAST
)) return 0;
1224 ret
= dc
->w
.GraphicsMode
;
1225 dc
->w
.GraphicsMode
= mode
;
1230 /***********************************************************************
1231 * GetArcDirection16 (GDI.524)
1233 INT16 WINAPI
GetArcDirection16( HDC16 hdc
)
1235 return GetArcDirection32( (HDC32
)hdc
);
1239 /***********************************************************************
1240 * GetArcDirection32 (GDI32.141)
1242 INT32 WINAPI
GetArcDirection32( HDC32 hdc
)
1244 DC
* dc
= (DC
*) GDI_GetObjPtr( hdc
, DC_MAGIC
);
1249 return dc
->w
.ArcDirection
;
1253 /***********************************************************************
1254 * SetArcDirection16 (GDI.525)
1256 INT16 WINAPI
SetArcDirection16( HDC16 hdc
, INT16 nDirection
)
1258 return SetArcDirection32( (HDC32
)hdc
, (INT32
)nDirection
);
1262 /***********************************************************************
1263 * SetArcDirection32 (GDI32.302)
1265 INT32 WINAPI
SetArcDirection32( HDC32 hdc
, INT32 nDirection
)
1267 DC
* dc
= (DC
*) GDI_GetObjPtr( hdc
, DC_MAGIC
);
1268 INT32 nOldDirection
;
1273 if (nDirection
!=AD_COUNTERCLOCKWISE
&& nDirection
!=AD_CLOCKWISE
)
1275 SetLastError(ERROR_INVALID_PARAMETER
);
1279 nOldDirection
= dc
->w
.ArcDirection
;
1280 dc
->w
.ArcDirection
= nDirection
;
1282 return nOldDirection
;
1286 /***********************************************************************
1287 * GetWorldTransform (GDI32.244)
1289 BOOL32 WINAPI
GetWorldTransform( HDC32 hdc
, LPXFORM xform
)
1291 DC
* dc
= (DC
*) GDI_GetObjPtr( hdc
, DC_MAGIC
);
1298 *xform
= dc
->w
.xformWorld2Wnd
;
1304 /***********************************************************************
1305 * SetWorldTransform (GDI32.346)
1307 BOOL32 WINAPI
SetWorldTransform( HDC32 hdc
, const XFORM
*xform
)
1309 DC
* dc
= (DC
*) GDI_GetObjPtr( hdc
, DC_MAGIC
);
1313 SetLastError( ERROR_INVALID_HANDLE
);
1320 /* Check that graphics mode is GM_ADVANCED */
1321 if (dc
->w
.GraphicsMode
!=GM_ADVANCED
)
1324 dc
->w
.xformWorld2Wnd
= *xform
;
1326 DC_UpdateXforms( dc
);
1332 /****************************************************************************
1333 * ModifyWorldTransform [GDI32.253]
1334 * Modifies the world transformation for a device context.
1337 * hdc [I] Handle to device context
1338 * xform [I] XFORM structure that will be used to modify the world
1340 * iMode [I] Specifies in what way to modify the world transformation
1343 * Resets the world transformation to the identity matrix.
1344 * The parameter xform is ignored.
1346 * Multiplies xform into the world transformation matrix from
1349 * Multiplies xform into the world transformation matrix from
1354 BOOL32 WINAPI
ModifyWorldTransform( HDC32 hdc
, const XFORM
*xform
,
1357 DC
* dc
= (DC
*) GDI_GetObjPtr( hdc
, DC_MAGIC
);
1359 /* Check for illegal parameters */
1362 SetLastError( ERROR_INVALID_HANDLE
);
1368 /* Check that graphics mode is GM_ADVANCED */
1369 if (dc
->w
.GraphicsMode
!=GM_ADVANCED
)
1375 dc
->w
.xformWorld2Wnd
.eM11
= 1.0f
;
1376 dc
->w
.xformWorld2Wnd
.eM12
= 0.0f
;
1377 dc
->w
.xformWorld2Wnd
.eM21
= 0.0f
;
1378 dc
->w
.xformWorld2Wnd
.eM22
= 1.0f
;
1379 dc
->w
.xformWorld2Wnd
.eDx
= 0.0f
;
1380 dc
->w
.xformWorld2Wnd
.eDy
= 0.0f
;
1382 case MWT_LEFTMULTIPLY
:
1383 CombineTransform( &dc
->w
.xformWorld2Wnd
, xform
,
1384 &dc
->w
.xformWorld2Wnd
);
1386 case MWT_RIGHTMULTIPLY
:
1387 CombineTransform( &dc
->w
.xformWorld2Wnd
, &dc
->w
.xformWorld2Wnd
,
1394 DC_UpdateXforms( dc
);
1400 /****************************************************************************
1401 * CombineTransform [GDI32.20]
1402 * Combines two transformation matrices.
1405 * xformResult [O] Stores the result of combining the two matrices
1406 * xform1 [I] Specifies the first matrix to apply
1407 * xform2 [I] Specifies the second matrix to apply
1410 * The same matrix can be passed in for more than one of the parameters.
1414 BOOL32 WINAPI
CombineTransform( LPXFORM xformResult
, const XFORM
*xform1
,
1415 const XFORM
*xform2
)
1419 /* Check for illegal parameters */
1420 if (!xformResult
|| !xform1
|| !xform2
)
1423 /* Create the result in a temporary XFORM, since xformResult may be
1424 * equal to xform1 or xform2 */
1425 xformTemp
.eM11
= xform1
->eM11
* xform2
->eM11
+
1426 xform1
->eM12
* xform2
->eM21
;
1427 xformTemp
.eM12
= xform1
->eM11
* xform2
->eM12
+
1428 xform1
->eM12
* xform2
->eM22
;
1429 xformTemp
.eM21
= xform1
->eM21
* xform2
->eM11
+
1430 xform1
->eM22
* xform2
->eM21
;
1431 xformTemp
.eM22
= xform1
->eM21
* xform2
->eM12
+
1432 xform1
->eM22
* xform2
->eM22
;
1433 xformTemp
.eDx
= xform1
->eDx
* xform2
->eM11
+
1434 xform1
->eDy
* xform2
->eM21
+
1436 xformTemp
.eDy
= xform1
->eDx
* xform2
->eM12
+
1437 xform1
->eDy
* xform2
->eM22
+
1440 /* Copy the result to xformResult */
1441 *xformResult
= xformTemp
;
1447 /***********************************************************************
1448 * SetDCHook (GDI.190)
1450 BOOL16 WINAPI
SetDCHook( HDC16 hdc
, FARPROC16 hookProc
, DWORD dwHookData
)
1452 DC
*dc
= (DC
*)GDI_GetObjPtr( hdc
, DC_MAGIC
);
1454 TRACE(dc
, "hookProc %08x, default is %08x\n",
1455 (UINT32
)hookProc
, (UINT32
)DCHook
);
1457 if (!dc
) return FALSE
;
1458 dc
->hookProc
= hookProc
;
1459 dc
->dwHookData
= dwHookData
;
1460 GDI_HEAP_UNLOCK( hdc
);
1465 /***********************************************************************
1466 * GetDCHook (GDI.191)
1468 DWORD WINAPI
GetDCHook( HDC16 hdc
, FARPROC16
*phookProc
)
1470 DC
*dc
= (DC
*)GDI_GetObjPtr( hdc
, DC_MAGIC
);
1472 *phookProc
= dc
->hookProc
;
1473 GDI_HEAP_UNLOCK( hdc
);
1474 return dc
->dwHookData
;
1478 /***********************************************************************
1479 * SetHookFlags (GDI.192)
1481 WORD WINAPI
SetHookFlags(HDC16 hDC
, WORD flags
)
1483 DC
* dc
= (DC
*)GDI_GetObjPtr( hDC
, DC_MAGIC
);
1487 WORD wRet
= dc
->w
.flags
& DC_DIRTY
;
1489 /* "Undocumented Windows" info is slightly confusing.
1492 TRACE(dc
,"hDC %04x, flags %04x\n",hDC
,flags
);
1494 if( flags
& DCHF_INVALIDATEVISRGN
)
1495 dc
->w
.flags
|= DC_DIRTY
;
1496 else if( flags
& DCHF_VALIDATEVISRGN
|| !flags
)
1497 dc
->w
.flags
&= ~DC_DIRTY
;
1498 GDI_HEAP_UNLOCK( hDC
);
1504 /***********************************************************************
1505 * SetICMMode (GDI32.318)
1507 INT32 WINAPI
SetICMMode(HDC32 hdc
, INT32 iEnableICM
)
1509 /*FIXME Asuming that ICM is always off, and cannot be turned on */
1510 if (iEnableICM
== ICM_OFF
) return ICM_OFF
;
1511 if (iEnableICM
== ICM_ON
) return 0;
1512 if (iEnableICM
== ICM_QUERY
) return ICM_OFF
;
1517 /***********************************************************************
1518 * GetColorSpace (GDI32.165)
1520 HCOLORSPACE32 WINAPI
GetColorSpace(HDC32 hdc
)
1522 /*FIXME Need to to whatever GetColorSpace actually does */
1526 /***********************************************************************
1527 * GetBoundsRect16 (GDI.194)
1529 UINT16 WINAPI
GetBoundsRect16(HDC16 hdc
, LPRECT16 rect
, UINT16 flags
)
1531 FIXME(dc
, "(): stub\n");
1532 return DCB_RESET
; /* bounding rectangle always empty */
1535 /***********************************************************************
1536 * SetBoundsRect16 (GDI.193)
1538 UINT16 WINAPI
SetBoundsRect16(HDC16 hdc
, LPRECT16 rect
, UINT16 flags
)
1540 FIXME(dc
, "(): stub\n");
1541 return DCB_DISABLE
; /* bounding rectangle always empty */