objects/brush.c

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