objects/dc.c

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