?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Release 961222
[wine/gsoc-2012-control.git] / objects / dc.c
blobcfe93a195923c8c53f279c581d974560c2c12d99
1 /*
2 * GDI Device Context functions
3 *
4 * Copyright 1993 Alexandre Julliard
5 *
6 */
7
8 #define NO_TRANSITION_TYPES /* This file is Win32-clean */
9 #include <stdlib.h>
10 #include <string.h>
11 #include "gdi.h"
12 #include "bitmap.h"
13 #include "heap.h"
14 #include "metafile.h"
15 #include "stddebug.h"
16 #include "color.h"
17 #include "debug.h"
18 #include "font.h"
19 #include "xmalloc.h"
20
21 extern void CLIPPING_UpdateGCRegion( DC * dc ); /* objects/clipping.c */
22
23 /* Default DC values */
24 static const WIN_DC_INFO DC_defaultValues =
25 {
26 0, /* flags */
27 NULL, /* devCaps */
28 0, /* hClipRgn */
29 0, /* hVisRgn */
30 0, /* hGCClipRgn */
31 STOCK_BLACK_PEN, /* hPen */
32 STOCK_WHITE_BRUSH, /* hBrush */
33 STOCK_SYSTEM_FONT, /* hFont */
34 0, /* hBitmap */
35 0, /* hFirstBitmap */
36 0, /* hDevice */
37 STOCK_DEFAULT_PALETTE, /* hPalette */
38 R2_COPYPEN, /* ROPmode */
39 ALTERNATE, /* polyFillMode */
40 BLACKONWHITE, /* stretchBltMode */
41 ABSOLUTE, /* relAbsMode */
42 OPAQUE, /* backgroundMode */
43 RGB( 255, 255, 255 ), /* backgroundColor */
44 RGB( 0, 0, 0 ), /* textColor */
45 0, /* backgroundPixel */
46 0, /* textPixel */
47 0, /* brushOrgX */
48 0, /* brushOrgY */
49 TA_LEFT | TA_TOP | TA_NOUPDATECP, /* textAlign */
50 0, /* charExtra */
51 0, /* breakTotalExtra */
52 0, /* breakCount */
53 0, /* breakExtra */
54 0, /* breakRem */
55 1, /* bitsPerPixel */
56 MM_TEXT, /* MapMode */
57 0, /* DCOrgX */
58 0, /* DCOrgY */
59 0, /* CursPosX */
60 0 /* CursPosY */
61 };
62
63 /* ROP code to GC function conversion */
64 const int DC_XROPfunction[16] =
65 {
66 GXclear, /* R2_BLACK */
67 GXnor, /* R2_NOTMERGEPEN */
68 GXandInverted, /* R2_MASKNOTPEN */
69 GXcopyInverted, /* R2_NOTCOPYPEN */
70 GXandReverse, /* R2_MASKPENNOT */
71 GXinvert, /* R2_NOT */
72 GXxor, /* R2_XORPEN */
73 GXnand, /* R2_NOTMASKPEN */
74 GXand, /* R2_MASKPEN */
75 GXequiv, /* R2_NOTXORPEN */
76 GXnoop, /* R2_NOP */
77 GXorInverted, /* R2_MERGENOTPEN */
78 GXcopy, /* R2_COPYPEN */
79 GXorReverse, /* R2_MERGEPENNOT */
80 GXor, /* R2_MERGEPEN */
81 GXset /* R2_WHITE */
82 };
83
84
85 /***********************************************************************
86 * DC_FillDevCaps
87 *
88 * Fill the device caps structure.
89 */
90 void DC_FillDevCaps( DeviceCaps * caps )
91 {
92 caps->version = 0x300;
93 caps->technology = DT_RASDISPLAY;
94 caps->horzSize = WidthMMOfScreen(screen) * screenWidth / WidthOfScreen(screen);
95 caps->vertSize = HeightMMOfScreen(screen) * screenHeight / HeightOfScreen(screen);
96 caps->horzRes = screenWidth;
97 caps->vertRes = screenHeight;
98 caps->bitsPixel = screenDepth;
99 caps->planes = 1;
100 caps->numBrushes = 16+6; /* 16 solid + 6 hatched brushes */
101 caps->numPens = 16; /* 16 solid pens */
102 caps->numMarkers = 0;
103 caps->numFonts = 0;
104 caps->numColors = 100;
105 caps->pdeviceSize = 0;
106 caps->curveCaps = CC_CIRCLES | CC_PIE | CC_CHORD | CC_ELLIPSES |
107 CC_WIDE | CC_STYLED | CC_WIDESTYLED |
108 CC_INTERIORS | CC_ROUNDRECT;
109 caps->lineCaps = LC_POLYLINE | LC_MARKER | LC_POLYMARKER | LC_WIDE |
110 LC_STYLED | LC_WIDESTYLED | LC_INTERIORS;
111 caps->polygonalCaps = PC_POLYGON | PC_RECTANGLE | PC_WINDPOLYGON |
112 PC_SCANLINE | PC_WIDE | PC_STYLED |
113 PC_WIDESTYLED | PC_INTERIORS;
114 caps->textCaps = TC_OP_CHARACTER | TC_OP_STROKE | TC_CP_STROKE |
115 TC_IA_ABLE | TC_UA_ABLE | TC_SO_ABLE | TC_RA_ABLE;
116 caps->clipCaps = CP_REGION;
117 caps->rasterCaps = RC_BITBLT | RC_BANDING | RC_SCALING | RC_BITMAP64 |
118 RC_DI_BITMAP | RC_DIBTODEV | RC_BIGFONT|
119 RC_STRETCHBLT | RC_STRETCHDIB | RC_DEVBITS;
120
121 if( !(COLOR_GetSystemPaletteFlags() & COLOR_VIRTUAL) )
122 caps->rasterCaps |= RC_PALETTE;
123
124 caps->aspectX = 36; /* ?? */
125 caps->aspectY = 36; /* ?? */
126 caps->aspectXY = 51;
127 caps->logPixelsX = (int)(caps->horzRes * 25.4 / caps->horzSize);
128 caps->logPixelsY = (int)(caps->vertRes * 25.4 / caps->vertSize);
129 caps->sizePalette = (caps->rasterCaps & RC_PALETTE)
130 ? DefaultVisual(display,DefaultScreen(display))->map_entries
131 : 0;
132 caps->numReserved = 0;
133 caps->colorRes = 0;
134 }
135
136
137 /***********************************************************************
138 * DC_AllocDC
139 */
140 DC *DC_AllocDC( const DC_FUNCTIONS *funcs )
141 {
142 HDC16 hdc;
143 DC *dc;
144
145 if (!(hdc = GDI_AllocObject( sizeof(DC), DC_MAGIC ))) return NULL;
146 dc = (DC *) GDI_HEAP_LIN_ADDR( hdc );
147
148 dc->hSelf = hdc;
149 dc->funcs = funcs;
150 dc->physDev = NULL;
151 dc->saveLevel = 0;
152 dc->dwHookData = 0L;
153 dc->hookProc = NULL;
154 dc->wndOrgX = 0;
155 dc->wndOrgY = 0;
156 dc->wndExtX = 1;
157 dc->wndExtY = 1;
158 dc->vportOrgX = 0;
159 dc->vportOrgY = 0;
160 dc->vportExtX = 1;
161 dc->vportExtY = 1;
162
163 memcpy( &dc->w, &DC_defaultValues, sizeof(DC_defaultValues) );
164 return dc;
165 }
166
167
168 /***********************************************************************
169 * DC_GetDCPtr
170 */
171 DC *DC_GetDCPtr( HDC32 hdc )
172 {
173 GDIOBJHDR *ptr = (GDIOBJHDR *)GDI_HEAP_LIN_ADDR( hdc );
174 if ((ptr->wMagic == DC_MAGIC) || (ptr->wMagic == METAFILE_DC_MAGIC))
175 return (DC *)ptr;
176 return NULL;
177 }
178
179
180 /***********************************************************************
181 * DC_InitDC
182 *
183 * Setup device-specific DC values for a newly created DC.
184 */
185 void DC_InitDC( DC* dc )
186 {
187 RealizeDefaultPalette( dc->hSelf );
188 SetTextColor( dc->hSelf, dc->w.textColor );
189 SetBkColor( dc->hSelf, dc->w.backgroundColor );
190 SelectObject32( dc->hSelf, dc->w.hPen );
191 SelectObject32( dc->hSelf, dc->w.hBrush );
192 SelectObject32( dc->hSelf, dc->w.hFont );
193 CLIPPING_UpdateGCRegion( dc );
194 }
195
196
197 /***********************************************************************
198 * DC_SetupGCForPatBlt
199 *
200 * Setup the GC for a PatBlt operation using current brush.
201 * If fMapColors is TRUE, X pixels are mapped to Windows colors.
202 * Return FALSE if brush is BS_NULL, TRUE otherwise.
203 */
204 BOOL32 DC_SetupGCForPatBlt( DC * dc, GC gc, BOOL32 fMapColors )
205 {
206 XGCValues val;
207 unsigned long mask;
208 Pixmap pixmap = 0;
209
210 if (dc->u.x.brush.style == BS_NULL) return FALSE;
211 if (dc->u.x.brush.pixel == -1)
212 {
213 /* Special case used for monochrome pattern brushes.
214 * We need to swap foreground and background because
215 * Windows does it the wrong way...
216 */
217 val.foreground = dc->w.backgroundPixel;
218 val.background = dc->w.textPixel;
219 }
220 else
221 {
222 val.foreground = dc->u.x.brush.pixel;
223 val.background = dc->w.backgroundPixel;
224 }
225 if (fMapColors && COLOR_PixelToPalette)
226 {
227 val.foreground = COLOR_PixelToPalette[val.foreground];
228 val.background = COLOR_PixelToPalette[val.background];
229 }
230
231 if (dc->w.flags & DC_DIRTY) CLIPPING_UpdateGCRegion(dc);
232
233 val.function = DC_XROPfunction[dc->w.ROPmode-1];
234 val.fill_style = dc->u.x.brush.fillStyle;
235 switch(val.fill_style)
236 {
237 case FillStippled:
238 case FillOpaqueStippled:
239 if (dc->w.backgroundMode==OPAQUE) val.fill_style = FillOpaqueStippled;
240 val.stipple = dc->u.x.brush.pixmap;
241 mask = GCStipple;
242 break;
243
244 case FillTiled:
245 if (fMapColors && COLOR_PixelToPalette)
246 {
247 register int x, y;
248 XImage *image;
249 pixmap = XCreatePixmap( display, rootWindow, 8, 8, screenDepth );
250 image = XGetImage( display, dc->u.x.brush.pixmap, 0, 0, 8, 8,
251 AllPlanes, ZPixmap );
252 for (y = 0; y < 8; y++)
253 for (x = 0; x < 8; x++)
254 XPutPixel( image, x, y,
255 COLOR_PixelToPalette[XGetPixel( image, x, y)] );
256 XPutImage( display, pixmap, gc, image, 0, 0, 0, 0, 8, 8 );
257 XDestroyImage( image );
258 val.tile = pixmap;
259 }
260 else val.tile = dc->u.x.brush.pixmap;
261 mask = GCTile;
262 break;
263
264 default:
265 mask = 0;
266 break;
267 }
268 val.ts_x_origin = dc->w.DCOrgX + dc->w.brushOrgX;
269 val.ts_y_origin = dc->w.DCOrgY + dc->w.brushOrgY;
270 val.fill_rule = (dc->w.polyFillMode==WINDING) ? WindingRule : EvenOddRule;
271 XChangeGC( display, gc,
272 GCFunction | GCForeground | GCBackground | GCFillStyle |
273 GCFillRule | GCTileStipXOrigin | GCTileStipYOrigin | mask,
274 &val );
275 if (pixmap) XFreePixmap( display, pixmap );
276 return TRUE;
277 }
278
279
280 /***********************************************************************
281 * DC_SetupGCForBrush
282 *
283 * Setup dc->u.x.gc for drawing operations using current brush.
284 * Return FALSE if brush is BS_NULL, TRUE otherwise.
285 */
286 BOOL32 DC_SetupGCForBrush( DC * dc )
287 {
288 return DC_SetupGCForPatBlt( dc, dc->u.x.gc, FALSE );
289 }
290
291
292 /***********************************************************************
293 * DC_SetupGCForPen
294 *
295 * Setup dc->u.x.gc for drawing operations using current pen.
296 * Return FALSE if pen is PS_NULL, TRUE otherwise.
297 */
298 BOOL32 DC_SetupGCForPen( DC * dc )
299 {
300 XGCValues val;
301
302 if (dc->u.x.pen.style == PS_NULL) return FALSE;
303
304 if (dc->w.flags & DC_DIRTY) CLIPPING_UpdateGCRegion(dc);
305
306 if ((screenDepth <= 8) && /* FIXME: Should check for palette instead */
307 ((dc->w.ROPmode == R2_BLACK) || (dc->w.ROPmode == R2_WHITE)))
308 {
309 val.function = GXcopy;
310 val.foreground = COLOR_ToPhysical( NULL, (dc->w.ROPmode == R2_BLACK) ?
311 RGB(0,0,0) : RGB(255,255,255) );
312 }
313 else
314 {
315 val.function = DC_XROPfunction[dc->w.ROPmode-1];
316 val.foreground = dc->u.x.pen.pixel;
317 }
318 val.background = dc->w.backgroundPixel;
319 val.fill_style = FillSolid;
320 if ((dc->u.x.pen.style!=PS_SOLID) && (dc->u.x.pen.style!=PS_INSIDEFRAME))
321 {
322 XSetDashes( display, dc->u.x.gc, 0,
323 dc->u.x.pen.dashes, dc->u.x.pen.dash_len );
324 val.line_style = (dc->w.backgroundMode == OPAQUE) ?
325 LineDoubleDash : LineOnOffDash;
326 }
327 else val.line_style = LineSolid;
328 val.line_width = dc->u.x.pen.width;
329 val.cap_style = CapRound;
330 val.join_style = JoinMiter;
331 XChangeGC( display, dc->u.x.gc,
332 GCFunction | GCForeground | GCBackground | GCLineWidth |
333 GCLineStyle | GCCapStyle | GCJoinStyle | GCFillStyle, &val );
334 return TRUE;
335 }
336
337
338 /***********************************************************************
339 * DC_SetupGCForText
340 *
341 * Setup dc->u.x.gc for text drawing operations.
342 * Return FALSE if the font is null, TRUE otherwise.
343 */
344 BOOL32 DC_SetupGCForText( DC * dc )
345 {
346 XGCValues val;
347
348 if (!dc->u.x.font.fstruct)
349 {
350 fprintf( stderr, "DC_SetupGCForText: fstruct is NULL. Please report this\n" );
351 return FALSE;
352 }
353
354 if (dc->w.flags & DC_DIRTY) CLIPPING_UpdateGCRegion(dc);
355
356 val.function = GXcopy; /* Text is always GXcopy */
357 val.foreground = dc->w.textPixel;
358 val.background = dc->w.backgroundPixel;
359 val.fill_style = FillSolid;
360 val.font = dc->u.x.font.fstruct->fid;
361 XChangeGC( display, dc->u.x.gc,
362 GCFunction | GCForeground | GCBackground | GCFillStyle |
363 GCFont, &val );
364 return TRUE;
365 }
366
367
368 /***********************************************************************
369 * GetDCState (GDI.179)
370 */
371 HDC16 GetDCState( HDC16 hdc )
372 {
373 DC * newdc, * dc;
374 HGDIOBJ16 handle;
375
376 if (!(dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC ))) return 0;
377 if (!(handle = GDI_AllocObject( sizeof(DC), DC_MAGIC ))) return 0;
378 newdc = (DC *) GDI_HEAP_LIN_ADDR( handle );
379
380 dprintf_dc(stddeb, "GetDCState(%04x): returning %04x\n", hdc, handle );
381
382 memset( &newdc->u.x, 0, sizeof(newdc->u.x) );
383 newdc->w.flags = dc->w.flags | DC_SAVED;
384 newdc->w.devCaps = dc->w.devCaps;
385 newdc->w.hPen = dc->w.hPen;
386 newdc->w.hBrush = dc->w.hBrush;
387 newdc->w.hFont = dc->w.hFont;
388 newdc->w.hBitmap = dc->w.hBitmap;
389 newdc->w.hFirstBitmap = dc->w.hFirstBitmap;
390 newdc->w.hDevice = dc->w.hDevice;
391 newdc->w.hPalette = dc->w.hPalette;
392 newdc->w.bitsPerPixel = dc->w.bitsPerPixel;
393 newdc->w.ROPmode = dc->w.ROPmode;
394 newdc->w.polyFillMode = dc->w.polyFillMode;
395 newdc->w.stretchBltMode = dc->w.stretchBltMode;
396 newdc->w.relAbsMode = dc->w.relAbsMode;
397 newdc->w.backgroundMode = dc->w.backgroundMode;
398 newdc->w.backgroundColor = dc->w.backgroundColor;
399 newdc->w.textColor = dc->w.textColor;
400 newdc->w.backgroundPixel = dc->w.backgroundPixel;
401 newdc->w.textPixel = dc->w.textPixel;
402 newdc->w.brushOrgX = dc->w.brushOrgX;
403 newdc->w.brushOrgY = dc->w.brushOrgY;
404 newdc->w.textAlign = dc->w.textAlign;
405 newdc->w.charExtra = dc->w.charExtra;
406 newdc->w.breakTotalExtra = dc->w.breakTotalExtra;
407 newdc->w.breakCount = dc->w.breakCount;
408 newdc->w.breakExtra = dc->w.breakExtra;
409 newdc->w.breakRem = dc->w.breakRem;
410 newdc->w.MapMode = dc->w.MapMode;
411 newdc->w.DCOrgX = dc->w.DCOrgX;
412 newdc->w.DCOrgY = dc->w.DCOrgY;
413 newdc->w.CursPosX = dc->w.CursPosX;
414 newdc->w.CursPosY = dc->w.CursPosY;
415 newdc->wndOrgX = dc->wndOrgX;
416 newdc->wndOrgY = dc->wndOrgY;
417 newdc->wndExtX = dc->wndExtX;
418 newdc->wndExtY = dc->wndExtY;
419 newdc->vportOrgX = dc->vportOrgX;
420 newdc->vportOrgY = dc->vportOrgY;
421 newdc->vportExtX = dc->vportExtX;
422 newdc->vportExtY = dc->vportExtY;
423
424 newdc->hSelf = (HDC32)handle;
425 newdc->saveLevel = 0;
426
427 newdc->w.hGCClipRgn = 0;
428 newdc->w.hVisRgn = CreateRectRgn32( 0, 0, 0, 0 );
429 CombineRgn32( newdc->w.hVisRgn, dc->w.hVisRgn, 0, RGN_COPY );
430 if (dc->w.hClipRgn)
431 {
432 newdc->w.hClipRgn = CreateRectRgn32( 0, 0, 0, 0 );
433 CombineRgn32( newdc->w.hClipRgn, dc->w.hClipRgn, 0, RGN_COPY );
434 }
435 return handle;
436 }
437
438
439 /***********************************************************************
440 * SetDCState (GDI.180)
441 */
442 void SetDCState( HDC16 hdc, HDC16 hdcs )
443 {
444 DC *dc, *dcs;
445
446 if (!(dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC ))) return;
447 if (!(dcs = (DC *) GDI_GetObjPtr( hdcs, DC_MAGIC ))) return;
448 if (!dcs->w.flags & DC_SAVED) return;
449 dprintf_dc(stddeb, "SetDCState: %04x %04x\n", hdc, hdcs );
450
451 dc->w.flags = dcs->w.flags & ~DC_SAVED;
452 dc->w.devCaps = dcs->w.devCaps;
453 dc->w.hFirstBitmap = dcs->w.hFirstBitmap;
454 dc->w.hDevice = dcs->w.hDevice;
455 dc->w.ROPmode = dcs->w.ROPmode;
456 dc->w.polyFillMode = dcs->w.polyFillMode;
457 dc->w.stretchBltMode = dcs->w.stretchBltMode;
458 dc->w.relAbsMode = dcs->w.relAbsMode;
459 dc->w.backgroundMode = dcs->w.backgroundMode;
460 dc->w.backgroundColor = dcs->w.backgroundColor;
461 dc->w.textColor = dcs->w.textColor;
462 dc->w.backgroundPixel = dcs->w.backgroundPixel;
463 dc->w.textPixel = dcs->w.textPixel;
464 dc->w.brushOrgX = dcs->w.brushOrgX;
465 dc->w.brushOrgY = dcs->w.brushOrgY;
466 dc->w.textAlign = dcs->w.textAlign;
467 dc->w.charExtra = dcs->w.charExtra;
468 dc->w.breakTotalExtra = dcs->w.breakTotalExtra;
469 dc->w.breakCount = dcs->w.breakCount;
470 dc->w.breakExtra = dcs->w.breakExtra;
471 dc->w.breakRem = dcs->w.breakRem;
472 dc->w.MapMode = dcs->w.MapMode;
473 dc->w.DCOrgX = dcs->w.DCOrgX;
474 dc->w.DCOrgY = dcs->w.DCOrgY;
475 dc->w.CursPosX = dcs->w.CursPosX;
476 dc->w.CursPosY = dcs->w.CursPosY;
477
478 dc->wndOrgX = dcs->wndOrgX;
479 dc->wndOrgY = dcs->wndOrgY;
480 dc->wndExtX = dcs->wndExtX;
481 dc->wndExtY = dcs->wndExtY;
482 dc->vportOrgX = dcs->vportOrgX;
483 dc->vportOrgY = dcs->vportOrgY;
484 dc->vportExtX = dcs->vportExtX;
485 dc->vportExtY = dcs->vportExtY;
486
487 if (!(dc->w.flags & DC_MEMORY)) dc->w.bitsPerPixel = dcs->w.bitsPerPixel;
488 CombineRgn32( dc->w.hVisRgn, dcs->w.hVisRgn, 0, RGN_COPY );
489 SelectClipRgn32( hdc, dcs->w.hClipRgn );
490 SelectObject32( hdc, dcs->w.hBitmap );
491 SelectObject32( hdc, dcs->w.hBrush );
492 SelectObject32( hdc, dcs->w.hFont );
493 SelectObject32( hdc, dcs->w.hPen );
494 GDISelectPalette( hdc, dcs->w.hPalette, FALSE );
495 }
496
497
498 /***********************************************************************
499 * SaveDC16 (GDI.30)
500 */
501 INT16 SaveDC16( HDC16 hdc )
502 {
503 return (INT16)SaveDC32( hdc );
504 }
505
506
507 /***********************************************************************
508 * SaveDC32 (GDI32.292)
509 */
510 INT32 SaveDC32( HDC32 hdc )
511 {
512 HDC32 hdcs;
513 DC * dc, * dcs;
514
515 dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
516 if (!dc)
517 {
518 dc = (DC *)GDI_GetObjPtr(hdc, METAFILE_DC_MAGIC);
519 if (!dc) return 0;
520 MF_MetaParam0(dc, META_SAVEDC);
521 return 1; /* ?? */
522 }
523 if (!(hdcs = GetDCState( hdc ))) return 0;
524 dcs = (DC *) GDI_HEAP_LIN_ADDR( hdcs );
525 dcs->header.hNext = dc->header.hNext;
526 dc->header.hNext = hdcs;
527 dprintf_dc(stddeb, "SaveDC(%04x): returning %d\n", hdc, dc->saveLevel+1 );
528 return ++dc->saveLevel;
529 }
530
531
532 /***********************************************************************
533 * RestoreDC16 (GDI.39)
534 */
535 BOOL16 RestoreDC16( HDC16 hdc, INT16 level )
536 {
537 return RestoreDC32( hdc, level );
538 }
539
540
541 /***********************************************************************
542 * RestoreDC32 (GDI32.290)
543 */
544 BOOL32 RestoreDC32( HDC32 hdc, INT32 level )
545 {
546 DC * dc, * dcs;
547
548 dprintf_dc(stddeb, "RestoreDC: %04x %d\n", hdc, level );
549 dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
550 if (!dc)
551 {
552 dc = (DC *)GDI_GetObjPtr(hdc, METAFILE_DC_MAGIC);
553 if (!dc) return FALSE;
554 if (level != -1) return FALSE;
555 MF_MetaParam1(dc, META_RESTOREDC, level);
556 return TRUE;
557 }
558 if (level == -1) level = dc->saveLevel;
559 if ((level < 1) || (level > dc->saveLevel)) return FALSE;
560
561 while (dc->saveLevel >= level)
562 {
563 HDC16 hdcs = dc->header.hNext;
564 if (!(dcs = (DC *) GDI_GetObjPtr( hdcs, DC_MAGIC ))) return FALSE;
565 dc->header.hNext = dcs->header.hNext;
566 if (--dc->saveLevel < level) SetDCState( hdc, hdcs );
567 DeleteDC32( hdcs );
568 }
569 return TRUE;
570 }
571
572
573 /***********************************************************************
574 * CreateDC16 (GDI.53)
575 */
576 HDC16 CreateDC16( LPCSTR driver, LPCSTR device, LPCSTR output,
577 const DEVMODE16 *initData )
578 {
579 DC * dc;
580 const DC_FUNCTIONS *funcs;
581
582 if (!(funcs = DRIVER_FindDriver( driver ))) return 0;
583 if (!(dc = DC_AllocDC( funcs ))) return 0;
584 dc->w.flags = 0;
585
586 dprintf_dc(stddeb, "CreateDC(%s %s %s): returning %04x\n",
587 driver, device, output, dc->hSelf );
588
589 if (dc->funcs->pCreateDC &&
590 !dc->funcs->pCreateDC( dc, driver, device, output, initData ))
591 {
592 dprintf_dc( stddeb, "CreateDC: creation aborted by device\n" );
593 GDI_HEAP_FREE( dc->hSelf );
594 return 0;
595 }
596
597 DC_InitDC( dc );
598 return dc->hSelf;
599 }
600
601
602 /***********************************************************************
603 * CreateDC32A (GDI32.)
604 */
605 HDC32 CreateDC32A( LPCSTR driver, LPCSTR device, LPCSTR output,
606 const DEVMODE32A *initData )
607 {
608 return CreateDC16( driver, device, output, (const DEVMODE16 *)initData );
609 }
610
611
612 /***********************************************************************
613 * CreateDC32W (GDI32.)
614 */
615 HDC32 CreateDC32W( LPCWSTR driver, LPCWSTR device, LPCWSTR output,
616 const DEVMODE32W *initData )
617 {
618 LPSTR driverA = HEAP_strdupWtoA( GetProcessHeap(), 0, driver );
619 LPSTR deviceA = HEAP_strdupWtoA( GetProcessHeap(), 0, device );
620 LPSTR outputA = HEAP_strdupWtoA( GetProcessHeap(), 0, output );
621 HDC32 res = CreateDC16( driverA, deviceA, outputA,
622 (const DEVMODE16 *)initData /*FIXME*/ );
623 HeapFree( GetProcessHeap(), 0, driverA );
624 HeapFree( GetProcessHeap(), 0, deviceA );
625 HeapFree( GetProcessHeap(), 0, outputA );
626 return res;
627 }
628
629
630 /***********************************************************************
631 * CreateIC16 (GDI.153)
632 */
633 HDC16 CreateIC16( LPCSTR driver, LPCSTR device, LPCSTR output,
634 const DEVMODE16* initData )
635 {
636 /* Nothing special yet for ICs */
637 return CreateDC16( driver, device, output, initData );
638 }
639
640
641 /***********************************************************************
642 * CreateIC32A (GDI32.49)
643 */
644 HDC32 CreateIC32A( LPCSTR driver, LPCSTR device, LPCSTR output,
645 const DEVMODE32A* initData )
646 {
647 /* Nothing special yet for ICs */
648 return CreateDC32A( driver, device, output, initData );
649 }
650
651
652 /***********************************************************************
653 * CreateIC32W (GDI32.50)
654 */
655 HDC32 CreateIC32W( LPCWSTR driver, LPCWSTR device, LPCWSTR output,
656 const DEVMODE32W* initData )
657 {
658 /* Nothing special yet for ICs */
659 return CreateDC32W( driver, device, output, initData );
660 }
661
662
663 /***********************************************************************
664 * CreateCompatibleDC16 (GDI.52)
665 */
666 HDC16 CreateCompatibleDC16( HDC16 hdc )
667 {
668 return (HDC16)CreateCompatibleDC32( hdc );
669 }
670
671
672 /***********************************************************************
673 * CreateCompatibleDC32 (GDI32.31)
674 */
675 HDC32 CreateCompatibleDC32( HDC32 hdc )
676 {
677 DC *dc, *origDC;
678 HBITMAP32 hbitmap;
679 const DC_FUNCTIONS *funcs;
680
681 if ((origDC = (DC *)GDI_GetObjPtr( hdc, DC_MAGIC ))) funcs = origDC->funcs;
682 else funcs = DRIVER_FindDriver( "DISPLAY" );
683 if (!funcs) return 0;
684
685 if (!(dc = DC_AllocDC( funcs ))) return 0;
686
687 dprintf_dc(stddeb, "CreateCompatibleDC(%04x): returning %04x\n",
688 hdc, dc->hSelf );
689
690 /* Create default bitmap */
691 if (!(hbitmap = CreateBitmap( 1, 1, 1, 1, NULL )))
692 {
693 GDI_HEAP_FREE( dc->hSelf );
694 return 0;
695 }
696 dc->w.flags = DC_MEMORY;
697 dc->w.bitsPerPixel = 1;
698 dc->w.hBitmap = hbitmap;
699 dc->w.hFirstBitmap = hbitmap;
700
701 if (dc->funcs->pCreateDC &&
702 !dc->funcs->pCreateDC( dc, NULL, NULL, NULL, NULL ))
703 {
704 dprintf_dc(stddeb, "CreateCompatibleDC: creation aborted by device\n");
705 DeleteObject32( hbitmap );
706 GDI_HEAP_FREE( dc->hSelf );
707 return 0;
708 }
709
710 DC_InitDC( dc );
711 return dc->hSelf;
712 }
713
714
715 /***********************************************************************
716 * DeleteDC16 (GDI.68)
717 */
718 BOOL16 DeleteDC16( HDC16 hdc )
719 {
720 return DeleteDC32( hdc );
721 }
722
723
724 /***********************************************************************
725 * DeleteDC32 (GDI32.67)
726 */
727 BOOL32 DeleteDC32( HDC32 hdc )
728 {
729 DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
730 if (!dc) return FALSE;
731
732 dprintf_dc(stddeb, "DeleteDC: %04x\n", hdc );
733
734 while (dc->saveLevel)
735 {
736 DC * dcs;
737 HDC16 hdcs = dc->header.hNext;
738 if (!(dcs = (DC *) GDI_GetObjPtr( hdcs, DC_MAGIC ))) break;
739 dc->header.hNext = dcs->header.hNext;
740 dc->saveLevel--;
741 DeleteDC32( hdcs );
742 }
743
744 if (!(dc->w.flags & DC_SAVED))
745 {
746 SelectObject32( hdc, STOCK_BLACK_PEN );
747 SelectObject32( hdc, STOCK_WHITE_BRUSH );
748 SelectObject32( hdc, STOCK_SYSTEM_FONT );
749 if (dc->w.flags & DC_MEMORY) DeleteObject32( dc->w.hFirstBitmap );
750 if (dc->funcs->pDeleteDC) dc->funcs->pDeleteDC(dc);
751 }
752
753 if (dc->w.hClipRgn) DeleteObject32( dc->w.hClipRgn );
754 if (dc->w.hVisRgn) DeleteObject32( dc->w.hVisRgn );
755 if (dc->w.hGCClipRgn) DeleteObject32( dc->w.hGCClipRgn );
756
757 return GDI_FreeObject( hdc );
758 }
759
760
761 /***********************************************************************
762 * ResetDC16 (GDI.376)
763 */
764 HDC16 ResetDC16( HDC16 hdc, const DEVMODE16 *devmode )
765 {
766 fprintf( stderr, "ResetDC16: empty stub!\n" );
767 return hdc;
768 }
769
770
771 /***********************************************************************
772 * ResetDC32A (GDI32.287)
773 */
774 HDC32 ResetDC32A( HDC32 hdc, const DEVMODE32A *devmode )
775 {
776 fprintf( stderr, "ResetDC32A: empty stub!\n" );
777 return hdc;
778 }
779
780
781 /***********************************************************************
782 * ResetDC32W (GDI32.288)
783 */
784 HDC32 ResetDC32W( HDC32 hdc, const DEVMODE32W *devmode )
785 {
786 fprintf( stderr, "ResetDC32A: empty stub!\n" );
787 return hdc;
788 }
789
790
791 /***********************************************************************
792 * GetDeviceCaps (GDI.80)
793 */
794 int GetDeviceCaps( HDC16 hdc, WORD cap )
795 {
796 DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
797 if (!dc) return 0;
798
799 if (cap > sizeof(DeviceCaps)-sizeof(WORD)) return 0;
800
801 dprintf_dc(stddeb, "GetDeviceCaps(%04x,%d): returning %d\n",
802 hdc, cap, *(WORD *)(((char *)dc->w.devCaps) + cap) );
803 return *(WORD *)(((char *)dc->w.devCaps) + cap);
804 }
805
806
807 /***********************************************************************
808 * SetBkColor (GDI.1) (GDI32.305)
809 */
810 COLORREF SetBkColor( HDC32 hdc, COLORREF color )
811 {
812 COLORREF oldColor;
813 DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
814 if (!dc)
815 {
816 dc = (DC *)GDI_GetObjPtr(hdc, METAFILE_DC_MAGIC);
817 if (!dc) return 0x80000000;
818 MF_MetaParam2(dc, META_SETBKCOLOR, HIWORD(color), LOWORD(color));
819 return 0; /* ?? */
820 }
821
822 oldColor = dc->w.backgroundColor;
823 dc->w.backgroundColor = color;
824 dc->w.backgroundPixel = COLOR_ToPhysical( dc, color );
825 return oldColor;
826 }
827
828
829 /***********************************************************************
830 * SetTextColor (GDI.9) (GDI32.338)
831 */
832 COLORREF SetTextColor( HDC32 hdc, COLORREF color )
833 {
834 COLORREF oldColor;
835 DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
836 if (!dc)
837 {
838 dc = (DC *)GDI_GetObjPtr(hdc, METAFILE_DC_MAGIC);
839 if (!dc) return 0x80000000;
840 MF_MetaParam2(dc, META_SETTEXTCOLOR, HIWORD(color), LOWORD(color));
841 return 0; /* ?? */
842 }
843
844 oldColor = dc->w.textColor;
845 dc->w.textColor = color;
846 dc->w.textPixel = COLOR_ToPhysical( dc, color );
847 return oldColor;
848 }
849
850
851 /***********************************************************************
852 * SetTextAlign16 (GDI.346)
853 */
854 UINT16 SetTextAlign16( HDC16 hdc, UINT16 textAlign )
855 {
856 return SetTextAlign32( hdc, textAlign );
857 }
858
859
860 /***********************************************************************
861 * SetTextAlign32 (GDI32.336)
862 */
863 UINT32 SetTextAlign32( HDC32 hdc, UINT32 textAlign )
864 {
865 UINT32 prevAlign;
866 DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
867 if (!dc)
868 {
869 if (!(dc = (DC *)GDI_GetObjPtr( hdc, METAFILE_DC_MAGIC ))) return 0;
870 MF_MetaParam1( dc, META_SETTEXTALIGN, textAlign );
871 return 1;
872 }
873 prevAlign = dc->w.textAlign;
874 dc->w.textAlign = textAlign;
875 return prevAlign;
876 }
877
878
879 /***********************************************************************
880 * GetDCOrgEx (GDI32.168)
881 */
882 BOOL32 GetDCOrgEx( HDC32 hDC, LPPOINT32 lpp )
883 {
884 DC * dc = (DC *) GDI_GetObjPtr( hDC, DC_MAGIC );
885 if (!dc || !lpp) return FALSE;
886
887 if (!(dc->w.flags & DC_MEMORY))
888 {
889 Window root;
890 int w, h, border, depth;
891 /* FIXME: this is not correct for managed windows */
892 XGetGeometry( display, dc->u.x.drawable, &root,
893 &lpp->x, &lpp->y, &w, &h, &border, &depth );
894 }
895 else lpp->x = lpp->y = 0;
896 lpp->x += dc->w.DCOrgX; lpp->y += dc->w.DCOrgY;
897 return TRUE;
898 }
899
900
901 /***********************************************************************
902 * GetDCOrg (GDI.79)
903 */
904 DWORD GetDCOrg( HDC16 hdc )
905 {
906 POINT32 pt;
907 if( GetDCOrgEx( hdc, &pt) )
908 return MAKELONG( (WORD)pt.x, (WORD)pt.y );
909 return 0;
910 }
911
912
913 /***********************************************************************
914 * SetDCOrg (GDI.117)
915 */
916 DWORD SetDCOrg( HDC16 hdc, INT16 x, INT16 y )
917 {
918 DWORD prevOrg;
919 DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
920 if (!dc) return 0;
921 prevOrg = dc->w.DCOrgX | (dc->w.DCOrgY << 16);
922 dc->w.DCOrgX = x;
923 dc->w.DCOrgY = y;
924 return prevOrg;
925 }
926
927
928 /***********************************************************************
929 * SetDCHook (GDI.190)
930 */
931 BOOL16 SetDCHook( HDC16 hdc, FARPROC16 hookProc, DWORD dwHookData )
932 {
933 DC *dc = (DC *)GDI_GetObjPtr( hdc, DC_MAGIC );
934
935 dprintf_dc( stddeb, "SetDCHook: hookProc %08x, default is %08x\n",
936 (UINT32)hookProc, (UINT32)DCHook );
937
938 if (!dc) return FALSE;
939 dc->hookProc = hookProc;
940 dc->dwHookData = dwHookData;
941 return TRUE;
942 }
943
944
945 /***********************************************************************
946 * GetDCHook (GDI.191)
947 */
948 DWORD GetDCHook( HDC16 hdc, FARPROC16 *phookProc )
949 {
950 DC *dc = (DC *)GDI_GetObjPtr( hdc, DC_MAGIC );
951 if (!dc) return 0;
952 *phookProc = dc->hookProc;
953 return dc->dwHookData;
954 }
955
956
957 /***********************************************************************
958 * SetHookFlags (GDI.192)
959 */
960 WORD SetHookFlags(HDC16 hDC, WORD flags)
961 {
962 DC* dc = (DC*)GDI_GetObjPtr( hDC, DC_MAGIC );
963
964 if( dc )
965 {
966 WORD wRet = dc->w.flags & DC_DIRTY;
967
968 /* "Undocumented Windows" info is slightly
969 * confusing
970 */
971
972 dprintf_dc(stddeb,"SetHookFlags: hDC %04x, flags %04x\n",hDC,flags);
973
974 if( flags & DCHF_INVALIDATEVISRGN )
975 dc->w.flags |= DC_DIRTY;
976 else if( flags & DCHF_VALIDATEVISRGN || !flags )
977 dc->w.flags &= ~DC_DIRTY;
978 return wRet;
979 }
980 return 0;
981 }
982
GSOC 2012 project to enhance the control panel