objects/brush.c

   1 /*
   2  * GDI brush objects
   3  *
   4  * Copyright 1993, 1994  Alexandre Julliard
   5  */
   6
   7 #define NO_TRANSITION_TYPES  /* This file is Win32-clean */
   8 #include <stdlib.h>
   9 #include "brush.h"
  10 #include "bitmap.h"
  11 #include "metafile.h"
  12 #include "color.h"
  13 #include "stddebug.h"
  14 #include "debug.h"
  15 #include "xmalloc.h"
  16
  17 #define NB_HATCH_STYLES  6
  18
  19 static const char HatchBrushes[NB_HATCH_STYLES][8] =
  20 {
  21     { 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00 }, /* HS_HORIZONTAL */
  22     { 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08 }, /* HS_VERTICAL   */
  23     { 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80 }, /* HS_FDIAGONAL  */
  24     { 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01 }, /* HS_BDIAGONAL  */
  25     { 0x08, 0x08, 0x08, 0xff, 0x08, 0x08, 0x08, 0x08 }, /* HS_CROSS      */
  26     { 0x81, 0x42, 0x24, 0x18, 0x18, 0x24, 0x42, 0x81 }  /* HS_DIAGCROSS  */
  27 };
  28
  29   /* Levels of each primary for dithering */
  30 #define PRIMARY_LEVELS  3
  31 #define TOTAL_LEVELS    (PRIMARY_LEVELS*PRIMARY_LEVELS*PRIMARY_LEVELS)
  32
  33  /* Dithering matrix size  */
  34 #define MATRIX_SIZE     8
  35 #define MATRIX_SIZE_2   (MATRIX_SIZE*MATRIX_SIZE)
  36
  37   /* Total number of possible levels for a dithered primary color */
  38 #define DITHER_LEVELS   (MATRIX_SIZE_2 * (PRIMARY_LEVELS-1) + 1)
  39
  40   /* Dithering matrix */
  41 static const int dither_matrix[MATRIX_SIZE_2] =
  42 {
  43      0, 32,  8, 40,  2, 34, 10, 42,
  44     48, 16, 56, 24, 50, 18, 58, 26,
  45     12, 44,  4, 36, 14, 46,  6, 38,
  46     60, 28, 52, 20, 62, 30, 54, 22,
  47      3, 35, 11, 43,  1, 33,  9, 41,
  48     51, 19, 59, 27, 49, 17, 57, 25,
  49     15, 47,  7, 39, 13, 45,  5, 37,
  50     63, 31, 55, 23, 61, 29, 53, 21
  51 };
  52
  53   /* Mapping between (R,G,B) triples and EGA colors */
  54 static const int EGAmapping[TOTAL_LEVELS] =
  55 {
  56     0,  /* 000000 -> 000000 */
  57     4,  /* 00007f -> 000080 */
  58     12, /* 0000ff -> 0000ff */
  59     2,  /* 007f00 -> 008000 */
  60     6,  /* 007f7f -> 008080 */
  61     6,  /* 007fff -> 008080 */
  62     10, /* 00ff00 -> 00ff00 */
  63     6,  /* 00ff7f -> 008080 */
  64     14, /* 00ffff -> 00ffff */
  65     1,  /* 7f0000 -> 800000 */
  66     5,  /* 7f007f -> 800080 */
  67     5,  /* 7f00ff -> 800080 */
  68     3,  /* 7f7f00 -> 808000 */
  69     8,  /* 7f7f7f -> 808080 */
  70     7,  /* 7f7fff -> c0c0c0 */
  71     3,  /* 7fff00 -> 808000 */
  72     7,  /* 7fff7f -> c0c0c0 */
  73     7,  /* 7fffff -> c0c0c0 */
  74     9,  /* ff0000 -> ff0000 */
  75     5,  /* ff007f -> 800080 */
  76     13, /* ff00ff -> ff00ff */
  77     3,  /* ff7f00 -> 808000 */
  78     7,  /* ff7f7f -> c0c0c0 */
  79     7,  /* ff7fff -> c0c0c0 */
  80     11, /* ffff00 -> ffff00 */
  81     7,  /* ffff7f -> c0c0c0 */
  82     15  /* ffffff -> ffffff */
  83 };
  84
  85 #define PIXEL_VALUE(r,g,b) \
  86     COLOR_mapEGAPixel[EGAmapping[((r)*PRIMARY_LEVELS+(g))*PRIMARY_LEVELS+(b)]]
  87
  88   /* X image for building dithered pixmap */
  89 static XImage *ditherImage = NULL;
  90
  91
  92 /***********************************************************************
  93  *           BRUSH_Init
  94  *
  95  * Create the X image used for dithering.
  96  */
  97 BOOL32 BRUSH_Init(void)
  98 {
  99     XCREATEIMAGE( ditherImage, MATRIX_SIZE, MATRIX_SIZE, screenDepth );
 100     return (ditherImage != NULL);
 101 }
 102
 103
 104 /***********************************************************************
 105  *           BRUSH_DitherColor
 106  */
 107 Pixmap BRUSH_DitherColor( DC *dc, COLORREF color )
 108 {
 109     static COLORREF prevColor = 0xffffffff;
 110     unsigned int x, y;
 111     Pixmap pixmap;
 112
 113     if (color != prevColor)
 114     {
 115         int r = GetRValue( color ) * DITHER_LEVELS;
 116         int g = GetGValue( color ) * DITHER_LEVELS;
 117         int b = GetBValue( color ) * DITHER_LEVELS;
 118         const int *pmatrix = dither_matrix;
 119
 120         for (y = 0; y < MATRIX_SIZE; y++)
 121         {
 122             for (x = 0; x < MATRIX_SIZE; x++)
 123             {
 124                 int d  = *pmatrix++ * 256;
 125                 int dr = ((r + d) / MATRIX_SIZE_2) / 256;
 126                 int dg = ((g + d) / MATRIX_SIZE_2) / 256;
 127                 int db = ((b + d) / MATRIX_SIZE_2) / 256;
 128                 XPutPixel( ditherImage, x, y, PIXEL_VALUE(dr,dg,db) );
 129             }
 130         }
 131         prevColor = color;
 132     }
 133
 134     pixmap = XCreatePixmap( display, rootWindow,
 135                             MATRIX_SIZE, MATRIX_SIZE, screenDepth );
 136     XPutImage( display, pixmap, BITMAP_colorGC, ditherImage, 0, 0,
 137                0, 0, MATRIX_SIZE, MATRIX_SIZE );
 138     return pixmap;
 139 }
 140
 141
 142 /***********************************************************************
 143  *           CreateBrushIndirect16    (GDI.50)
 144  */
 145 HBRUSH16 CreateBrushIndirect16( const LOGBRUSH16 * brush )
 146 {
 147     BRUSHOBJ * brushPtr;
 148     HBRUSH16 hbrush = GDI_AllocObject( sizeof(BRUSHOBJ), BRUSH_MAGIC );
 149     if (!hbrush) return 0;
 150     brushPtr = (BRUSHOBJ *) GDI_HEAP_LIN_ADDR( hbrush );
 151     brushPtr->logbrush.lbStyle = brush->lbStyle;
 152     brushPtr->logbrush.lbColor = brush->lbColor;
 153     brushPtr->logbrush.lbHatch = brush->lbHatch;
 154     return hbrush;
 155 }
 156
 157
 158 /***********************************************************************
 159  *           CreateBrushIndirect32    (GDI32.27)
 160  */
 161 HBRUSH32 CreateBrushIndirect32( const LOGBRUSH32 * brush )
 162 {
 163     BRUSHOBJ * brushPtr;
 164     HBRUSH32 hbrush = GDI_AllocObject( sizeof(BRUSHOBJ), BRUSH_MAGIC );
 165     if (!hbrush) return 0;
 166     brushPtr = (BRUSHOBJ *) GDI_HEAP_LIN_ADDR( hbrush );
 167     brushPtr->logbrush.lbStyle = brush->lbStyle;
 168     brushPtr->logbrush.lbColor = brush->lbColor;
 169     brushPtr->logbrush.lbHatch = brush->lbHatch;
 170     return hbrush;
 171 }
 172
 173
 174 /***********************************************************************
 175  *           CreateHatchBrush16    (GDI.58)
 176  */
 177 HBRUSH16 CreateHatchBrush16( INT16 style, COLORREF color )
 178 {
 179     LOGBRUSH32 logbrush = { BS_HATCHED, color, style };
 180     dprintf_gdi(stddeb, "CreateHatchBrush16: %d %06lx\n", style, color );
 181     if ((style < 0) || (style >= NB_HATCH_STYLES)) return 0;
 182     return CreateBrushIndirect32( &logbrush );
 183 }
 184
 185
 186 /***********************************************************************
 187  *           CreateHatchBrush32    (GDI32.48)
 188  */
 189 HBRUSH32 CreateHatchBrush32( INT32 style, COLORREF color )
 190 {
 191     LOGBRUSH32 logbrush = { BS_HATCHED, color, style };
 192     dprintf_gdi(stddeb, "CreateHatchBrush32: %d %06lx\n", style, color );
 193     if ((style < 0) || (style >= NB_HATCH_STYLES)) return 0;
 194     return CreateBrushIndirect32( &logbrush );
 195 }
 196
 197
 198 /***********************************************************************
 199  *           CreatePatternBrush16    (GDI.60)
 200  */
 201 HBRUSH16 CreatePatternBrush16( HBITMAP16 hbitmap )
 202 {
 203     return (HBRUSH16)CreatePatternBrush32( hbitmap );
 204 }
 205
 206
 207 /***********************************************************************
 208  *           CreatePatternBrush32    (GDI32.54)
 209  */
 210 HBRUSH32 CreatePatternBrush32( HBITMAP32 hbitmap )
 211 {
 212     LOGBRUSH32 logbrush = { BS_PATTERN, 0, 0 };
 213     BITMAPOBJ *bmp, *newbmp;
 214
 215     dprintf_gdi(stddeb, "CreatePatternBrush: %04x\n", hbitmap );
 216
 217       /* Make a copy of the bitmap */
 218
 219     if (!(bmp = (BITMAPOBJ *) GDI_GetObjPtr( hbitmap, BITMAP_MAGIC )))
 220         return 0;
 221     logbrush.lbHatch = (INT32)CreateBitmapIndirect16( &bmp->bitmap );
 222     newbmp = (BITMAPOBJ *) GDI_GetObjPtr( (HGDIOBJ32)logbrush.lbHatch,
 223                                           BITMAP_MAGIC );
 224     if (!newbmp) return 0;
 225     XCopyArea( display, bmp->pixmap, newbmp->pixmap, BITMAP_GC(bmp),
 226                0, 0, bmp->bitmap.bmWidth, bmp->bitmap.bmHeight, 0, 0 );
 227     return CreateBrushIndirect32( &logbrush );
 228 }
 229
 230
 231 /***********************************************************************
 232  *           CreateDIBPatternBrush16    (GDI.445)
 233  */
 234 HBRUSH16 CreateDIBPatternBrush16( HGLOBAL16 hbitmap, UINT16 coloruse )
 235 {
 236     LOGBRUSH32 logbrush = { BS_DIBPATTERN, coloruse, 0 };
 237     BITMAPINFO *info, *newInfo;
 238     INT32 size;
 239
 240     dprintf_gdi(stddeb, "CreateDIBPatternBrush: %04x\n", hbitmap );
 241
 242       /* Make a copy of the bitmap */
 243
 244     if (!(info = (BITMAPINFO *)GlobalLock16( hbitmap ))) return 0;
 245
 246     if (info->bmiHeader.biCompression)
 247         size = info->bmiHeader.biSizeImage;
 248     else
 249         size = (info->bmiHeader.biWidth * info->bmiHeader.biBitCount + 31) / 32
 250                  * 8 * info->bmiHeader.biHeight;
 251     size += DIB_BitmapInfoSize( info, coloruse );
 252
 253     if (!(logbrush.lbHatch = (INT16)GlobalAlloc16( GMEM_MOVEABLE, size )))
 254     {
 255         GlobalUnlock16( hbitmap );
 256         return 0;
 257     }
 258     newInfo = (BITMAPINFO *) GlobalLock16( (HGLOBAL16)logbrush.lbHatch );
 259     memcpy( newInfo, info, size );
 260     GlobalUnlock16( (HGLOBAL16)logbrush.lbHatch );
 261     GlobalUnlock16( hbitmap );
 262     return CreateBrushIndirect32( &logbrush );
 263 }
 264
 265
 266 /***********************************************************************
 267  *           CreateDIBPatternBrush32    (GDI32.34)
 268  */
 269 HBRUSH32 CreateDIBPatternBrush32( HGLOBAL32 hbitmap, UINT32 coloruse )
 270 {
 271     LOGBRUSH32 logbrush = { BS_DIBPATTERN, coloruse, 0 };
 272     BITMAPINFO *info, *newInfo;
 273     INT32 size;
 274
 275     dprintf_gdi(stddeb, "CreateDIBPatternBrush: %04x\n", hbitmap );
 276
 277       /* Make a copy of the bitmap */
 278
 279     if (!(info = (BITMAPINFO *)GlobalLock32( hbitmap ))) return 0;
 280
 281     if (info->bmiHeader.biCompression)
 282         size = info->bmiHeader.biSizeImage;
 283     else
 284         size = (info->bmiHeader.biWidth * info->bmiHeader.biBitCount + 31) / 32
 285                  * 8 * info->bmiHeader.biHeight;
 286     size += DIB_BitmapInfoSize( info, coloruse );
 287
 288     if (!(logbrush.lbHatch = (INT32)GlobalAlloc16( GMEM_MOVEABLE, size )))
 289     {
 290         GlobalUnlock16( hbitmap );
 291         return 0;
 292     }
 293     newInfo = (BITMAPINFO *) GlobalLock16( (HGLOBAL16)logbrush.lbHatch );
 294     memcpy( newInfo, info, size );
 295     GlobalUnlock16( (HGLOBAL16)logbrush.lbHatch );
 296     GlobalUnlock16( hbitmap );
 297     return CreateBrushIndirect32( &logbrush );
 298 }
 299
 300
 301 /***********************************************************************
 302  *           CreateSolidBrush    (GDI.66)
 303  */
 304 HBRUSH16 CreateSolidBrush16( COLORREF color )
 305 {
 306     LOGBRUSH32 logbrush = { BS_SOLID, color, 0 };
 307     dprintf_gdi(stddeb, "CreateSolidBrush16: %06lx\n", color );
 308     return CreateBrushIndirect32( &logbrush );
 309 }
 310
 311
 312 /***********************************************************************
 313  *           CreateSolidBrush32    (GDI32.64)
 314  */
 315 HBRUSH32 CreateSolidBrush32( COLORREF color )
 316 {
 317     LOGBRUSH32 logbrush = { BS_SOLID, color, 0 };
 318     dprintf_gdi(stddeb, "CreateSolidBrush32: %06lx\n", color );
 319     return CreateBrushIndirect32( &logbrush );
 320 }
 321
 322
 323 /***********************************************************************
 324  *           SetBrushOrg    (GDI.148)
 325  */
 326 DWORD SetBrushOrg( HDC16 hdc, INT16 x, INT16 y )
 327 {
 328     DWORD retval;
 329     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 330     if (!dc) return FALSE;
 331     retval = dc->w.brushOrgX | (dc->w.brushOrgY << 16);
 332     dc->w.brushOrgX = x;
 333     dc->w.brushOrgY = y;
 334     return retval;
 335 }
 336
 337
 338 /***********************************************************************
 339  *           SetBrushOrgEx    (GDI32.308)
 340  */
 341 BOOL32 SetBrushOrgEx( HDC32 hdc, INT32 x, INT32 y, LPPOINT32 oldorg )
 342 {
 343     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 344
 345     if (!dc) return FALSE;
 346     if (oldorg)
 347     {
 348         oldorg->x = dc->w.brushOrgX;
 349         oldorg->y = dc->w.brushOrgY;
 350     }
 351     dc->w.brushOrgX = x;
 352     dc->w.brushOrgY = y;
 353     return TRUE;
 354 }
 355
 356
 357 /***********************************************************************
 358  *           GetSysColorBrush16    (USER.281)
 359  */
 360 HBRUSH16 GetSysColorBrush16( INT16 index )
 361 {
 362     fprintf( stderr, "Unimplemented stub: GetSysColorBrush16(%d)\n", index );
 363     return GetStockObject32(LTGRAY_BRUSH);
 364 }
 365
 366
 367 /***********************************************************************
 368  *           GetSysColorBrush32    (USER32.289)
 369  */
 370 HBRUSH32 GetSysColorBrush32( INT32 index)
 371 {
 372     fprintf( stderr, "Unimplemented stub: GetSysColorBrush32(%d)\n", index );
 373     return GetStockObject32(LTGRAY_BRUSH);
 374 }
 375
 376
 377 /***********************************************************************
 378  *           BRUSH_DeleteObject
 379  */
 380 BOOL32 BRUSH_DeleteObject( HBRUSH16 hbrush, BRUSHOBJ * brush )
 381 {
 382     switch(brush->logbrush.lbStyle)
 383     {
 384       case BS_PATTERN:
 385           DeleteObject32( (HGDIOBJ32)brush->logbrush.lbHatch );
 386           break;
 387       case BS_DIBPATTERN:
 388           GlobalFree16( (HGLOBAL16)brush->logbrush.lbHatch );
 389           break;
 390     }
 391     return GDI_FreeObject( hbrush );
 392 }
 393
 394
 395 /***********************************************************************
 396  *           BRUSH_GetObject16
 397  */
 398 INT16 BRUSH_GetObject16( BRUSHOBJ * brush, INT16 count, LPSTR buffer )
 399 {
 400     LOGBRUSH16 logbrush;
 401
 402     logbrush.lbStyle = brush->logbrush.lbStyle;
 403     logbrush.lbColor = brush->logbrush.lbColor;
 404     logbrush.lbHatch = brush->logbrush.lbHatch;
 405     if (count > sizeof(logbrush)) count = sizeof(logbrush);
 406     memcpy( buffer, &logbrush, count );
 407     return count;
 408 }
 409
 410
 411 /***********************************************************************
 412  *           BRUSH_GetObject32
 413  */
 414 INT32 BRUSH_GetObject32( BRUSHOBJ * brush, INT32 count, LPSTR buffer )
 415 {
 416     if (count > sizeof(brush->logbrush)) count = sizeof(brush->logbrush);
 417     memcpy( buffer, &brush->logbrush, count );
 418     return count;
 419 }
 420
 421
 422 /***********************************************************************
 423  *           BRUSH_SelectSolidBrush
 424  */
 425 static void BRUSH_SelectSolidBrush( DC *dc, COLORREF color )
 426 {
 427     if ((dc->w.bitsPerPixel > 1) && (screenDepth <= 8) && !COLOR_IsSolid( color ))
 428     {
 429           /* Dithered brush */
 430         dc->u.x.brush.pixmap = BRUSH_DitherColor( dc, color );
 431         dc->u.x.brush.fillStyle = FillTiled;
 432         dc->u.x.brush.pixel = 0;
 433     }
 434     else
 435     {
 436           /* Solid brush */
 437         dc->u.x.brush.pixel = COLOR_ToPhysical( dc, color );
 438         dc->u.x.brush.fillStyle = FillSolid;
 439     }
 440 }
 441
 442
 443 /***********************************************************************
 444  *           BRUSH_SelectPatternBrush
 445  */
 446 static BOOL32 BRUSH_SelectPatternBrush( DC * dc, HBITMAP32 hbitmap )
 447 {
 448     BITMAPOBJ * bmp = (BITMAPOBJ *) GDI_GetObjPtr( hbitmap, BITMAP_MAGIC );
 449     if (!bmp) return FALSE;
 450     dc->u.x.brush.pixmap = XCreatePixmap( display, rootWindow,
 451                                           8, 8, bmp->bitmap.bmBitsPixel );
 452     XCopyArea( display, bmp->pixmap, dc->u.x.brush.pixmap,
 453                BITMAP_GC(bmp), 0, 0, 8, 8, 0, 0 );
 454
 455     if (bmp->bitmap.bmBitsPixel > 1)
 456     {
 457         dc->u.x.brush.fillStyle = FillTiled;
 458         dc->u.x.brush.pixel = 0;  /* Ignored */
 459     }
 460     else
 461     {
 462         dc->u.x.brush.fillStyle = FillOpaqueStippled;
 463         dc->u.x.brush.pixel = -1;  /* Special case (see DC_SetupGCForBrush) */
 464     }
 465     return TRUE;
 466 }
 467
 468
 469
 470 /***********************************************************************
 471  *           BRUSH_SelectObject
 472  */
 473 HBRUSH32 BRUSH_SelectObject( DC * dc, HBRUSH32 hbrush, BRUSHOBJ * brush )
 474 {
 475     HBITMAP16 hBitmap;
 476     BITMAPINFO * bmpInfo;
 477     HBRUSH16 prevHandle = dc->w.hBrush;
 478
 479     dprintf_gdi(stddeb, "Brush_SelectObject: hdc=%04x hbrush=%04x\n",
 480                 dc->hSelf,hbrush);
 481     if (dc->header.wMagic == METAFILE_DC_MAGIC)
 482     {
 483         LOGBRUSH16 logbrush = { brush->logbrush.lbStyle,
 484                                 brush->logbrush.lbColor,
 485                                 brush->logbrush.lbHatch };
 486         switch (brush->logbrush.lbStyle)
 487         {
 488         case BS_SOLID:
 489         case BS_HATCHED:
 490         case BS_HOLLOW:
 491             if (!MF_CreateBrushIndirect( dc, hbrush, &logbrush )) return 0;
 492             break;
 493         case BS_PATTERN:
 494         case BS_DIBPATTERN:
 495             if (!MF_CreatePatternBrush( dc, hbrush, &logbrush )) return 0;
 496             break;
 497         }
 498         return 1;  /* FIXME? */
 499     }
 500
 501     dc->w.hBrush = hbrush;
 502
 503     if (dc->u.x.brush.pixmap)
 504     {
 505         XFreePixmap( display, dc->u.x.brush.pixmap );
 506         dc->u.x.brush.pixmap = 0;
 507     }
 508     dc->u.x.brush.style = brush->logbrush.lbStyle;
 509
 510     switch(brush->logbrush.lbStyle)
 511     {
 512       case BS_NULL:
 513         dprintf_gdi( stddeb,"BS_NULL\n" );
 514         break;
 515
 516       case BS_SOLID:
 517         dprintf_gdi( stddeb,"BS_SOLID\n" );
 518         BRUSH_SelectSolidBrush( dc, brush->logbrush.lbColor );
 519         break;
 520
 521       case BS_HATCHED:
 522         dprintf_gdi( stddeb, "BS_HATCHED\n" );
 523         dc->u.x.brush.pixel = COLOR_ToPhysical( dc, brush->logbrush.lbColor );
 524         dc->u.x.brush.pixmap = XCreateBitmapFromData( display, rootWindow,
 525                                  HatchBrushes[brush->logbrush.lbHatch], 8, 8 );
 526         dc->u.x.brush.fillStyle = FillStippled;
 527         break;
 528
 529       case BS_PATTERN:
 530         dprintf_gdi( stddeb, "BS_PATTERN\n");
 531         BRUSH_SelectPatternBrush( dc, (HBRUSH16)brush->logbrush.lbHatch );
 532         break;
 533
 534       case BS_DIBPATTERN:
 535         dprintf_gdi( stddeb, "BS_DIBPATTERN\n");
 536         if ((bmpInfo = (BITMAPINFO *) GlobalLock16( (HGLOBAL16)brush->logbrush.lbHatch )))
 537         {
 538             int size = DIB_BitmapInfoSize( bmpInfo, brush->logbrush.lbColor );
 539             hBitmap = CreateDIBitmap32( dc->hSelf, &bmpInfo->bmiHeader,
 540                                         CBM_INIT, ((char *)bmpInfo) + size,
 541                                         bmpInfo,
 542                                         (WORD)brush->logbrush.lbColor );
 543             BRUSH_SelectPatternBrush( dc, hBitmap );
 544             DeleteObject16( hBitmap );
 545             GlobalUnlock16( (HGLOBAL16)brush->logbrush.lbHatch );
 546         }
 547
 548         break;
 549     }
 550
 551     return prevHandle;
 552 }