objects/brush.c

   1 /*
   2  * GDI brush objects
   3  *
   4  * Copyright 1993, 1994  Alexandre Julliard
   5  */
   6
   7 #include <string.h>
   8 #include "winbase.h"
   9 #include "brush.h"
  10 #include "bitmap.h"
  11 #include "debug.h"
  12
  13 DEFAULT_DEBUG_CHANNEL(gdi)
  14
  15
  16 /***********************************************************************
  17  *           CreateBrushIndirect16    (GDI.50)
  18  */
  19 HBRUSH16 WINAPI CreateBrushIndirect16( const LOGBRUSH16 * brush )
  20 {
  21     BRUSHOBJ * brushPtr;
  22     HBRUSH16 hbrush = GDI_AllocObject( sizeof(BRUSHOBJ), BRUSH_MAGIC );
  23     if (!hbrush) return 0;
  24     brushPtr = (BRUSHOBJ *) GDI_HEAP_LOCK( hbrush );
  25     brushPtr->logbrush.lbStyle = brush->lbStyle;
  26     brushPtr->logbrush.lbColor = brush->lbColor;
  27     brushPtr->logbrush.lbHatch = brush->lbHatch;
  28     GDI_HEAP_UNLOCK( hbrush );
  29     TRACE(gdi, "%04x\n", hbrush);
  30     return hbrush;
  31 }
  32
  33
  34 /***********************************************************************
  35  *           CreateBrushIndirect32    (GDI32.27)
  36  */
  37 HBRUSH WINAPI CreateBrushIndirect( const LOGBRUSH * brush )
  38 {
  39     BRUSHOBJ * brushPtr;
  40     HBRUSH hbrush = GDI_AllocObject( sizeof(BRUSHOBJ), BRUSH_MAGIC );
  41     if (!hbrush) return 0;
  42     brushPtr = (BRUSHOBJ *) GDI_HEAP_LOCK( hbrush );
  43     brushPtr->logbrush.lbStyle = brush->lbStyle;
  44     brushPtr->logbrush.lbColor = brush->lbColor;
  45     brushPtr->logbrush.lbHatch = brush->lbHatch;
  46     GDI_HEAP_UNLOCK( hbrush );
  47     TRACE(gdi, "%08x\n", hbrush);
  48     return hbrush;
  49 }
  50
  51
  52 /***********************************************************************
  53  *           CreateHatchBrush16    (GDI.58)
  54  */
  55 HBRUSH16 WINAPI CreateHatchBrush16( INT16 style, COLORREF color )
  56 {
  57     LOGBRUSH logbrush;
  58
  59     TRACE(gdi, "%d %06lx\n", style, color );
  60
  61     logbrush.lbStyle = BS_HATCHED;
  62     logbrush.lbColor = color;
  63     logbrush.lbHatch = style;
  64
  65     if ((style < 0) || (style >= NB_HATCH_STYLES)) return 0;
  66     return CreateBrushIndirect( &logbrush );
  67 }
  68
  69
  70 /***********************************************************************
  71  *           CreateHatchBrush32    (GDI32.48)
  72  */
  73 HBRUSH WINAPI CreateHatchBrush( INT style, COLORREF color )
  74 {
  75     LOGBRUSH logbrush;
  76
  77     TRACE(gdi, "%d %06lx\n", style, color );
  78
  79     logbrush.lbStyle = BS_HATCHED;
  80     logbrush.lbColor = color;
  81     logbrush.lbHatch = style;
  82
  83     if ((style < 0) || (style >= NB_HATCH_STYLES)) return 0;
  84     return CreateBrushIndirect( &logbrush );
  85 }
  86
  87
  88 /***********************************************************************
  89  *           CreatePatternBrush16    (GDI.60)
  90  */
  91 HBRUSH16 WINAPI CreatePatternBrush16( HBITMAP16 hbitmap )
  92 {
  93     return (HBRUSH16)CreatePatternBrush( hbitmap );
  94 }
  95
  96
  97 /***********************************************************************
  98  *           CreatePatternBrush32    (GDI32.54)
  99  */
 100 HBRUSH WINAPI CreatePatternBrush( HBITMAP hbitmap )
 101 {
 102     LOGBRUSH logbrush = { BS_PATTERN, 0, 0 };
 103     TRACE(gdi, "%04x\n", hbitmap );
 104
 105     logbrush.lbHatch = (INT)BITMAP_CopyBitmap( hbitmap );
 106     if(!logbrush.lbHatch)
 107         return 0;
 108     else
 109         return CreateBrushIndirect( &logbrush );
 110 }
 111
 112
 113 /***********************************************************************
 114  *           CreateDIBPatternBrush16    (GDI.445)
 115  */
 116 HBRUSH16 WINAPI CreateDIBPatternBrush16( HGLOBAL16 hbitmap, UINT16 coloruse )
 117 {
 118     LOGBRUSH logbrush;
 119     BITMAPINFO *info, *newInfo;
 120     INT size;
 121
 122     TRACE(gdi, "%04x\n", hbitmap );
 123
 124     logbrush.lbStyle = BS_DIBPATTERN;
 125     logbrush.lbColor = coloruse;
 126     logbrush.lbHatch = 0;
 127
 128       /* Make a copy of the bitmap */
 129
 130     if (!(info = (BITMAPINFO *)GlobalLock16( hbitmap ))) return 0;
 131
 132     if (info->bmiHeader.biCompression)
 133         size = info->bmiHeader.biSizeImage;
 134     else
 135         size = DIB_GetDIBImageBytes(info->bmiHeader.biWidth,
 136                                     info->bmiHeader.biHeight,
 137                                     info->bmiHeader.biBitCount);
 138     size += DIB_BitmapInfoSize( info, coloruse );
 139
 140     if (!(logbrush.lbHatch = (INT16)GlobalAlloc16( GMEM_MOVEABLE, size )))
 141     {
 142         GlobalUnlock16( hbitmap );
 143         return 0;
 144     }
 145     newInfo = (BITMAPINFO *) GlobalLock16( (HGLOBAL16)logbrush.lbHatch );
 146     memcpy( newInfo, info, size );
 147     GlobalUnlock16( (HGLOBAL16)logbrush.lbHatch );
 148     GlobalUnlock16( hbitmap );
 149     return CreateBrushIndirect( &logbrush );
 150 }
 151
 152
 153 /***********************************************************************
 154  *           CreateDIBPatternBrush32    (GDI32.34)
 155  *
 156  *      Create a logical brush which has the pattern specified by the DIB
 157  *
 158  *      Function call is for compatability only.  CreateDIBPatternBrushPt should be used.
 159  *
 160  * RETURNS
 161  *
 162  *      Handle to a logical brush on success, NULL on failure.
 163  *
 164  * BUGS
 165  *
 166  */
 167 HBRUSH WINAPI CreateDIBPatternBrush(
 168                 HGLOBAL hbitmap,                /* Global object containg BITMAPINFO structure */
 169                 UINT coloruse           /* Specifies color format, if provided */
 170 )
 171 {
 172     LOGBRUSH logbrush;
 173     BITMAPINFO *info, *newInfo;
 174     INT size;
 175
 176     TRACE(gdi, "%04x\n", hbitmap );
 177
 178     logbrush.lbStyle = BS_DIBPATTERN;
 179     logbrush.lbColor = coloruse;
 180     logbrush.lbHatch = 0;
 181
 182       /* Make a copy of the bitmap */
 183
 184     if (!(info = (BITMAPINFO *)GlobalLock( hbitmap ))) return 0;
 185
 186     if (info->bmiHeader.biCompression)
 187         size = info->bmiHeader.biSizeImage;
 188     else
 189         size = DIB_GetDIBImageBytes(info->bmiHeader.biWidth,
 190                                     info->bmiHeader.biHeight,
 191                                     info->bmiHeader.biBitCount);
 192     size += DIB_BitmapInfoSize( info, coloruse );
 193
 194     if (!(logbrush.lbHatch = (INT)GlobalAlloc16( GMEM_MOVEABLE, size )))
 195     {
 196         GlobalUnlock16( hbitmap );
 197         return 0;
 198     }
 199     newInfo = (BITMAPINFO *) GlobalLock16( (HGLOBAL16)logbrush.lbHatch );
 200     memcpy( newInfo, info, size );
 201     GlobalUnlock16( (HGLOBAL16)logbrush.lbHatch );
 202     GlobalUnlock( hbitmap );
 203     return CreateBrushIndirect( &logbrush );
 204 }
 205
 206
 207 /***********************************************************************
 208  *           CreateDIBPatternBrushPt    (GDI32.35)
 209  *
 210  *      Create a logical brush which has the pattern specified by the DIB
 211  *
 212  * RETURNS
 213  *
 214  *      Handle to a logical brush on success, NULL on failure.
 215  *
 216  * BUGS
 217  *
 218  */
 219 HBRUSH WINAPI CreateDIBPatternBrushPt(
 220                 const void* data,               /* Pointer to a BITMAPINFO structure followed by more data */
 221                 UINT coloruse           /* Specifies color format, if provided */
 222 )
 223 {
 224     BITMAPINFO *info=(BITMAPINFO*)data;
 225     LOGBRUSH logbrush = { BS_DIBPATTERN, coloruse, 0 };
 226     BITMAPINFO  *newInfo;
 227     INT size;
 228
 229     TRACE(gdi, "%p %ldx%ld %dbpp\n", info, info->bmiHeader.biWidth,
 230           info->bmiHeader.biHeight,  info->bmiHeader.biBitCount);
 231
 232       /* Make a copy of the bitmap */
 233
 234
 235     if (info->bmiHeader.biCompression)
 236         size = info->bmiHeader.biSizeImage;
 237     else
 238         size = DIB_GetDIBImageBytes(info->bmiHeader.biWidth,
 239                                     info->bmiHeader.biHeight,
 240                                     info->bmiHeader.biBitCount);
 241     size += DIB_BitmapInfoSize( info, coloruse );
 242
 243     if (!(logbrush.lbHatch = (INT)GlobalAlloc16( GMEM_MOVEABLE, size )))
 244     {
 245         return 0;
 246     }
 247     newInfo = (BITMAPINFO *) GlobalLock16( (HGLOBAL16)logbrush.lbHatch );
 248     memcpy( newInfo, info, size );
 249     GlobalUnlock16( (HGLOBAL16)logbrush.lbHatch );
 250     return CreateBrushIndirect( &logbrush );
 251 }
 252
 253
 254 /***********************************************************************
 255  *           CreateSolidBrush    (GDI.66)
 256  */
 257 HBRUSH16 WINAPI CreateSolidBrush16( COLORREF color )
 258 {
 259     LOGBRUSH logbrush;
 260
 261     TRACE(gdi, "%06lx\n", color );
 262
 263     logbrush.lbStyle = BS_SOLID;
 264     logbrush.lbColor = color;
 265     logbrush.lbHatch = 0;
 266
 267     return CreateBrushIndirect( &logbrush );
 268 }
 269
 270
 271 /***********************************************************************
 272  *           CreateSolidBrush32    (GDI32.64)
 273  */
 274 HBRUSH WINAPI CreateSolidBrush( COLORREF color )
 275 {
 276     LOGBRUSH logbrush;
 277
 278     TRACE(gdi, "%06lx\n", color );
 279
 280     logbrush.lbStyle = BS_SOLID;
 281     logbrush.lbColor = color;
 282     logbrush.lbHatch = 0;
 283
 284     return CreateBrushIndirect( &logbrush );
 285 }
 286
 287
 288 /***********************************************************************
 289  *           SetBrushOrg    (GDI.148)
 290  */
 291 DWORD WINAPI SetBrushOrg16( HDC16 hdc, INT16 x, INT16 y )
 292 {
 293     DWORD retval;
 294     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 295     if (!dc) return FALSE;
 296     retval = dc->w.brushOrgX | (dc->w.brushOrgY << 16);
 297     dc->w.brushOrgX = x;
 298     dc->w.brushOrgY = y;
 299     return retval;
 300 }
 301
 302
 303 /***********************************************************************
 304  *           SetBrushOrgEx    (GDI32.308)
 305  */
 306 BOOL WINAPI SetBrushOrgEx( HDC hdc, INT x, INT y, LPPOINT oldorg )
 307 {
 308     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 309
 310     if (!dc) return FALSE;
 311     if (oldorg)
 312     {
 313         oldorg->x = dc->w.brushOrgX;
 314         oldorg->y = dc->w.brushOrgY;
 315     }
 316     dc->w.brushOrgX = x;
 317     dc->w.brushOrgY = y;
 318     return TRUE;
 319 }
 320
 321 /***********************************************************************
 322  *           FixBrushOrgEx    (GDI32.102)
 323  * SDK says discontinued, but in Win95 GDI32 this is the same as SetBrushOrgEx
 324  */
 325 BOOL WINAPI FixBrushOrgEx( HDC hdc, INT x, INT y, LPPOINT oldorg )
 326 {
 327     return SetBrushOrgEx(hdc,x,y,oldorg);
 328 }
 329
 330
 331 /***********************************************************************
 332  *           BRUSH_DeleteObject
 333  */
 334 BOOL BRUSH_DeleteObject( HBRUSH16 hbrush, BRUSHOBJ * brush )
 335 {
 336     switch(brush->logbrush.lbStyle)
 337     {
 338       case BS_PATTERN:
 339           DeleteObject( (HGDIOBJ)brush->logbrush.lbHatch );
 340           break;
 341       case BS_DIBPATTERN:
 342           GlobalFree16( (HGLOBAL16)brush->logbrush.lbHatch );
 343           break;
 344     }
 345     return GDI_FreeObject( hbrush );
 346 }
 347
 348
 349 /***********************************************************************
 350  *           BRUSH_GetObject16
 351  */
 352 INT16 BRUSH_GetObject16( BRUSHOBJ * brush, INT16 count, LPSTR buffer )
 353 {
 354     LOGBRUSH16 logbrush;
 355
 356     logbrush.lbStyle = brush->logbrush.lbStyle;
 357     logbrush.lbColor = brush->logbrush.lbColor;
 358     logbrush.lbHatch = brush->logbrush.lbHatch;
 359     if (count > sizeof(logbrush)) count = sizeof(logbrush);
 360     memcpy( buffer, &logbrush, count );
 361     return count;
 362 }
 363
 364
 365 /***********************************************************************
 366  *           BRUSH_GetObject32
 367  */
 368 INT BRUSH_GetObject( BRUSHOBJ * brush, INT count, LPSTR buffer )
 369 {
 370     if (count > sizeof(brush->logbrush)) count = sizeof(brush->logbrush);
 371     memcpy( buffer, &brush->logbrush, count );
 372     return count;
 373 }
 374
 375
 376 /***********************************************************************
 377  *           SetSolidBrush16   (GDI.604)
 378  *
 379  *  If hBrush is a solid brush, change it's color to newColor.
 380  *
 381  *  RETURNS
 382  *           TRUE on success, FALSE on failure.
 383  *   FIXME: not yet implemented!
 384  */
 385 BOOL16 WINAPI SetSolidBrush16(HBRUSH16 hBrush, COLORREF newColor )
 386 {
 387      FIXME(gdi, "(hBrush %04x, newColor %04x): stub!\n", hBrush, (int)newColor);
 388
 389      return(FALSE);
 390 }
 391