?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Release 980913
[wine/multimedia.git] / objects / dc.c
blobb1ad95e1db1071ca7f6fe8e3e5df0c7b17db4569
1 /*
2 * GDI Device Context functions
3 *
4 * Copyright 1993 Alexandre Julliard
5 *
6 */
7
8 #include <stdlib.h>
9 #include <string.h>
10 #include "dc.h"
11 #include "gdi.h"
12 #include "heap.h"
13 #include "metafile.h"
14 #include "color.h"
15 #include "debug.h"
16 #include "font.h"
17 #include "winerror.h"
18 #include "x11font.h"
19
20 /* ROP code to GC function conversion */
21 const int DC_XROPfunction[16] =
22 {
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 */
33 GXnoop, /* R2_NOP */
34 GXorInverted, /* R2_MERGENOTPEN */
35 GXcopy, /* R2_COPYPEN */
36 GXorReverse, /* R2_MERGEPENNOT */
37 GXor, /* R2_MERGEPEN */
38 GXset /* R2_WHITE */
39 };
40
41
42 /***********************************************************************
43 * DC_FillDevCaps
44 *
45 * Fill the device caps structure.
46 */
47 void DC_FillDevCaps( DeviceCaps * caps )
48 {
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;
56 caps->planes = 1;
57 caps->numBrushes = 16+6; /* 16 solid + 6 hatched brushes */
58 caps->numPens = 16; /* 16 solid pens */
59 caps->numMarkers = 0;
60 caps->numFonts = 0;
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;
77
78 if( !(COLOR_GetSystemPaletteFlags() & COLOR_VIRTUAL) )
79 caps->rasterCaps |= RC_PALETTE;
80
81 caps->aspectX = 36; /* ?? */
82 caps->aspectY = 36; /* ?? */
83 caps->aspectXY = 51;
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
88 : 0;
89 caps->numReserved = 0;
90 caps->colorRes = 0;
91 }
92
93
94 /***********************************************************************
95 * DC_Init_DC_INFO
96 *
97 * Fill the WIN_DC_INFO structure.
98 */
99 static void DC_Init_DC_INFO( WIN_DC_INFO *win_dc_info )
100 {
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;
146
147 PATH_InitGdiPath(&win_dc_info->path);
148 }
149
150
151 /***********************************************************************
152 * DC_AllocDC
153 */
154 DC *DC_AllocDC( const DC_FUNCTIONS *funcs )
155 {
156 HDC16 hdc;
157 DC *dc;
158
159 if (!(hdc = GDI_AllocObject( sizeof(DC), DC_MAGIC ))) return NULL;
160 dc = (DC *) GDI_HEAP_LOCK( hdc );
161
162 dc->hSelf = hdc;
163 dc->funcs = funcs;
164 dc->physDev = NULL;
165 dc->saveLevel = 0;
166 dc->dwHookData = 0L;
167 dc->hookProc = NULL;
168 dc->wndOrgX = 0;
169 dc->wndOrgY = 0;
170 dc->wndExtX = 1;
171 dc->wndExtY = 1;
172 dc->vportOrgX = 0;
173 dc->vportOrgY = 0;
174 dc->vportExtX = 1;
175 dc->vportExtY = 1;
176
177 DC_Init_DC_INFO( &dc->w );
178
179 return dc;
180 }
181
182
183
184 /***********************************************************************
185 * DC_GetDCPtr
186 */
187 DC *DC_GetDCPtr( HDC32 hdc )
188 {
189 GDIOBJHDR *ptr = (GDIOBJHDR *)GDI_HEAP_LOCK( hdc );
190 if (!ptr) return NULL;
191 if ((ptr->wMagic == DC_MAGIC) || (ptr->wMagic == METAFILE_DC_MAGIC))
192 return (DC *)ptr;
193 GDI_HEAP_UNLOCK( hdc );
194 return NULL;
195 }
196
197
198 /***********************************************************************
199 * DC_InitDC
200 *
201 * Setup device-specific DC values for a newly created DC.
202 */
203 void DC_InitDC( DC* dc )
204 {
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 );
212 }
213
214
215 /***********************************************************************
216 * DC_SetupGCForPatBlt
217 *
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.
221 */
222 BOOL32 DC_SetupGCForPatBlt( DC * dc, GC gc, BOOL32 fMapColors )
223 {
224 XGCValues val;
225 unsigned long mask;
226 Pixmap pixmap = 0;
227
228 if (dc->u.x.brush.style == BS_NULL) return FALSE;
229 if (dc->u.x.brush.pixel == -1)
230 {
231 /* Special case used for monochrome pattern brushes.
232 * We need to swap foreground and background because
233 * Windows does it the wrong way...
234 */
235 val.foreground = dc->u.x.backgroundPixel;
236 val.background = dc->u.x.textPixel;
237 }
238 else
239 {
240 val.foreground = dc->u.x.brush.pixel;
241 val.background = dc->u.x.backgroundPixel;
242 }
243 if (fMapColors && COLOR_PixelToPalette)
244 {
245 val.foreground = COLOR_PixelToPalette[val.foreground];
246 val.background = COLOR_PixelToPalette[val.background];
247 }
248
249 if (dc->w.flags & DC_DIRTY) CLIPPING_UpdateGCRegion(dc);
250
251 val.function = DC_XROPfunction[dc->w.ROPmode-1];
252 /*
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
256 */
257 if (val.function == GXinvert)
258 {
259 val.foreground = BlackPixelOfScreen(screen) ^ WhitePixelOfScreen(screen);
260 val.function = GXxor;
261 }
262 val.fill_style = dc->u.x.brush.fillStyle;
263 switch(val.fill_style)
264 {
265 case FillStippled:
266 case FillOpaqueStippled:
267 if (dc->w.backgroundMode==OPAQUE) val.fill_style = FillOpaqueStippled;
268 val.stipple = dc->u.x.brush.pixmap;
269 mask = GCStipple;
270 break;
271
272 case FillTiled:
273 if (fMapColors && COLOR_PixelToPalette)
274 {
275 register int x, y;
276 XImage *image;
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 );
288 val.tile = pixmap;
289 }
290 else val.tile = dc->u.x.brush.pixmap;
291 mask = GCTile;
292 break;
293
294 default:
295 mask = 0;
296 break;
297 }
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,
304 &val );
305 if (pixmap) TSXFreePixmap( display, pixmap );
306 return TRUE;
307 }
308
309
310 /***********************************************************************
311 * DC_SetupGCForBrush
312 *
313 * Setup dc->u.x.gc for drawing operations using current brush.
314 * Return FALSE if brush is BS_NULL, TRUE otherwise.
315 */
316 BOOL32 DC_SetupGCForBrush( DC * dc )
317 {
318 return DC_SetupGCForPatBlt( dc, dc->u.x.gc, FALSE );
319 }
320
321
322 /***********************************************************************
323 * DC_SetupGCForPen
324 *
325 * Setup dc->u.x.gc for drawing operations using current pen.
326 * Return FALSE if pen is PS_NULL, TRUE otherwise.
327 */
328 BOOL32 DC_SetupGCForPen( DC * dc )
329 {
330 XGCValues val;
331
332 if (dc->u.x.pen.style == PS_NULL) return FALSE;
333
334 if (dc->w.flags & DC_DIRTY) CLIPPING_UpdateGCRegion(dc);
335
336 switch (dc->w.ROPmode)
337 {
338 case R2_BLACK :
339 val.foreground = BlackPixelOfScreen( screen );
340 val.function = GXcopy;
341 break;
342 case R2_WHITE :
343 val.foreground = WhitePixelOfScreen( screen );
344 val.function = GXcopy;
345 break;
346 case R2_XORPEN :
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;
354 break;
355 default :
356 val.foreground = dc->u.x.pen.pixel;
357 val.function = DC_XROPfunction[dc->w.ROPmode-1];
358 }
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))
362 {
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;
367 }
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;
372 } else {
373 switch (dc->u.x.pen.endcap)
374 {
375 case PS_ENDCAP_SQUARE:
376 val.cap_style = CapProjecting;
377 break;
378 case PS_ENDCAP_FLAT:
379 val.cap_style = CapButt;
380 break;
381 case PS_ENDCAP_ROUND:
382 default:
383 val.cap_style = CapRound;
384 }
385 }
386 switch (dc->u.x.pen.linejoin)
387 {
388 case PS_JOIN_BEVEL:
389 val.join_style = JoinBevel;
390 break;
391 case PS_JOIN_MITER:
392 val.join_style = JoinMiter;
393 break;
394 case PS_JOIN_ROUND:
395 default:
396 val.join_style = JoinRound;
397 }
398 TSXChangeGC( display, dc->u.x.gc,
399 GCFunction | GCForeground | GCBackground | GCLineWidth |
400 GCLineStyle | GCCapStyle | GCJoinStyle | GCFillStyle, &val );
401 return TRUE;
402 }
403
404
405 /***********************************************************************
406 * DC_SetupGCForText
407 *
408 * Setup dc->u.x.gc for text drawing operations.
409 * Return FALSE if the font is null, TRUE otherwise.
410 */
411 BOOL32 DC_SetupGCForText( DC * dc )
412 {
413 XFontStruct* xfs = XFONT_GetFontStruct( dc->u.x.font );
414
415 if( xfs )
416 {
417 XGCValues val;
418
419 if (dc->w.flags & DC_DIRTY) CLIPPING_UpdateGCRegion(dc);
420
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;
425 val.font = xfs->fid;
426
427 TSXChangeGC( display, dc->u.x.gc,
428 GCFunction | GCForeground | GCBackground | GCFillStyle |
429 GCFont, &val );
430 return TRUE;
431 }
432 WARN(dc, "Physical font failure\n" );
433 return FALSE;
434 }
435
436
437 /***********************************************************************
438 * DC_InvertXform
439 *
440 * Computes the inverse of the transformation xformSrc and stores it to
441 * xformDest. Returns TRUE if successful or FALSE if the xformSrc matrix
442 * is singular.
443 */
444 static BOOL32 DC_InvertXform( const XFORM *xformSrc, XFORM *xformDest )
445 {
446 FLOAT determinant;
447
448 determinant = xformSrc->eM11*xformSrc->eM22 -
449 xformSrc->eM12*xformSrc->eM21;
450 if (determinant > -1e-12 && determinant < 1e-12)
451 return FALSE;
452
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;
461
462 return TRUE;
463 }
464
465
466 /***********************************************************************
467 * DC_UpdateXforms
468 *
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.
475 */
476 void DC_UpdateXforms( DC *dc )
477 {
478 XFORM xformWnd2Vport;
479 FLOAT scaleX, scaleY;
480
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;
492
493 /* Combine with the world transformation */
494 CombineTransform( &dc->w.xformWorld2Vport, &dc->w.xformWorld2Wnd,
495 &xformWnd2Vport );
496
497 /* Create inverse of world-to-viewport transformation */
498 dc->w.vport2WorldValid = DC_InvertXform( &dc->w.xformWorld2Vport,
499 &dc->w.xformVport2World );
500 }
501
502
503 /***********************************************************************
504 * GetDCState (GDI.179)
505 */
506 HDC16 WINAPI GetDCState( HDC16 hdc )
507 {
508 DC * newdc, * dc;
509 HGDIOBJ16 handle;
510
511 if (!(dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC ))) return 0;
512 if (!(handle = GDI_AllocObject( sizeof(DC), DC_MAGIC )))
513 {
514 GDI_HEAP_UNLOCK( hdc );
515 return 0;
516 }
517 newdc = (DC *) GDI_HEAP_LOCK( handle );
518
519 TRACE(dc, "(%04x): returning %04x\n", hdc, handle );
520
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;
549 newdc->w.DCOrgX = dc->w.DCOrgX;
550 newdc->w.DCOrgY = dc->w.DCOrgY;
551 newdc->w.CursPosX = dc->w.CursPosX;
552 newdc->w.CursPosY = dc->w.CursPosY;
553 newdc->w.ArcDirection = dc->w.ArcDirection;
554 newdc->w.xformWorld2Wnd = dc->w.xformWorld2Wnd;
555 newdc->w.xformWorld2Vport = dc->w.xformWorld2Vport;
556 newdc->w.xformVport2World = dc->w.xformVport2World;
557 newdc->w.vport2WorldValid = dc->w.vport2WorldValid;
558 newdc->wndOrgX = dc->wndOrgX;
559 newdc->wndOrgY = dc->wndOrgY;
560 newdc->wndExtX = dc->wndExtX;
561 newdc->wndExtY = dc->wndExtY;
562 newdc->vportOrgX = dc->vportOrgX;
563 newdc->vportOrgY = dc->vportOrgY;
564 newdc->vportExtX = dc->vportExtX;
565 newdc->vportExtY = dc->vportExtY;
566
567 newdc->hSelf = (HDC32)handle;
568 newdc->saveLevel = 0;
569
570 PATH_InitGdiPath( &newdc->w.path );
571
572 /* Get/SetDCState() don't change hVisRgn field ("Undoc. Windows" p.559). */
573
574 newdc->w.hGCClipRgn = newdc->w.hVisRgn = 0;
575 if (dc->w.hClipRgn)
576 {
577 newdc->w.hClipRgn = CreateRectRgn32( 0, 0, 0, 0 );
578 CombineRgn32( newdc->w.hClipRgn, dc->w.hClipRgn, 0, RGN_COPY );
579 }
580 else
581 newdc->w.hClipRgn = 0;
582 GDI_HEAP_UNLOCK( handle );
583 GDI_HEAP_UNLOCK( hdc );
584 return handle;
585 }
586
587
588 /***********************************************************************
589 * SetDCState (GDI.180)
590 */
591 void WINAPI SetDCState( HDC16 hdc, HDC16 hdcs )
592 {
593 DC *dc, *dcs;
594
595 if (!(dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC ))) return;
596 if (!(dcs = (DC *) GDI_GetObjPtr( hdcs, DC_MAGIC )))
597 {
598 GDI_HEAP_UNLOCK( hdc );
599 return;
600 }
601 if (!dcs->w.flags & DC_SAVED)
602 {
603 GDI_HEAP_UNLOCK( hdc );
604 GDI_HEAP_UNLOCK( hdcs );
605 return;
606 }
607 TRACE(dc, "%04x %04x\n", hdc, hdcs );
608
609 dc->w.flags = dcs->w.flags & ~DC_SAVED;
610 dc->w.devCaps = dcs->w.devCaps;
611 dc->w.hFirstBitmap = dcs->w.hFirstBitmap;
612 dc->w.hDevice = dcs->w.hDevice;
613 dc->w.ROPmode = dcs->w.ROPmode;
614 dc->w.polyFillMode = dcs->w.polyFillMode;
615 dc->w.stretchBltMode = dcs->w.stretchBltMode;
616 dc->w.relAbsMode = dcs->w.relAbsMode;
617 dc->w.backgroundMode = dcs->w.backgroundMode;
618 dc->w.backgroundColor = dcs->w.backgroundColor;
619 dc->w.textColor = dcs->w.textColor;
620 dc->w.brushOrgX = dcs->w.brushOrgX;
621 dc->w.brushOrgY = dcs->w.brushOrgY;
622 dc->w.textAlign = dcs->w.textAlign;
623 dc->w.charExtra = dcs->w.charExtra;
624 dc->w.breakTotalExtra = dcs->w.breakTotalExtra;
625 dc->w.breakCount = dcs->w.breakCount;
626 dc->w.breakExtra = dcs->w.breakExtra;
627 dc->w.breakRem = dcs->w.breakRem;
628 dc->w.MapMode = dcs->w.MapMode;
629 dc->w.GraphicsMode = dcs->w.GraphicsMode;
630 dc->w.DCOrgX = dcs->w.DCOrgX;
631 dc->w.DCOrgY = dcs->w.DCOrgY;
632 dc->w.CursPosX = dcs->w.CursPosX;
633 dc->w.CursPosY = dcs->w.CursPosY;
634 dc->w.ArcDirection = dcs->w.ArcDirection;
635 dc->w.xformWorld2Wnd = dcs->w.xformWorld2Wnd;
636 dc->w.xformWorld2Vport = dcs->w.xformWorld2Vport;
637 dc->w.xformVport2World = dcs->w.xformVport2World;
638 dc->w.vport2WorldValid = dcs->w.vport2WorldValid;
639
640 dc->wndOrgX = dcs->wndOrgX;
641 dc->wndOrgY = dcs->wndOrgY;
642 dc->wndExtX = dcs->wndExtX;
643 dc->wndExtY = dcs->wndExtY;
644 dc->vportOrgX = dcs->vportOrgX;
645 dc->vportOrgY = dcs->vportOrgY;
646 dc->vportExtX = dcs->vportExtX;
647 dc->vportExtY = dcs->vportExtY;
648
649 if (!(dc->w.flags & DC_MEMORY)) dc->w.bitsPerPixel = dcs->w.bitsPerPixel;
650 SelectClipRgn32( hdc, dcs->w.hClipRgn );
651
652 SelectObject32( hdc, dcs->w.hBitmap );
653 SelectObject32( hdc, dcs->w.hBrush );
654 SelectObject32( hdc, dcs->w.hFont );
655 SelectObject32( hdc, dcs->w.hPen );
656 SetBkColor32( hdc, dcs->w.backgroundColor);
657 SetTextColor32( hdc, dcs->w.textColor);
658 GDISelectPalette( hdc, dcs->w.hPalette, FALSE );
659 GDI_HEAP_UNLOCK( hdc );
660 GDI_HEAP_UNLOCK( hdcs );
661 }
662
663
664 /***********************************************************************
665 * SaveDC16 (GDI.30)
666 */
667 INT16 WINAPI SaveDC16( HDC16 hdc )
668 {
669 return (INT16)SaveDC32( hdc );
670 }
671
672
673 /***********************************************************************
674 * SaveDC32 (GDI32.292)
675 */
676 INT32 WINAPI SaveDC32( HDC32 hdc )
677 {
678 HDC32 hdcs;
679 DC * dc, * dcs;
680 INT32 ret;
681
682 dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
683 if (!dc)
684 {
685 dc = (DC *)GDI_GetObjPtr(hdc, METAFILE_DC_MAGIC);
686 if (!dc) return 0;
687 MF_MetaParam0(dc, META_SAVEDC);
688 GDI_HEAP_UNLOCK( hdc );
689 return 1; /* ?? */
690 }
691 if (!(hdcs = GetDCState( hdc )))
692 {
693 GDI_HEAP_UNLOCK( hdc );
694 return 0;
695 }
696 dcs = (DC *) GDI_HEAP_LOCK( hdcs );
697
698 /* Copy path. The reason why path saving / restoring is in SaveDC/
699 * RestoreDC and not in GetDCState/SetDCState is that the ...DCState
700 * functions are only in Win16 (which doesn't have paths) and that
701 * SetDCState doesn't allow us to signal an error (which can happen
702 * when copying paths).
703 */
704 if (!PATH_AssignGdiPath( &dcs->w.path, &dc->w.path ))
705 {
706 GDI_HEAP_UNLOCK( hdc );
707 GDI_HEAP_UNLOCK( hdcs );
708 DeleteDC32( hdcs );
709 return 0;
710 }
711
712 dcs->header.hNext = dc->header.hNext;
713 dc->header.hNext = hdcs;
714 TRACE(dc, "(%04x): returning %d\n", hdc, dc->saveLevel+1 );
715 ret = ++dc->saveLevel;
716 GDI_HEAP_UNLOCK( hdcs );
717 GDI_HEAP_UNLOCK( hdc );
718 return ret;
719 }
720
721
722 /***********************************************************************
723 * RestoreDC16 (GDI.39)
724 */
725 BOOL16 WINAPI RestoreDC16( HDC16 hdc, INT16 level )
726 {
727 return RestoreDC32( hdc, level );
728 }
729
730
731 /***********************************************************************
732 * RestoreDC32 (GDI32.290)
733 */
734 BOOL32 WINAPI RestoreDC32( HDC32 hdc, INT32 level )
735 {
736 DC * dc, * dcs;
737 BOOL32 success;
738
739 TRACE(dc, "%04x %d\n", hdc, level );
740 dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
741 if (!dc)
742 {
743 dc = (DC *)GDI_GetObjPtr(hdc, METAFILE_DC_MAGIC);
744 if (!dc) return FALSE;
745 if (level != -1)
746 {
747 GDI_HEAP_UNLOCK( hdc );
748 return FALSE;
749 }
750 MF_MetaParam1(dc, META_RESTOREDC, level);
751 GDI_HEAP_UNLOCK( hdc );
752 return TRUE;
753 }
754 if (level == -1) level = dc->saveLevel;
755 if ((level < 1) || (level > dc->saveLevel))
756 {
757 GDI_HEAP_UNLOCK( hdc );
758 return FALSE;
759 }
760
761 success=TRUE;
762 while (dc->saveLevel >= level)
763 {
764 HDC16 hdcs = dc->header.hNext;
765 if (!(dcs = (DC *) GDI_GetObjPtr( hdcs, DC_MAGIC )))
766 {
767 GDI_HEAP_UNLOCK( hdc );
768 return FALSE;
769 }
770 dc->header.hNext = dcs->header.hNext;
771 if (--dc->saveLevel < level)
772 {
773 SetDCState( hdc, hdcs );
774 if (!PATH_AssignGdiPath( &dc->w.path, &dcs->w.path ))
775 /* FIXME: This might not be quite right, since we're
776 * returning FALSE but still destroying the saved DC state */
777 success=FALSE;
778 }
779 DeleteDC32( hdcs );
780 }
781 GDI_HEAP_UNLOCK( hdc );
782 return success;
783 }
784
785
786 /***********************************************************************
787 * CreateDC16 (GDI.53)
788 */
789 HDC16 WINAPI CreateDC16( LPCSTR driver, LPCSTR device, LPCSTR output,
790 const DEVMODE16 *initData )
791 {
792 DC * dc;
793 const DC_FUNCTIONS *funcs;
794
795 if (!(funcs = DRIVER_FindDriver( driver ))) return 0;
796 if (!(dc = DC_AllocDC( funcs ))) return 0;
797 dc->w.flags = 0;
798
799 TRACE(dc, "(driver=%s, device=%s, output=%s): returning %04x\n",
800 debugstr_a(driver), debugstr_a(device), debugstr_a(output), dc->hSelf );
801
802 if (dc->funcs->pCreateDC &&
803 !dc->funcs->pCreateDC( dc, driver, device, output, initData ))
804 {
805 WARN(dc, "creation aborted by device\n" );
806 GDI_HEAP_FREE( dc->hSelf );
807 return 0;
808 }
809
810 DC_InitDC( dc );
811 GDI_HEAP_UNLOCK( dc->hSelf );
812 return dc->hSelf;
813 }
814
815
816 /***********************************************************************
817 * CreateDC32A (GDI32.)
818 */
819 HDC32 WINAPI CreateDC32A( LPCSTR driver, LPCSTR device, LPCSTR output,
820 const DEVMODE32A *initData )
821 {
822 return CreateDC16( driver, device, output, (const DEVMODE16 *)initData );
823 }
824
825
826 /***********************************************************************
827 * CreateDC32W (GDI32.)
828 */
829 HDC32 WINAPI CreateDC32W( LPCWSTR driver, LPCWSTR device, LPCWSTR output,
830 const DEVMODE32W *initData )
831 {
832 LPSTR driverA = HEAP_strdupWtoA( GetProcessHeap(), 0, driver );
833 LPSTR deviceA = HEAP_strdupWtoA( GetProcessHeap(), 0, device );
834 LPSTR outputA = HEAP_strdupWtoA( GetProcessHeap(), 0, output );
835 HDC32 res = CreateDC16( driverA, deviceA, outputA,
836 (const DEVMODE16 *)initData /*FIXME*/ );
837 HeapFree( GetProcessHeap(), 0, driverA );
838 HeapFree( GetProcessHeap(), 0, deviceA );
839 HeapFree( GetProcessHeap(), 0, outputA );
840 return res;
841 }
842
843
844 /***********************************************************************
845 * CreateIC16 (GDI.153)
846 */
847 HDC16 WINAPI CreateIC16( LPCSTR driver, LPCSTR device, LPCSTR output,
848 const DEVMODE16* initData )
849 {
850 /* Nothing special yet for ICs */
851 return CreateDC16( driver, device, output, initData );
852 }
853
854
855 /***********************************************************************
856 * CreateIC32A (GDI32.49)
857 */
858 HDC32 WINAPI CreateIC32A( LPCSTR driver, LPCSTR device, LPCSTR output,
859 const DEVMODE32A* initData )
860 {
861 /* Nothing special yet for ICs */
862 return CreateDC32A( driver, device, output, initData );
863 }
864
865
866 /***********************************************************************
867 * CreateIC32W (GDI32.50)
868 */
869 HDC32 WINAPI CreateIC32W( LPCWSTR driver, LPCWSTR device, LPCWSTR output,
870 const DEVMODE32W* initData )
871 {
872 /* Nothing special yet for ICs */
873 return CreateDC32W( driver, device, output, initData );
874 }
875
876
877 /***********************************************************************
878 * CreateCompatibleDC16 (GDI.52)
879 */
880 HDC16 WINAPI CreateCompatibleDC16( HDC16 hdc )
881 {
882 return (HDC16)CreateCompatibleDC32( hdc );
883 }
884
885
886 /***********************************************************************
887 * CreateCompatibleDC32 (GDI32.31)
888 */
889 HDC32 WINAPI CreateCompatibleDC32( HDC32 hdc )
890 {
891 DC *dc, *origDC;
892 HBITMAP32 hbitmap;
893 const DC_FUNCTIONS *funcs;
894
895 if ((origDC = (DC *)GDI_GetObjPtr( hdc, DC_MAGIC ))) funcs = origDC->funcs;
896 else funcs = DRIVER_FindDriver( "DISPLAY" );
897 if (!funcs) return 0;
898
899 if (!(dc = DC_AllocDC( funcs ))) return 0;
900
901 TRACE(dc, "(%04x): returning %04x\n",
902 hdc, dc->hSelf );
903
904 /* Create default bitmap */
905 if (!(hbitmap = CreateBitmap32( 1, 1, 1, 1, NULL )))
906 {
907 GDI_HEAP_FREE( dc->hSelf );
908 return 0;
909 }
910 dc->w.flags = DC_MEMORY;
911 dc->w.bitsPerPixel = 1;
912 dc->w.hBitmap = hbitmap;
913 dc->w.hFirstBitmap = hbitmap;
914
915 if (dc->funcs->pCreateDC &&
916 !dc->funcs->pCreateDC( dc, NULL, NULL, NULL, NULL ))
917 {
918 WARN(dc, "creation aborted by device\n");
919 DeleteObject32( hbitmap );
920 GDI_HEAP_FREE( dc->hSelf );
921 return 0;
922 }
923
924 DC_InitDC( dc );
925 GDI_HEAP_UNLOCK( dc->hSelf );
926 return dc->hSelf;
927 }
928
929
930 /***********************************************************************
931 * DeleteDC16 (GDI.68)
932 */
933 BOOL16 WINAPI DeleteDC16( HDC16 hdc )
934 {
935 return DeleteDC32( hdc );
936 }
937
938
939 /***********************************************************************
940 * DeleteDC32 (GDI32.67)
941 */
942 BOOL32 WINAPI DeleteDC32( HDC32 hdc )
943 {
944 DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
945 if (!dc) return FALSE;
946
947 TRACE(dc, "%04x\n", hdc );
948
949 while (dc->saveLevel)
950 {
951 DC * dcs;
952 HDC16 hdcs = dc->header.hNext;
953 if (!(dcs = (DC *) GDI_GetObjPtr( hdcs, DC_MAGIC ))) break;
954 dc->header.hNext = dcs->header.hNext;
955 dc->saveLevel--;
956 DeleteDC32( hdcs );
957 }
958
959 if (!(dc->w.flags & DC_SAVED))
960 {
961 SelectObject32( hdc, STOCK_BLACK_PEN );
962 SelectObject32( hdc, STOCK_WHITE_BRUSH );
963 SelectObject32( hdc, STOCK_SYSTEM_FONT );
964 if (dc->w.flags & DC_MEMORY) DeleteObject32( dc->w.hFirstBitmap );
965 if (dc->funcs->pDeleteDC) dc->funcs->pDeleteDC(dc);
966 }
967
968 if (dc->w.hClipRgn) DeleteObject32( dc->w.hClipRgn );
969 if (dc->w.hVisRgn) DeleteObject32( dc->w.hVisRgn );
970 if (dc->w.hGCClipRgn) DeleteObject32( dc->w.hGCClipRgn );
971
972 PATH_DestroyGdiPath(&dc->w.path);
973
974 return GDI_FreeObject( hdc );
975 }
976
977
978 /***********************************************************************
979 * ResetDC16 (GDI.376)
980 */
981 HDC16 WINAPI ResetDC16( HDC16 hdc, const DEVMODE16 *devmode )
982 {
983 FIXME(dc, "stub\n" );
984 return hdc;
985 }
986
987
988 /***********************************************************************
989 * ResetDC32A (GDI32.287)
990 */
991 HDC32 WINAPI ResetDC32A( HDC32 hdc, const DEVMODE32A *devmode )
992 {
993 FIXME(dc, "stub\n" );
994 return hdc;
995 }
996
997
998 /***********************************************************************
999 * ResetDC32W (GDI32.288)
1000 */
1001 HDC32 WINAPI ResetDC32W( HDC32 hdc, const DEVMODE32W *devmode )
1002 {
1003 FIXME(dc, "stub\n" );
1004 return hdc;
1005 }
1006
1007
1008 /***********************************************************************
1009 * GetDeviceCaps16 (GDI.80)
1010 */
1011 INT16 WINAPI GetDeviceCaps16( HDC16 hdc, INT16 cap )
1012 {
1013 return GetDeviceCaps32( hdc, cap );
1014 }
1015
1016
1017 /***********************************************************************
1018 * GetDeviceCaps32 (GDI32.171)
1019 */
1020 INT32 WINAPI GetDeviceCaps32( HDC32 hdc, INT32 cap )
1021 {
1022 DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
1023 INT32 ret;
1024
1025 if (!dc) return 0;
1026
1027 if ((cap < 0) || (cap > sizeof(DeviceCaps)-sizeof(WORD)))
1028 {
1029 GDI_HEAP_UNLOCK( hdc );
1030 return 0;
1031 }
1032
1033 TRACE(dc, "(%04x,%d): returning %d\n",
1034 hdc, cap, *(WORD *)(((char *)dc->w.devCaps) + cap) );
1035 ret = *(WORD *)(((char *)dc->w.devCaps) + cap);
1036 GDI_HEAP_UNLOCK( hdc );
1037 return ret;
1038 }
1039
1040
1041 /***********************************************************************
1042 * SetBkColor16 (GDI.1)
1043 */
1044 COLORREF WINAPI SetBkColor16( HDC16 hdc, COLORREF color )
1045 {
1046 return SetBkColor32( hdc, color );
1047 }
1048
1049
1050 /***********************************************************************
1051 * SetBkColor32 (GDI32.305)
1052 */
1053 COLORREF WINAPI SetBkColor32( HDC32 hdc, COLORREF color )
1054 {
1055 COLORREF oldColor;
1056 DC * dc = DC_GetDCPtr( hdc );
1057
1058 if (!dc) return 0x80000000;
1059 if (dc->funcs->pSetBkColor)
1060 oldColor = dc->funcs->pSetBkColor(dc, color);
1061 else {
1062 oldColor = dc->w.backgroundColor;
1063 dc->w.backgroundColor = color;
1064 }
1065 GDI_HEAP_UNLOCK( hdc );
1066 return oldColor;
1067 }
1068
1069
1070 /***********************************************************************
1071 * SetTextColor16 (GDI.9)
1072 */
1073 COLORREF WINAPI SetTextColor16( HDC16 hdc, COLORREF color )
1074 {
1075 return SetTextColor32( hdc, color );
1076 }
1077
1078
1079 /***********************************************************************
1080 * SetTextColor32 (GDI32.338)
1081 */
1082 COLORREF WINAPI SetTextColor32( HDC32 hdc, COLORREF color )
1083 {
1084 COLORREF oldColor;
1085 DC * dc = DC_GetDCPtr( hdc );
1086
1087 if (!dc) return 0x80000000;
1088 if (dc->funcs->pSetTextColor)
1089 oldColor = dc->funcs->pSetTextColor(dc, color);
1090 else {
1091 oldColor = dc->w.textColor;
1092 dc->w.textColor = color;
1093 }
1094 GDI_HEAP_UNLOCK( hdc );
1095 return oldColor;
1096 }
1097
1098
1099 /***********************************************************************
1100 * SetTextAlign16 (GDI.346)
1101 */
1102 UINT16 WINAPI SetTextAlign16( HDC16 hdc, UINT16 textAlign )
1103 {
1104 return SetTextAlign32( hdc, textAlign );
1105 }
1106
1107
1108 /***********************************************************************
1109 * SetTextAlign32 (GDI32.336)
1110 */
1111 UINT32 WINAPI SetTextAlign32( HDC32 hdc, UINT32 textAlign )
1112 {
1113 UINT32 prevAlign;
1114 DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
1115 if (!dc)
1116 {
1117 if (!(dc = (DC *)GDI_GetObjPtr( hdc, METAFILE_DC_MAGIC ))) return 0;
1118 MF_MetaParam1( dc, META_SETTEXTALIGN, textAlign );
1119 GDI_HEAP_UNLOCK( hdc );
1120 return 1;
1121 }
1122 prevAlign = dc->w.textAlign;
1123 dc->w.textAlign = textAlign;
1124 GDI_HEAP_UNLOCK( hdc );
1125 return prevAlign;
1126 }
1127
1128
1129 /***********************************************************************
1130 * GetDCOrgEx (GDI32.168)
1131 */
1132 BOOL32 WINAPI GetDCOrgEx( HDC32 hDC, LPPOINT32 lpp )
1133 {
1134 DC * dc;
1135 if (!lpp) return FALSE;
1136 if (!(dc = (DC *) GDI_GetObjPtr( hDC, DC_MAGIC ))) return FALSE;
1137
1138 if (!(dc->w.flags & DC_MEMORY))
1139 {
1140 Window root;
1141 int w, h, border, depth;
1142 /* FIXME: this is not correct for managed windows */
1143 TSXGetGeometry( display, dc->u.x.drawable, &root,
1144 &lpp->x, &lpp->y, &w, &h, &border, &depth );
1145 }
1146 else lpp->x = lpp->y = 0;
1147 lpp->x += dc->w.DCOrgX; lpp->y += dc->w.DCOrgY;
1148 GDI_HEAP_UNLOCK( hDC );
1149 return TRUE;
1150 }
1151
1152
1153 /***********************************************************************
1154 * GetDCOrg (GDI.79)
1155 */
1156 DWORD WINAPI GetDCOrg( HDC16 hdc )
1157 {
1158 POINT32 pt;
1159 if( GetDCOrgEx( hdc, &pt) )
1160 return MAKELONG( (WORD)pt.x, (WORD)pt.y );
1161 return 0;
1162 }
1163
1164
1165 /***********************************************************************
1166 * SetDCOrg (GDI.117)
1167 */
1168 DWORD WINAPI SetDCOrg( HDC16 hdc, INT16 x, INT16 y )
1169 {
1170 DWORD prevOrg;
1171 DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
1172 if (!dc) return 0;
1173 prevOrg = dc->w.DCOrgX | (dc->w.DCOrgY << 16);
1174 dc->w.DCOrgX = x;
1175 dc->w.DCOrgY = y;
1176 GDI_HEAP_UNLOCK( hdc );
1177 return prevOrg;
1178 }
1179
1180
1181 /***********************************************************************
1182 * GetGraphicsMode (GDI32.188)
1183 */
1184 INT32 WINAPI GetGraphicsMode( HDC32 hdc )
1185 {
1186 DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
1187 if (!dc) return 0;
1188 return dc->w.GraphicsMode;
1189 }
1190
1191
1192 /***********************************************************************
1193 * SetGraphicsMode (GDI32.317)
1194 */
1195 INT32 WINAPI SetGraphicsMode( HDC32 hdc, INT32 mode )
1196 {
1197 INT32 ret;
1198 DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
1199
1200 /* One would think that setting the graphics mode to GM_COMPATIBLE
1201 * would also reset the world transformation matrix to the unity
1202 * matrix. However, in Windows, this is not the case. This doesn't
1203 * make a lot of sense to me, but that's the way it is.
1204 */
1205
1206 if (!dc) return 0;
1207 if ((mode <= 0) || (mode > GM_LAST)) return 0;
1208 ret = dc->w.GraphicsMode;
1209 dc->w.GraphicsMode = mode;
1210 return ret;
1211 }
1212
1213
1214 /***********************************************************************
1215 * GetArcDirection16 (GDI.524)
1216 */
1217 INT16 WINAPI GetArcDirection16( HDC16 hdc )
1218 {
1219 return GetArcDirection32( (HDC32)hdc );
1220 }
1221
1222
1223 /***********************************************************************
1224 * GetArcDirection32 (GDI32.141)
1225 */
1226 INT32 WINAPI GetArcDirection32( HDC32 hdc )
1227 {
1228 DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
1229
1230 if (!dc)
1231 return 0;
1232
1233 return dc->w.ArcDirection;
1234 }
1235
1236
1237 /***********************************************************************
1238 * SetArcDirection16 (GDI.525)
1239 */
1240 INT16 WINAPI SetArcDirection16( HDC16 hdc, INT16 nDirection )
1241 {
1242 return SetArcDirection32( (HDC32)hdc, (INT32)nDirection );
1243 }
1244
1245
1246 /***********************************************************************
1247 * SetArcDirection32 (GDI32.302)
1248 */
1249 INT32 WINAPI SetArcDirection32( HDC32 hdc, INT32 nDirection )
1250 {
1251 DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
1252 INT32 nOldDirection;
1253
1254 if (!dc)
1255 return 0;
1256
1257 if (nDirection!=AD_COUNTERCLOCKWISE && nDirection!=AD_CLOCKWISE)
1258 {
1259 SetLastError(ERROR_INVALID_PARAMETER);
1260 return 0;
1261 }
1262
1263 nOldDirection = dc->w.ArcDirection;
1264 dc->w.ArcDirection = nDirection;
1265
1266 return nOldDirection;
1267 }
1268
1269
1270 /***********************************************************************
1271 * GetWorldTransform (GDI32.244)
1272 */
1273 BOOL32 WINAPI GetWorldTransform( HDC32 hdc, LPXFORM xform )
1274 {
1275 DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
1276
1277 if (!dc)
1278 return FALSE;
1279 if (!xform)
1280 return FALSE;
1281
1282 *xform = dc->w.xformWorld2Wnd;
1283
1284 return TRUE;
1285 }
1286
1287
1288 /***********************************************************************
1289 * SetWorldTransform (GDI32.346)
1290 */
1291 BOOL32 WINAPI SetWorldTransform( HDC32 hdc, const XFORM *xform )
1292 {
1293 DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
1294
1295 if (!dc)
1296 {
1297 SetLastError( ERROR_INVALID_HANDLE );
1298 return FALSE;
1299 }
1300
1301 if (!xform)
1302 return FALSE;
1303
1304 /* Check that graphics mode is GM_ADVANCED */
1305 if (dc->w.GraphicsMode!=GM_ADVANCED)
1306 return FALSE;
1307
1308 dc->w.xformWorld2Wnd = *xform;
1309
1310 DC_UpdateXforms( dc );
1311
1312 return TRUE;
1313 }
1314
1315
1316 /****************************************************************************
1317 * ModifyWorldTransform [GDI32.253]
1318 * Modifies the world transformation for a device context.
1319 *
1320 * PARAMS
1321 * hdc [I] Handle to device context
1322 * xform [I] XFORM structure that will be used to modify the world
1323 * transformation
1324 * iMode [I] Specifies in what way to modify the world transformation
1325 * Possible values:
1326 * MWT_IDENTITY
1327 * Resets the world transformation to the identity matrix.
1328 * The parameter xform is ignored.
1329 * MWT_LEFTMULTIPLY
1330 * Multiplies xform into the world transformation matrix from
1331 * the left.
1332 * MWT_RIGHTMULTIPLY
1333 * Multiplies xform into the world transformation matrix from
1334 * the right.
1335 *
1336 * RETURNS STD
1337 */
1338 BOOL32 WINAPI ModifyWorldTransform( HDC32 hdc, const XFORM *xform,
1339 DWORD iMode )
1340 {
1341 DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
1342
1343 /* Check for illegal parameters */
1344 if (!dc)
1345 {
1346 SetLastError( ERROR_INVALID_HANDLE );
1347 return FALSE;
1348 }
1349 if (!xform)
1350 return FALSE;
1351
1352 /* Check that graphics mode is GM_ADVANCED */
1353 if (dc->w.GraphicsMode!=GM_ADVANCED)
1354 return FALSE;
1355
1356 switch (iMode)
1357 {
1358 case MWT_IDENTITY:
1359 dc->w.xformWorld2Wnd.eM11 = 1.0f;
1360 dc->w.xformWorld2Wnd.eM12 = 0.0f;
1361 dc->w.xformWorld2Wnd.eM21 = 0.0f;
1362 dc->w.xformWorld2Wnd.eM22 = 1.0f;
1363 dc->w.xformWorld2Wnd.eDx = 0.0f;
1364 dc->w.xformWorld2Wnd.eDy = 0.0f;
1365 break;
1366 case MWT_LEFTMULTIPLY:
1367 CombineTransform( &dc->w.xformWorld2Wnd, xform,
1368 &dc->w.xformWorld2Wnd );
1369 break;
1370 case MWT_RIGHTMULTIPLY:
1371 CombineTransform( &dc->w.xformWorld2Wnd, &dc->w.xformWorld2Wnd,
1372 xform );
1373 break;
1374 default:
1375 return FALSE;
1376 }
1377
1378 DC_UpdateXforms( dc );
1379
1380 return TRUE;
1381 }
1382
1383
1384 /****************************************************************************
1385 * CombineTransform [GDI32.20]
1386 * Combines two transformation matrices.
1387 *
1388 * PARAMS
1389 * xformResult [O] Stores the result of combining the two matrices
1390 * xform1 [I] Specifies the first matrix to apply
1391 * xform2 [I] Specifies the second matrix to apply
1392 *
1393 * REMARKS
1394 * The same matrix can be passed in for more than one of the parameters.
1395 *
1396 * RETURNS STD
1397 */
1398 BOOL32 WINAPI CombineTransform( LPXFORM xformResult, const XFORM *xform1,
1399 const XFORM *xform2 )
1400 {
1401 XFORM xformTemp;
1402
1403 /* Check for illegal parameters */
1404 if (!xformResult || !xform1 || !xform2)
1405 return FALSE;
1406
1407 /* Create the result in a temporary XFORM, since xformResult may be
1408 * equal to xform1 or xform2 */
1409 xformTemp.eM11 = xform1->eM11 * xform2->eM11 +
1410 xform1->eM12 * xform2->eM21;
1411 xformTemp.eM12 = xform1->eM11 * xform2->eM12 +
1412 xform1->eM12 * xform2->eM22;
1413 xformTemp.eM21 = xform1->eM21 * xform2->eM11 +
1414 xform1->eM22 * xform2->eM21;
1415 xformTemp.eM22 = xform1->eM21 * xform2->eM12 +
1416 xform1->eM22 * xform2->eM22;
1417 xformTemp.eDx = xform1->eDx * xform2->eM11 +
1418 xform1->eDy * xform2->eM21 +
1419 xform2->eDx;
1420 xformTemp.eDy = xform1->eDx * xform2->eM12 +
1421 xform1->eDy * xform2->eM22 +
1422 xform2->eDy;
1423
1424 /* Copy the result to xformResult */
1425 *xformResult = xformTemp;
1426
1427 return TRUE;
1428 }
1429
1430
1431 /***********************************************************************
1432 * SetDCHook (GDI.190)
1433 */
1434 BOOL16 WINAPI SetDCHook( HDC16 hdc, FARPROC16 hookProc, DWORD dwHookData )
1435 {
1436 DC *dc = (DC *)GDI_GetObjPtr( hdc, DC_MAGIC );
1437
1438 TRACE(dc, "hookProc %08x, default is %08x\n",
1439 (UINT32)hookProc, (UINT32)DCHook );
1440
1441 if (!dc) return FALSE;
1442 dc->hookProc = hookProc;
1443 dc->dwHookData = dwHookData;
1444 GDI_HEAP_UNLOCK( hdc );
1445 return TRUE;
1446 }
1447
1448
1449 /***********************************************************************
1450 * GetDCHook (GDI.191)
1451 */
1452 DWORD WINAPI GetDCHook( HDC16 hdc, FARPROC16 *phookProc )
1453 {
1454 DC *dc = (DC *)GDI_GetObjPtr( hdc, DC_MAGIC );
1455 if (!dc) return 0;
1456 *phookProc = dc->hookProc;
1457 GDI_HEAP_UNLOCK( hdc );
1458 return dc->dwHookData;
1459 }
1460
1461
1462 /***********************************************************************
1463 * SetHookFlags (GDI.192)
1464 */
1465 WORD WINAPI SetHookFlags(HDC16 hDC, WORD flags)
1466 {
1467 DC* dc = (DC*)GDI_GetObjPtr( hDC, DC_MAGIC );
1468
1469 if( dc )
1470 {
1471 WORD wRet = dc->w.flags & DC_DIRTY;
1472
1473 /* "Undocumented Windows" info is slightly confusing.
1474 */
1475
1476 TRACE(dc,"hDC %04x, flags %04x\n",hDC,flags);
1477
1478 if( flags & DCHF_INVALIDATEVISRGN )
1479 dc->w.flags |= DC_DIRTY;
1480 else if( flags & DCHF_VALIDATEVISRGN || !flags )
1481 dc->w.flags &= ~DC_DIRTY;
1482 GDI_HEAP_UNLOCK( hDC );
1483 return wRet;
1484 }
1485 return 0;
1486 }
1487
1488 /***********************************************************************
1489 * SetICMMode (GDI32.318)
1490 */
1491 INT32 WINAPI SetICMMode(HDC32 hdc, INT32 iEnableICM)
1492 {
1493 /*FIXME Asuming that ICM is always off, and cannot be turned on */
1494 if (iEnableICM == ICM_OFF) return ICM_OFF;
1495 if (iEnableICM == ICM_ON) return 0;
1496 if (iEnableICM == ICM_QUERY) return ICM_OFF;
1497 return 0;
1498 }
1499
1500
1501 /***********************************************************************
1502 * GetColorSpace (GDI32.165)
1503 */
1504 HCOLORSPACE32 WINAPI GetColorSpace(HDC32 hdc)
1505 {
1506 /*FIXME Need to to whatever GetColorSpace actually does */
1507 return 0;
1508 }
Maarten's multimedia branch