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