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