objects/brush.c

   1 /*
   2  * GDI brush objects
   3  *
   4  * Copyright 1993 Alexandre Julliard
   5  *
   6 static char Copyright[] = "Copyright  Alexandre Julliard, 1993";
   7 */
   8
   9 #include "gdi.h"
  10 #include "bitmap.h"
  11 #include "metafile.h"
  12 #include "stddebug.h"
  13 #include "color.h"
  14 #include "debug.h"
  15
  16 #define NB_HATCH_STYLES  6
  17
  18 static char HatchBrushes[NB_HATCH_STYLES][8] =
  19 {
  20     { 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00 }, /* HS_HORIZONTAL */
  21     { 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08 }, /* HS_VERTICAL   */
  22     { 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80 }, /* HS_FDIAGONAL  */
  23     { 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01 }, /* HS_BDIAGONAL  */
  24     { 0x08, 0x08, 0x08, 0xff, 0x08, 0x08, 0x08, 0x08 }, /* HS_CROSS      */
  25     { 0x81, 0x42, 0x24, 0x18, 0x18, 0x24, 0x42, 0x81 }  /* HS_DIAGCROSS  */
  26 };
  27
  28
  29 /***********************************************************************
  30  *           CreateBrushIndirect    (GDI.50)
  31  */
  32 HBRUSH CreateBrushIndirect( LOGBRUSH * brush )
  33 {
  34     BRUSHOBJ * brushPtr;
  35     HBRUSH hbrush = GDI_AllocObject( sizeof(BRUSHOBJ), BRUSH_MAGIC );
  36     if (!hbrush) return 0;
  37     brushPtr = (BRUSHOBJ *) GDI_HEAP_ADDR( hbrush );
  38     memcpy( &brushPtr->logbrush, brush, sizeof(LOGBRUSH) );
  39     return hbrush;
  40 }
  41
  42
  43 /***********************************************************************
  44  *           CreateHatchBrush    (GDI.58)
  45  */
  46 HBRUSH CreateHatchBrush( short style, COLORREF color )
  47 {
  48     LOGBRUSH logbrush = { BS_HATCHED, color, style };
  49     dprintf_gdi(stddeb, "CreateHatchBrush: %d %06lx\n", style, color );
  50     if ((style < 0) || (style >= NB_HATCH_STYLES)) return 0;
  51     return CreateBrushIndirect( &logbrush );
  52 }
  53
  54
  55 /***********************************************************************
  56  *           CreatePatternBrush    (GDI.60)
  57  */
  58 HBRUSH CreatePatternBrush( HBITMAP hbitmap )
  59 {
  60     LOGBRUSH logbrush = { BS_PATTERN, 0, 0 };
  61     BITMAPOBJ *bmp, *newbmp;
  62
  63     dprintf_gdi(stddeb, "CreatePatternBrush: %d\n", hbitmap );
  64
  65       /* Make a copy of the bitmap */
  66
  67     if (!(bmp = (BITMAPOBJ *) GDI_GetObjPtr( hbitmap, BITMAP_MAGIC )))
  68         return 0;
  69     logbrush.lbHatch = CreateBitmapIndirect( &bmp->bitmap );
  70     newbmp = (BITMAPOBJ *) GDI_GetObjPtr( logbrush.lbHatch, BITMAP_MAGIC );
  71     if (!newbmp) return 0;
  72     XCopyArea( display, bmp->pixmap, newbmp->pixmap, BITMAP_GC(bmp),
  73                0, 0, bmp->bitmap.bmWidth, bmp->bitmap.bmHeight, 0, 0 );
  74     return CreateBrushIndirect( &logbrush );
  75 }
  76
  77
  78 /***********************************************************************
  79  *           CreateDIBPatternBrush    (GDI.445)
  80  */
  81 HBRUSH CreateDIBPatternBrush( HANDLE hbitmap, WORD coloruse )
  82 {
  83     LOGBRUSH logbrush = { BS_DIBPATTERN, coloruse, 0 };
  84     BITMAPINFO *info, *newInfo;
  85     int size;
  86
  87     dprintf_gdi(stddeb, "CreateDIBPatternBrush: %d\n", hbitmap );
  88
  89       /* Make a copy of the bitmap */
  90
  91     if (!(info = (BITMAPINFO *) GlobalLock( hbitmap ))) return 0;
  92
  93     size = info->bmiHeader.biSizeImage;
  94     if (!size)
  95         size = (info->bmiHeader.biWidth * info->bmiHeader.biBitCount + 31) / 32
  96                  * 8 * info->bmiHeader.biHeight;
  97     size += DIB_BitmapInfoSize( info, coloruse );
  98
  99     if (!(logbrush.lbHatch = GlobalAlloc( GMEM_MOVEABLE, size )))
 100     {
 101         GlobalUnlock( hbitmap );
 102         return 0;
 103     }
 104     newInfo = (BITMAPINFO *) GlobalLock( logbrush.lbHatch );
 105     memcpy( newInfo, info, size );
 106     GlobalUnlock( logbrush.lbHatch );
 107     GlobalUnlock( hbitmap );
 108     return CreateBrushIndirect( &logbrush );
 109 }
 110
 111
 112 /***********************************************************************
 113  *           CreateSolidBrush    (GDI.66)
 114  */
 115 HBRUSH CreateSolidBrush( COLORREF color )
 116 {
 117     LOGBRUSH logbrush = { BS_SOLID, color, 0 };
 118     dprintf_gdi(stddeb, "CreateSolidBrush: %06lx\n", color );
 119     return CreateBrushIndirect( &logbrush );
 120 }
 121
 122
 123 /***********************************************************************
 124  *           SetBrushOrg    (GDI.148)
 125  */
 126 DWORD SetBrushOrg( HDC hdc, short x, short y )
 127 {
 128     DWORD retval;
 129     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 130     if (!dc) return FALSE;
 131     retval = dc->w.brushOrgX | (dc->w.brushOrgY << 16);
 132     dc->w.brushOrgX = x;
 133     dc->w.brushOrgY = y;
 134     return retval;
 135 }
 136
 137 /***********************************************************************
 138  *           GetSysColorBrush    (USER.281)
 139  */
 140 WORD GetSysColorBrush(WORD x)
 141 {
 142         return GetStockObject(GRAY_BRUSH);
 143 }
 144
 145 /***********************************************************************
 146  *           BRUSH_DeleteObject
 147  */
 148 BOOL BRUSH_DeleteObject( HBRUSH hbrush, BRUSHOBJ * brush )
 149 {
 150     switch(brush->logbrush.lbStyle)
 151     {
 152       case BS_PATTERN:
 153           DeleteObject( brush->logbrush.lbHatch );
 154           break;
 155       case BS_DIBPATTERN:
 156           GlobalFree( brush->logbrush.lbHatch );
 157           break;
 158     }
 159     return GDI_FreeObject( hbrush );
 160 }
 161
 162
 163 /***********************************************************************
 164  *           BRUSH_GetObject
 165  */
 166 int BRUSH_GetObject( BRUSHOBJ * brush, int count, LPSTR buffer )
 167 {
 168     if (count > sizeof(LOGBRUSH)) count = sizeof(LOGBRUSH);
 169     memcpy( buffer, &brush->logbrush, count );
 170     return count;
 171 }
 172
 173
 174 /***********************************************************************
 175  *           BRUSH_MakeSolidBrush
 176  */
 177 static void BRUSH_SelectSolidBrush( DC *dc, COLORREF color )
 178 {
 179     if ((dc->w.bitsPerPixel > 1) && (screenDepth <= 8) && !COLOR_IsSolid( color ))
 180     {
 181           /* Dithered brush */
 182         dc->u.x.brush.pixmap = DITHER_DitherColor( dc, color );
 183         dc->u.x.brush.fillStyle = FillTiled;
 184         dc->u.x.brush.pixel = 0;
 185     }
 186     else
 187     {
 188           /* Solid brush */
 189         dc->u.x.brush.pixel = COLOR_ToPhysical( dc, color );
 190         dc->u.x.brush.fillStyle = FillSolid;
 191     }
 192 }
 193
 194
 195 /***********************************************************************
 196  *           BRUSH_SelectPatternBrush
 197  */
 198 static BOOL BRUSH_SelectPatternBrush( DC * dc, HBITMAP hbitmap )
 199 {
 200     BITMAPOBJ * bmp = (BITMAPOBJ *) GDI_GetObjPtr( hbitmap, BITMAP_MAGIC );
 201     if (!bmp) return FALSE;
 202     dc->u.x.brush.pixmap = XCreatePixmap( display, rootWindow,
 203                                           8, 8, bmp->bitmap.bmBitsPixel );
 204     XCopyArea( display, bmp->pixmap, dc->u.x.brush.pixmap,
 205                BITMAP_GC(bmp), 0, 0, 8, 8, 0, 0 );
 206
 207     if (bmp->bitmap.bmBitsPixel > 1)
 208     {
 209         dc->u.x.brush.fillStyle = FillTiled;
 210         dc->u.x.brush.pixel = 0;  /* Ignored */
 211     }
 212     else
 213     {
 214         dc->u.x.brush.fillStyle = FillOpaqueStippled;
 215         dc->u.x.brush.pixel = -1;  /* Special case (see DC_SetupGCForBrush) */
 216     }
 217     return TRUE;
 218 }
 219
 220
 221
 222 /***********************************************************************
 223  *           BRUSH_SelectObject
 224  */
 225 HBRUSH BRUSH_SelectObject( HDC hdc, DC * dc, HBRUSH hbrush, BRUSHOBJ * brush )
 226 {
 227     HBITMAP hBitmap;
 228     BITMAPINFO * bmpInfo;
 229     HBRUSH prevHandle = dc->w.hBrush;
 230
 231     dprintf_gdi(stddeb, "Brush_SelectObject   hdc=%04x  hbrush=%04x\n",
 232                 hdc,hbrush);
 233     if (dc->header.wMagic == METAFILE_DC_MAGIC)
 234     {
 235         switch (brush->logbrush.lbStyle)
 236         {
 237         case BS_SOLID:
 238         case BS_HATCHED:
 239         case BS_HOLLOW:
 240             if (!MF_CreateBrushIndirect(dc, hbrush, &(brush->logbrush)))
 241                 return 0;
 242             break;
 243
 244         case BS_PATTERN:
 245         case BS_DIBPATTERN:
 246             if (!MF_CreatePatternBrush(dc, hbrush, &(brush->logbrush)))
 247                 return 0;
 248             break;
 249         }
 250         return 1;
 251     }
 252
 253     dc->w.hBrush = hbrush;
 254
 255     if (dc->u.x.brush.pixmap)
 256     {
 257         XFreePixmap( display, dc->u.x.brush.pixmap );
 258         dc->u.x.brush.pixmap = 0;
 259     }
 260     dc->u.x.brush.style = brush->logbrush.lbStyle;
 261
 262     switch(brush->logbrush.lbStyle)
 263     {
 264       case BS_NULL:
 265         dprintf_gdi( stddeb,"BS_NULL\n" );
 266         break;
 267
 268       case BS_SOLID:
 269         dprintf_gdi( stddeb,"BS_SOLID\n" );
 270         BRUSH_SelectSolidBrush( dc, brush->logbrush.lbColor );
 271         break;
 272
 273       case BS_HATCHED:
 274         dprintf_gdi( stddeb, "BS_HATCHED\n" );
 275         dc->u.x.brush.pixel = COLOR_ToPhysical( dc, brush->logbrush.lbColor );
 276         dc->u.x.brush.pixmap = XCreateBitmapFromData( display, rootWindow,
 277                                  HatchBrushes[brush->logbrush.lbHatch], 8, 8 );
 278         dc->u.x.brush.fillStyle = FillStippled;
 279         break;
 280
 281       case BS_PATTERN:
 282         dprintf_gdi( stddeb, "BS_PATTERN\n");
 283         BRUSH_SelectPatternBrush( dc, brush->logbrush.lbHatch );
 284         break;
 285
 286       case BS_DIBPATTERN:
 287         dprintf_gdi( stddeb, "BS_DIBPATTERN\n");
 288         if ((bmpInfo = (BITMAPINFO *) GlobalLock( brush->logbrush.lbHatch )))
 289         {
 290             int size = DIB_BitmapInfoSize( bmpInfo, brush->logbrush.lbColor );
 291             hBitmap = CreateDIBitmap( hdc, &bmpInfo->bmiHeader, CBM_INIT,
 292                                       ((char *)bmpInfo) + size, bmpInfo,
 293                                       (WORD) brush->logbrush.lbColor );
 294             BRUSH_SelectPatternBrush( dc, hBitmap );
 295             DeleteObject( hBitmap );
 296             GlobalUnlock( brush->logbrush.lbHatch );
 297         }
 298
 299         break;
 300     }
 301
 302     return prevHandle;
 303 }