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
.bitsPerPixel
= dc
->w
.bitsPerPixel
;
532 newdc
->w
.ROPmode
= dc
->w
.ROPmode
;
533 newdc
->w
.polyFillMode
= dc
->w
.polyFillMode
;
534 newdc
->w
.stretchBltMode
= dc
->w
.stretchBltMode
;
535 newdc
->w
.relAbsMode
= dc
->w
.relAbsMode
;
536 newdc
->w
.backgroundMode
= dc
->w
.backgroundMode
;
537 newdc
->w
.backgroundColor
= dc
->w
.backgroundColor
;
538 newdc
->w
.textColor
= dc
->w
.textColor
;
539 newdc
->w
.brushOrgX
= dc
->w
.brushOrgX
;
540 newdc
->w
.brushOrgY
= dc
->w
.brushOrgY
;
541 newdc
->w
.textAlign
= dc
->w
.textAlign
;
542 newdc
->w
.charExtra
= dc
->w
.charExtra
;
543 newdc
->w
.breakTotalExtra
= dc
->w
.breakTotalExtra
;
544 newdc
->w
.breakCount
= dc
->w
.breakCount
;
545 newdc
->w
.breakExtra
= dc
->w
.breakExtra
;
546 newdc
->w
.breakRem
= dc
->w
.breakRem
;
547 newdc
->w
.MapMode
= dc
->w
.MapMode
;
548 newdc
->w
.GraphicsMode
= dc
->w
.GraphicsMode
;
550 /* Apparently, the DC origin is not changed by [GS]etDCState */
551 newdc
->w
.DCOrgX
= dc
->w
.DCOrgX
;
552 newdc
->w
.DCOrgY
= dc
->w
.DCOrgY
;
554 newdc
->w
.CursPosX
= dc
->w
.CursPosX
;
555 newdc
->w
.CursPosY
= dc
->w
.CursPosY
;
556 newdc
->w
.ArcDirection
= dc
->w
.ArcDirection
;
557 newdc
->w
.xformWorld2Wnd
= dc
->w
.xformWorld2Wnd
;
558 newdc
->w
.xformWorld2Vport
= dc
->w
.xformWorld2Vport
;
559 newdc
->w
.xformVport2World
= dc
->w
.xformVport2World
;
560 newdc
->w
.vport2WorldValid
= dc
->w
.vport2WorldValid
;
561 newdc
->wndOrgX
= dc
->wndOrgX
;
562 newdc
->wndOrgY
= dc
->wndOrgY
;
563 newdc
->wndExtX
= dc
->wndExtX
;
564 newdc
->wndExtY
= dc
->wndExtY
;
565 newdc
->vportOrgX
= dc
->vportOrgX
;
566 newdc
->vportOrgY
= dc
->vportOrgY
;
567 newdc
->vportExtX
= dc
->vportExtX
;
568 newdc
->vportExtY
= dc
->vportExtY
;
570 newdc
->hSelf
= (HDC32
)handle
;
571 newdc
->saveLevel
= 0;
573 PATH_InitGdiPath( &newdc
->w
.path
);
575 /* Get/SetDCState() don't change hVisRgn field ("Undoc. Windows" p.559). */
577 newdc
->w
.hGCClipRgn
= newdc
->w
.hVisRgn
= 0;
580 newdc
->w
.hClipRgn
= CreateRectRgn32( 0, 0, 0, 0 );
581 CombineRgn32( newdc
->w
.hClipRgn
, dc
->w
.hClipRgn
, 0, RGN_COPY
);
584 newdc
->w
.hClipRgn
= 0;
585 GDI_HEAP_UNLOCK( handle
);
586 GDI_HEAP_UNLOCK( hdc
);
591 /***********************************************************************
592 * SetDCState (GDI.180)
594 void WINAPI
SetDCState( HDC16 hdc
, HDC16 hdcs
)
598 if (!(dc
= (DC
*) GDI_GetObjPtr( hdc
, DC_MAGIC
))) return;
599 if (!(dcs
= (DC
*) GDI_GetObjPtr( hdcs
, DC_MAGIC
)))
601 GDI_HEAP_UNLOCK( hdc
);
604 if (!dcs
->w
.flags
& DC_SAVED
)
606 GDI_HEAP_UNLOCK( hdc
);
607 GDI_HEAP_UNLOCK( hdcs
);
610 TRACE(dc
, "%04x %04x\n", hdc
, hdcs
);
612 dc
->w
.flags
= dcs
->w
.flags
& ~DC_SAVED
;
613 dc
->w
.devCaps
= dcs
->w
.devCaps
;
614 dc
->w
.hFirstBitmap
= dcs
->w
.hFirstBitmap
;
615 dc
->w
.hDevice
= dcs
->w
.hDevice
;
616 dc
->w
.ROPmode
= dcs
->w
.ROPmode
;
617 dc
->w
.polyFillMode
= dcs
->w
.polyFillMode
;
618 dc
->w
.stretchBltMode
= dcs
->w
.stretchBltMode
;
619 dc
->w
.relAbsMode
= dcs
->w
.relAbsMode
;
620 dc
->w
.backgroundMode
= dcs
->w
.backgroundMode
;
621 dc
->w
.backgroundColor
= dcs
->w
.backgroundColor
;
622 dc
->w
.textColor
= dcs
->w
.textColor
;
623 dc
->w
.brushOrgX
= dcs
->w
.brushOrgX
;
624 dc
->w
.brushOrgY
= dcs
->w
.brushOrgY
;
625 dc
->w
.textAlign
= dcs
->w
.textAlign
;
626 dc
->w
.charExtra
= dcs
->w
.charExtra
;
627 dc
->w
.breakTotalExtra
= dcs
->w
.breakTotalExtra
;
628 dc
->w
.breakCount
= dcs
->w
.breakCount
;
629 dc
->w
.breakExtra
= dcs
->w
.breakExtra
;
630 dc
->w
.breakRem
= dcs
->w
.breakRem
;
631 dc
->w
.MapMode
= dcs
->w
.MapMode
;
632 dc
->w
.GraphicsMode
= dcs
->w
.GraphicsMode
;
634 /* Apparently, the DC origin is not changed by [GS]etDCState */
635 dc
->w
.DCOrgX
= dcs
->w
.DCOrgX
;
636 dc
->w
.DCOrgY
= dcs
->w
.DCOrgY
;
638 dc
->w
.CursPosX
= dcs
->w
.CursPosX
;
639 dc
->w
.CursPosY
= dcs
->w
.CursPosY
;
640 dc
->w
.ArcDirection
= dcs
->w
.ArcDirection
;
641 dc
->w
.xformWorld2Wnd
= dcs
->w
.xformWorld2Wnd
;
642 dc
->w
.xformWorld2Vport
= dcs
->w
.xformWorld2Vport
;
643 dc
->w
.xformVport2World
= dcs
->w
.xformVport2World
;
644 dc
->w
.vport2WorldValid
= dcs
->w
.vport2WorldValid
;
646 dc
->wndOrgX
= dcs
->wndOrgX
;
647 dc
->wndOrgY
= dcs
->wndOrgY
;
648 dc
->wndExtX
= dcs
->wndExtX
;
649 dc
->wndExtY
= dcs
->wndExtY
;
650 dc
->vportOrgX
= dcs
->vportOrgX
;
651 dc
->vportOrgY
= dcs
->vportOrgY
;
652 dc
->vportExtX
= dcs
->vportExtX
;
653 dc
->vportExtY
= dcs
->vportExtY
;
655 if (!(dc
->w
.flags
& DC_MEMORY
)) dc
->w
.bitsPerPixel
= dcs
->w
.bitsPerPixel
;
659 if (!dc
->w
.hClipRgn
) dc
->w
.hClipRgn
= CreateRectRgn32( 0, 0, 0, 0 );
660 CombineRgn32( dc
->w
.hClipRgn
, dcs
->w
.hClipRgn
, 0, RGN_COPY
);
661 CLIPPING_UpdateGCRegion( dc
);
666 SelectObject32( hdc
, dcs
->w
.hBitmap
);
667 SelectObject32( hdc
, dcs
->w
.hBrush
);
668 SelectObject32( hdc
, dcs
->w
.hFont
);
669 SelectObject32( hdc
, dcs
->w
.hPen
);
670 SetBkColor32( hdc
, dcs
->w
.backgroundColor
);
671 SetTextColor32( hdc
, dcs
->w
.textColor
);
672 GDISelectPalette( hdc
, dcs
->w
.hPalette
, FALSE
);
673 GDI_HEAP_UNLOCK( hdc
);
674 GDI_HEAP_UNLOCK( hdcs
);
678 /***********************************************************************
681 INT16 WINAPI
SaveDC16( HDC16 hdc
)
683 return (INT16
)SaveDC32( hdc
);
687 /***********************************************************************
688 * SaveDC32 (GDI32.292)
690 INT32 WINAPI
SaveDC32( HDC32 hdc
)
696 dc
= (DC
*) GDI_GetObjPtr( hdc
, DC_MAGIC
);
699 dc
= (DC
*)GDI_GetObjPtr(hdc
, METAFILE_DC_MAGIC
);
701 MF_MetaParam0(dc
, META_SAVEDC
);
702 GDI_HEAP_UNLOCK( hdc
);
705 if (!(hdcs
= GetDCState( hdc
)))
707 GDI_HEAP_UNLOCK( hdc
);
710 dcs
= (DC
*) GDI_HEAP_LOCK( hdcs
);
712 /* Copy path. The reason why path saving / restoring is in SaveDC/
713 * RestoreDC and not in GetDCState/SetDCState is that the ...DCState
714 * functions are only in Win16 (which doesn't have paths) and that
715 * SetDCState doesn't allow us to signal an error (which can happen
716 * when copying paths).
718 if (!PATH_AssignGdiPath( &dcs
->w
.path
, &dc
->w
.path
))
720 GDI_HEAP_UNLOCK( hdc
);
721 GDI_HEAP_UNLOCK( hdcs
);
726 dcs
->header
.hNext
= dc
->header
.hNext
;
727 dc
->header
.hNext
= hdcs
;
728 TRACE(dc
, "(%04x): returning %d\n", hdc
, dc
->saveLevel
+1 );
729 ret
= ++dc
->saveLevel
;
730 GDI_HEAP_UNLOCK( hdcs
);
731 GDI_HEAP_UNLOCK( hdc
);
736 /***********************************************************************
737 * RestoreDC16 (GDI.39)
739 BOOL16 WINAPI
RestoreDC16( HDC16 hdc
, INT16 level
)
741 return RestoreDC32( hdc
, level
);
745 /***********************************************************************
746 * RestoreDC32 (GDI32.290)
748 BOOL32 WINAPI
RestoreDC32( HDC32 hdc
, INT32 level
)
753 TRACE(dc
, "%04x %d\n", hdc
, level
);
754 dc
= (DC
*) GDI_GetObjPtr( hdc
, DC_MAGIC
);
757 dc
= (DC
*)GDI_GetObjPtr(hdc
, METAFILE_DC_MAGIC
);
758 if (!dc
) return FALSE
;
761 GDI_HEAP_UNLOCK( hdc
);
764 MF_MetaParam1(dc
, META_RESTOREDC
, level
);
765 GDI_HEAP_UNLOCK( hdc
);
768 if (level
== -1) level
= dc
->saveLevel
;
769 if ((level
< 1) || (level
> dc
->saveLevel
))
771 GDI_HEAP_UNLOCK( hdc
);
776 while (dc
->saveLevel
>= level
)
778 HDC16 hdcs
= dc
->header
.hNext
;
779 if (!(dcs
= (DC
*) GDI_GetObjPtr( hdcs
, DC_MAGIC
)))
781 GDI_HEAP_UNLOCK( hdc
);
784 dc
->header
.hNext
= dcs
->header
.hNext
;
785 if (--dc
->saveLevel
< level
)
787 SetDCState( hdc
, hdcs
);
788 if (!PATH_AssignGdiPath( &dc
->w
.path
, &dcs
->w
.path
))
789 /* FIXME: This might not be quite right, since we're
790 * returning FALSE but still destroying the saved DC state */
795 GDI_HEAP_UNLOCK( hdc
);
800 /***********************************************************************
801 * CreateDC16 (GDI.53)
803 HDC16 WINAPI
CreateDC16( LPCSTR driver
, LPCSTR device
, LPCSTR output
,
804 const DEVMODE16
*initData
)
807 const DC_FUNCTIONS
*funcs
;
809 if (!(funcs
= DRIVER_FindDriver( driver
))) return 0;
810 if (!(dc
= DC_AllocDC( funcs
))) return 0;
813 TRACE(dc
, "(driver=%s, device=%s, output=%s): returning %04x\n",
814 debugstr_a(driver
), debugstr_a(device
), debugstr_a(output
), dc
->hSelf
);
816 if (dc
->funcs
->pCreateDC
&&
817 !dc
->funcs
->pCreateDC( dc
, driver
, device
, output
, initData
))
819 WARN(dc
, "creation aborted by device\n" );
820 GDI_HEAP_FREE( dc
->hSelf
);
825 GDI_HEAP_UNLOCK( dc
->hSelf
);
830 /***********************************************************************
831 * CreateDC32A (GDI32.)
833 HDC32 WINAPI
CreateDC32A( LPCSTR driver
, LPCSTR device
, LPCSTR output
,
834 const DEVMODE32A
*initData
)
836 return CreateDC16( driver
, device
, output
, (const DEVMODE16
*)initData
);
840 /***********************************************************************
841 * CreateDC32W (GDI32.)
843 HDC32 WINAPI
CreateDC32W( LPCWSTR driver
, LPCWSTR device
, LPCWSTR output
,
844 const DEVMODE32W
*initData
)
846 LPSTR driverA
= HEAP_strdupWtoA( GetProcessHeap(), 0, driver
);
847 LPSTR deviceA
= HEAP_strdupWtoA( GetProcessHeap(), 0, device
);
848 LPSTR outputA
= HEAP_strdupWtoA( GetProcessHeap(), 0, output
);
849 HDC32 res
= CreateDC16( driverA
, deviceA
, outputA
,
850 (const DEVMODE16
*)initData
/*FIXME*/ );
851 HeapFree( GetProcessHeap(), 0, driverA
);
852 HeapFree( GetProcessHeap(), 0, deviceA
);
853 HeapFree( GetProcessHeap(), 0, outputA
);
858 /***********************************************************************
859 * CreateIC16 (GDI.153)
861 HDC16 WINAPI
CreateIC16( LPCSTR driver
, LPCSTR device
, LPCSTR output
,
862 const DEVMODE16
* initData
)
864 /* Nothing special yet for ICs */
865 return CreateDC16( driver
, device
, output
, initData
);
869 /***********************************************************************
870 * CreateIC32A (GDI32.49)
872 HDC32 WINAPI
CreateIC32A( LPCSTR driver
, LPCSTR device
, LPCSTR output
,
873 const DEVMODE32A
* initData
)
875 /* Nothing special yet for ICs */
876 return CreateDC32A( driver
, device
, output
, initData
);
880 /***********************************************************************
881 * CreateIC32W (GDI32.50)
883 HDC32 WINAPI
CreateIC32W( LPCWSTR driver
, LPCWSTR device
, LPCWSTR output
,
884 const DEVMODE32W
* initData
)
886 /* Nothing special yet for ICs */
887 return CreateDC32W( driver
, device
, output
, initData
);
891 /***********************************************************************
892 * CreateCompatibleDC16 (GDI.52)
894 HDC16 WINAPI
CreateCompatibleDC16( HDC16 hdc
)
896 return (HDC16
)CreateCompatibleDC32( hdc
);
900 /***********************************************************************
901 * CreateCompatibleDC32 (GDI32.31)
903 HDC32 WINAPI
CreateCompatibleDC32( HDC32 hdc
)
907 const DC_FUNCTIONS
*funcs
;
909 if ((origDC
= (DC
*)GDI_GetObjPtr( hdc
, DC_MAGIC
))) funcs
= origDC
->funcs
;
910 else funcs
= DRIVER_FindDriver( "DISPLAY" );
911 if (!funcs
) return 0;
913 if (!(dc
= DC_AllocDC( funcs
))) return 0;
915 TRACE(dc
, "(%04x): returning %04x\n",
918 /* Create default bitmap */
919 if (!(hbitmap
= CreateBitmap32( 1, 1, 1, 1, NULL
)))
921 GDI_HEAP_FREE( dc
->hSelf
);
924 dc
->w
.flags
= DC_MEMORY
;
925 dc
->w
.bitsPerPixel
= 1;
926 dc
->w
.hBitmap
= hbitmap
;
927 dc
->w
.hFirstBitmap
= hbitmap
;
929 if (dc
->funcs
->pCreateDC
&&
930 !dc
->funcs
->pCreateDC( dc
, NULL
, NULL
, NULL
, NULL
))
932 WARN(dc
, "creation aborted by device\n");
933 DeleteObject32( hbitmap
);
934 GDI_HEAP_FREE( dc
->hSelf
);
939 GDI_HEAP_UNLOCK( dc
->hSelf
);
944 /***********************************************************************
945 * DeleteDC16 (GDI.68)
947 BOOL16 WINAPI
DeleteDC16( HDC16 hdc
)
949 return DeleteDC32( hdc
);
953 /***********************************************************************
954 * DeleteDC32 (GDI32.67)
956 BOOL32 WINAPI
DeleteDC32( HDC32 hdc
)
958 DC
* dc
= (DC
*) GDI_GetObjPtr( hdc
, DC_MAGIC
);
959 if (!dc
) return FALSE
;
961 TRACE(dc
, "%04x\n", hdc
);
963 while (dc
->saveLevel
)
966 HDC16 hdcs
= dc
->header
.hNext
;
967 if (!(dcs
= (DC
*) GDI_GetObjPtr( hdcs
, DC_MAGIC
))) break;
968 dc
->header
.hNext
= dcs
->header
.hNext
;
973 if (!(dc
->w
.flags
& DC_SAVED
))
975 SelectObject32( hdc
, STOCK_BLACK_PEN
);
976 SelectObject32( hdc
, STOCK_WHITE_BRUSH
);
977 SelectObject32( hdc
, STOCK_SYSTEM_FONT
);
978 if (dc
->w
.flags
& DC_MEMORY
) DeleteObject32( dc
->w
.hFirstBitmap
);
979 if (dc
->funcs
->pDeleteDC
) dc
->funcs
->pDeleteDC(dc
);
982 if (dc
->w
.hClipRgn
) DeleteObject32( dc
->w
.hClipRgn
);
983 if (dc
->w
.hVisRgn
) DeleteObject32( dc
->w
.hVisRgn
);
984 if (dc
->w
.hGCClipRgn
) DeleteObject32( dc
->w
.hGCClipRgn
);
986 PATH_DestroyGdiPath(&dc
->w
.path
);
988 return GDI_FreeObject( hdc
);
992 /***********************************************************************
993 * ResetDC16 (GDI.376)
995 HDC16 WINAPI
ResetDC16( HDC16 hdc
, const DEVMODE16
*devmode
)
997 FIXME(dc
, "stub\n" );
1002 /***********************************************************************
1003 * ResetDC32A (GDI32.287)
1005 HDC32 WINAPI
ResetDC32A( HDC32 hdc
, const DEVMODE32A
*devmode
)
1007 FIXME(dc
, "stub\n" );
1012 /***********************************************************************
1013 * ResetDC32W (GDI32.288)
1015 HDC32 WINAPI
ResetDC32W( HDC32 hdc
, const DEVMODE32W
*devmode
)
1017 FIXME(dc
, "stub\n" );
1022 /***********************************************************************
1023 * GetDeviceCaps16 (GDI.80)
1025 INT16 WINAPI
GetDeviceCaps16( HDC16 hdc
, INT16 cap
)
1027 return GetDeviceCaps32( hdc
, cap
);
1031 /***********************************************************************
1032 * GetDeviceCaps32 (GDI32.171)
1034 INT32 WINAPI
GetDeviceCaps32( HDC32 hdc
, INT32 cap
)
1036 DC
* dc
= (DC
*) GDI_GetObjPtr( hdc
, DC_MAGIC
);
1041 if ((cap
< 0) || (cap
> sizeof(DeviceCaps
)-sizeof(WORD
)))
1043 GDI_HEAP_UNLOCK( hdc
);
1047 TRACE(dc
, "(%04x,%d): returning %d\n",
1048 hdc
, cap
, *(WORD
*)(((char *)dc
->w
.devCaps
) + cap
) );
1049 ret
= *(WORD
*)(((char *)dc
->w
.devCaps
) + cap
);
1050 GDI_HEAP_UNLOCK( hdc
);
1055 /***********************************************************************
1056 * SetBkColor16 (GDI.1)
1058 COLORREF WINAPI
SetBkColor16( HDC16 hdc
, COLORREF color
)
1060 return SetBkColor32( hdc
, color
);
1064 /***********************************************************************
1065 * SetBkColor32 (GDI32.305)
1067 COLORREF WINAPI
SetBkColor32( HDC32 hdc
, COLORREF color
)
1070 DC
* dc
= DC_GetDCPtr( hdc
);
1072 if (!dc
) return 0x80000000;
1073 if (dc
->funcs
->pSetBkColor
)
1074 oldColor
= dc
->funcs
->pSetBkColor(dc
, color
);
1076 oldColor
= dc
->w
.backgroundColor
;
1077 dc
->w
.backgroundColor
= color
;
1079 GDI_HEAP_UNLOCK( hdc
);
1084 /***********************************************************************
1085 * SetTextColor16 (GDI.9)
1087 COLORREF WINAPI
SetTextColor16( HDC16 hdc
, COLORREF color
)
1089 return SetTextColor32( hdc
, color
);
1093 /***********************************************************************
1094 * SetTextColor32 (GDI32.338)
1096 COLORREF WINAPI
SetTextColor32( HDC32 hdc
, COLORREF color
)
1099 DC
* dc
= DC_GetDCPtr( hdc
);
1101 if (!dc
) return 0x80000000;
1102 if (dc
->funcs
->pSetTextColor
)
1103 oldColor
= dc
->funcs
->pSetTextColor(dc
, color
);
1105 oldColor
= dc
->w
.textColor
;
1106 dc
->w
.textColor
= color
;
1108 GDI_HEAP_UNLOCK( hdc
);
1113 /***********************************************************************
1114 * SetTextAlign16 (GDI.346)
1116 UINT16 WINAPI
SetTextAlign16( HDC16 hdc
, UINT16 textAlign
)
1118 return SetTextAlign32( hdc
, textAlign
);
1122 /***********************************************************************
1123 * SetTextAlign32 (GDI32.336)
1125 UINT32 WINAPI
SetTextAlign32( HDC32 hdc
, UINT32 textAlign
)
1128 DC
* dc
= (DC
*) GDI_GetObjPtr( hdc
, DC_MAGIC
);
1131 if (!(dc
= (DC
*)GDI_GetObjPtr( hdc
, METAFILE_DC_MAGIC
))) return 0;
1132 MF_MetaParam1( dc
, META_SETTEXTALIGN
, textAlign
);
1133 GDI_HEAP_UNLOCK( hdc
);
1136 prevAlign
= dc
->w
.textAlign
;
1137 dc
->w
.textAlign
= textAlign
;
1138 GDI_HEAP_UNLOCK( hdc
);
1143 /***********************************************************************
1144 * GetDCOrgEx (GDI32.168)
1146 BOOL32 WINAPI
GetDCOrgEx( HDC32 hDC
, LPPOINT32 lpp
)
1149 if (!lpp
) return FALSE
;
1150 if (!(dc
= (DC
*) GDI_GetObjPtr( hDC
, DC_MAGIC
))) return FALSE
;
1152 if (!(dc
->w
.flags
& DC_MEMORY
))
1155 int w
, h
, border
, depth
;
1156 /* FIXME: this is not correct for managed windows */
1157 TSXGetGeometry( display
, dc
->u
.x
.drawable
, &root
,
1158 &lpp
->x
, &lpp
->y
, &w
, &h
, &border
, &depth
);
1160 else lpp
->x
= lpp
->y
= 0;
1161 lpp
->x
+= dc
->w
.DCOrgX
; lpp
->y
+= dc
->w
.DCOrgY
;
1162 GDI_HEAP_UNLOCK( hDC
);
1167 /***********************************************************************
1170 DWORD WINAPI
GetDCOrg( HDC16 hdc
)
1173 if( GetDCOrgEx( hdc
, &pt
) )
1174 return MAKELONG( (WORD
)pt
.x
, (WORD
)pt
.y
);
1179 /***********************************************************************
1180 * SetDCOrg (GDI.117)
1182 DWORD WINAPI
SetDCOrg( HDC16 hdc
, INT16 x
, INT16 y
)
1185 DC
* dc
= (DC
*) GDI_GetObjPtr( hdc
, DC_MAGIC
);
1187 prevOrg
= dc
->w
.DCOrgX
| (dc
->w
.DCOrgY
<< 16);
1190 GDI_HEAP_UNLOCK( hdc
);
1195 /***********************************************************************
1196 * GetGraphicsMode (GDI32.188)
1198 INT32 WINAPI
GetGraphicsMode( HDC32 hdc
)
1200 DC
* dc
= (DC
*) GDI_GetObjPtr( hdc
, DC_MAGIC
);
1202 return dc
->w
.GraphicsMode
;
1206 /***********************************************************************
1207 * SetGraphicsMode (GDI32.317)
1209 INT32 WINAPI
SetGraphicsMode( HDC32 hdc
, INT32 mode
)
1212 DC
* dc
= (DC
*) GDI_GetObjPtr( hdc
, DC_MAGIC
);
1214 /* One would think that setting the graphics mode to GM_COMPATIBLE
1215 * would also reset the world transformation matrix to the unity
1216 * matrix. However, in Windows, this is not the case. This doesn't
1217 * make a lot of sense to me, but that's the way it is.
1221 if ((mode
<= 0) || (mode
> GM_LAST
)) return 0;
1222 ret
= dc
->w
.GraphicsMode
;
1223 dc
->w
.GraphicsMode
= mode
;
1228 /***********************************************************************
1229 * GetArcDirection16 (GDI.524)
1231 INT16 WINAPI
GetArcDirection16( HDC16 hdc
)
1233 return GetArcDirection32( (HDC32
)hdc
);
1237 /***********************************************************************
1238 * GetArcDirection32 (GDI32.141)
1240 INT32 WINAPI
GetArcDirection32( HDC32 hdc
)
1242 DC
* dc
= (DC
*) GDI_GetObjPtr( hdc
, DC_MAGIC
);
1247 return dc
->w
.ArcDirection
;
1251 /***********************************************************************
1252 * SetArcDirection16 (GDI.525)
1254 INT16 WINAPI
SetArcDirection16( HDC16 hdc
, INT16 nDirection
)
1256 return SetArcDirection32( (HDC32
)hdc
, (INT32
)nDirection
);
1260 /***********************************************************************
1261 * SetArcDirection32 (GDI32.302)
1263 INT32 WINAPI
SetArcDirection32( HDC32 hdc
, INT32 nDirection
)
1265 DC
* dc
= (DC
*) GDI_GetObjPtr( hdc
, DC_MAGIC
);
1266 INT32 nOldDirection
;
1271 if (nDirection
!=AD_COUNTERCLOCKWISE
&& nDirection
!=AD_CLOCKWISE
)
1273 SetLastError(ERROR_INVALID_PARAMETER
);
1277 nOldDirection
= dc
->w
.ArcDirection
;
1278 dc
->w
.ArcDirection
= nDirection
;
1280 return nOldDirection
;
1284 /***********************************************************************
1285 * GetWorldTransform (GDI32.244)
1287 BOOL32 WINAPI
GetWorldTransform( HDC32 hdc
, LPXFORM xform
)
1289 DC
* dc
= (DC
*) GDI_GetObjPtr( hdc
, DC_MAGIC
);
1296 *xform
= dc
->w
.xformWorld2Wnd
;
1302 /***********************************************************************
1303 * SetWorldTransform (GDI32.346)
1305 BOOL32 WINAPI
SetWorldTransform( HDC32 hdc
, const XFORM
*xform
)
1307 DC
* dc
= (DC
*) GDI_GetObjPtr( hdc
, DC_MAGIC
);
1311 SetLastError( ERROR_INVALID_HANDLE
);
1318 /* Check that graphics mode is GM_ADVANCED */
1319 if (dc
->w
.GraphicsMode
!=GM_ADVANCED
)
1322 dc
->w
.xformWorld2Wnd
= *xform
;
1324 DC_UpdateXforms( dc
);
1330 /****************************************************************************
1331 * ModifyWorldTransform [GDI32.253]
1332 * Modifies the world transformation for a device context.
1335 * hdc [I] Handle to device context
1336 * xform [I] XFORM structure that will be used to modify the world
1338 * iMode [I] Specifies in what way to modify the world transformation
1341 * Resets the world transformation to the identity matrix.
1342 * The parameter xform is ignored.
1344 * Multiplies xform into the world transformation matrix from
1347 * Multiplies xform into the world transformation matrix from
1352 BOOL32 WINAPI
ModifyWorldTransform( HDC32 hdc
, const XFORM
*xform
,
1355 DC
* dc
= (DC
*) GDI_GetObjPtr( hdc
, DC_MAGIC
);
1357 /* Check for illegal parameters */
1360 SetLastError( ERROR_INVALID_HANDLE
);
1366 /* Check that graphics mode is GM_ADVANCED */
1367 if (dc
->w
.GraphicsMode
!=GM_ADVANCED
)
1373 dc
->w
.xformWorld2Wnd
.eM11
= 1.0f
;
1374 dc
->w
.xformWorld2Wnd
.eM12
= 0.0f
;
1375 dc
->w
.xformWorld2Wnd
.eM21
= 0.0f
;
1376 dc
->w
.xformWorld2Wnd
.eM22
= 1.0f
;
1377 dc
->w
.xformWorld2Wnd
.eDx
= 0.0f
;
1378 dc
->w
.xformWorld2Wnd
.eDy
= 0.0f
;
1380 case MWT_LEFTMULTIPLY
:
1381 CombineTransform( &dc
->w
.xformWorld2Wnd
, xform
,
1382 &dc
->w
.xformWorld2Wnd
);
1384 case MWT_RIGHTMULTIPLY
:
1385 CombineTransform( &dc
->w
.xformWorld2Wnd
, &dc
->w
.xformWorld2Wnd
,
1392 DC_UpdateXforms( dc
);
1398 /****************************************************************************
1399 * CombineTransform [GDI32.20]
1400 * Combines two transformation matrices.
1403 * xformResult [O] Stores the result of combining the two matrices
1404 * xform1 [I] Specifies the first matrix to apply
1405 * xform2 [I] Specifies the second matrix to apply
1408 * The same matrix can be passed in for more than one of the parameters.
1412 BOOL32 WINAPI
CombineTransform( LPXFORM xformResult
, const XFORM
*xform1
,
1413 const XFORM
*xform2
)
1417 /* Check for illegal parameters */
1418 if (!xformResult
|| !xform1
|| !xform2
)
1421 /* Create the result in a temporary XFORM, since xformResult may be
1422 * equal to xform1 or xform2 */
1423 xformTemp
.eM11
= xform1
->eM11
* xform2
->eM11
+
1424 xform1
->eM12
* xform2
->eM21
;
1425 xformTemp
.eM12
= xform1
->eM11
* xform2
->eM12
+
1426 xform1
->eM12
* xform2
->eM22
;
1427 xformTemp
.eM21
= xform1
->eM21
* xform2
->eM11
+
1428 xform1
->eM22
* xform2
->eM21
;
1429 xformTemp
.eM22
= xform1
->eM21
* xform2
->eM12
+
1430 xform1
->eM22
* xform2
->eM22
;
1431 xformTemp
.eDx
= xform1
->eDx
* xform2
->eM11
+
1432 xform1
->eDy
* xform2
->eM21
+
1434 xformTemp
.eDy
= xform1
->eDx
* xform2
->eM12
+
1435 xform1
->eDy
* xform2
->eM22
+
1438 /* Copy the result to xformResult */
1439 *xformResult
= xformTemp
;
1445 /***********************************************************************
1446 * SetDCHook (GDI.190)
1448 BOOL16 WINAPI
SetDCHook( HDC16 hdc
, FARPROC16 hookProc
, DWORD dwHookData
)
1450 DC
*dc
= (DC
*)GDI_GetObjPtr( hdc
, DC_MAGIC
);
1452 TRACE(dc
, "hookProc %08x, default is %08x\n",
1453 (UINT32
)hookProc
, (UINT32
)DCHook
);
1455 if (!dc
) return FALSE
;
1456 dc
->hookProc
= hookProc
;
1457 dc
->dwHookData
= dwHookData
;
1458 GDI_HEAP_UNLOCK( hdc
);
1463 /***********************************************************************
1464 * GetDCHook (GDI.191)
1466 DWORD WINAPI
GetDCHook( HDC16 hdc
, FARPROC16
*phookProc
)
1468 DC
*dc
= (DC
*)GDI_GetObjPtr( hdc
, DC_MAGIC
);
1470 *phookProc
= dc
->hookProc
;
1471 GDI_HEAP_UNLOCK( hdc
);
1472 return dc
->dwHookData
;
1476 /***********************************************************************
1477 * SetHookFlags (GDI.192)
1479 WORD WINAPI
SetHookFlags(HDC16 hDC
, WORD flags
)
1481 DC
* dc
= (DC
*)GDI_GetObjPtr( hDC
, DC_MAGIC
);
1485 WORD wRet
= dc
->w
.flags
& DC_DIRTY
;
1487 /* "Undocumented Windows" info is slightly confusing.
1490 TRACE(dc
,"hDC %04x, flags %04x\n",hDC
,flags
);
1492 if( flags
& DCHF_INVALIDATEVISRGN
)
1493 dc
->w
.flags
|= DC_DIRTY
;
1494 else if( flags
& DCHF_VALIDATEVISRGN
|| !flags
)
1495 dc
->w
.flags
&= ~DC_DIRTY
;
1496 GDI_HEAP_UNLOCK( hDC
);
1502 /***********************************************************************
1503 * SetICMMode (GDI32.318)
1505 INT32 WINAPI
SetICMMode(HDC32 hdc
, INT32 iEnableICM
)
1507 /*FIXME Asuming that ICM is always off, and cannot be turned on */
1508 if (iEnableICM
== ICM_OFF
) return ICM_OFF
;
1509 if (iEnableICM
== ICM_ON
) return 0;
1510 if (iEnableICM
== ICM_QUERY
) return ICM_OFF
;
1515 /***********************************************************************
1516 * GetColorSpace (GDI32.165)
1518 HCOLORSPACE32 WINAPI
GetColorSpace(HDC32 hdc
)
1520 /*FIXME Need to to whatever GetColorSpace actually does */
1524 /***********************************************************************
1525 * GetBoundsRect16 (GDI.194)
1527 UINT16 WINAPI
GetBoundsRect16(HDC16 hdc
, LPRECT16 rect
, UINT16 flags
)
1529 FIXME(dc
, "(): stub\n");
1530 return DCB_RESET
; /* bounding rectangle always empty */
1533 /***********************************************************************
1534 * SetBoundsRect16 (GDI.193)
1536 UINT16 WINAPI
SetBoundsRect16(HDC16 hdc
, LPRECT16 rect
, UINT16 flags
)
1538 FIXME(dc
, "(): stub\n");
1539 return DCB_DISABLE
; /* bounding rectangle always empty */