4 * Copyright 1993, 1994 Alexandre Julliard
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
29 #include "gdi_private.h"
30 #include "wine/debug.h"
32 WINE_DEFAULT_DEBUG_CHANNEL(gdi
);
34 /* GDI logical brush object */
39 struct brush_pattern pattern
;
42 #define NB_HATCH_STYLES 6
44 static HGDIOBJ
BRUSH_SelectObject( HGDIOBJ handle
, HDC hdc
);
45 static INT
BRUSH_GetObject( HGDIOBJ handle
, INT count
, LPVOID buffer
);
46 static BOOL
BRUSH_DeleteObject( HGDIOBJ handle
);
48 static const struct gdi_obj_funcs brush_funcs
=
50 BRUSH_SelectObject
, /* pSelectObject */
51 BRUSH_GetObject
, /* pGetObjectA */
52 BRUSH_GetObject
, /* pGetObjectW */
53 NULL
, /* pUnrealizeObject */
54 BRUSH_DeleteObject
/* pDeleteObject */
58 static BOOL
copy_bitmap( struct brush_pattern
*brush
, HBITMAP bitmap
)
60 char buffer
[FIELD_OFFSET( BITMAPINFO
, bmiColors
[256])];
61 BITMAPINFO
*info
= (BITMAPINFO
*)buffer
;
62 struct gdi_image_bits bits
;
63 struct bitblt_coords src
;
64 BITMAPOBJ
*bmp
= GDI_GetObjPtr( bitmap
, OBJ_BITMAP
);
66 if (!bmp
) return FALSE
;
68 src
.visrect
.left
= src
.x
= 0;
69 src
.visrect
.top
= src
.y
= 0;
70 src
.visrect
.right
= src
.width
= bmp
->dib
.dsBm
.bmWidth
;
71 src
.visrect
.bottom
= src
.height
= bmp
->dib
.dsBm
.bmHeight
;
72 if (bmp
->funcs
->pGetImage( NULL
, bitmap
, info
, &bits
, &src
)) goto done
;
77 if (!(brush
->bits
.ptr
= HeapAlloc( GetProcessHeap(), 0, info
->bmiHeader
.biSizeImage
))) goto done
;
78 memcpy( brush
->bits
.ptr
, bits
.ptr
, info
->bmiHeader
.biSizeImage
);
79 brush
->bits
.free
= free_heap_bits
;
82 if (!(brush
->info
= HeapAlloc( GetProcessHeap(), 0, get_dib_info_size( info
, DIB_RGB_COLORS
))))
84 if (brush
->bits
.free
) brush
->bits
.free( &brush
->bits
);
87 memcpy( brush
->info
, info
, get_dib_info_size( info
, DIB_RGB_COLORS
));
88 brush
->bits
.is_copy
= FALSE
; /* the bits can't be modified */
89 brush
->usage
= DIB_RGB_COLORS
;
92 GDI_ReleaseObj( bitmap
);
93 return brush
->info
!= NULL
;
96 BOOL
store_brush_pattern( LOGBRUSH
*brush
, struct brush_pattern
*pattern
)
101 pattern
->info
= NULL
;
102 pattern
->bits
.free
= NULL
;
104 switch (brush
->lbStyle
)
111 if (brush
->lbHatch
> HS_DIAGCROSS
)
113 if (brush
->lbHatch
>= HS_API_MAX
) return FALSE
;
114 brush
->lbStyle
= BS_SOLID
;
120 brush
->lbStyle
= BS_PATTERN
;
124 return copy_bitmap( pattern
, (HBITMAP
)brush
->lbHatch
);
127 hmem
= (HGLOBAL
)brush
->lbHatch
;
128 if (!(brush
->lbHatch
= (ULONG_PTR
)GlobalLock( hmem
))) return FALSE
;
130 case BS_DIBPATTERNPT
:
131 pattern
->usage
= brush
->lbColor
;
132 pattern
->info
= copy_packed_dib( (BITMAPINFO
*)brush
->lbHatch
, pattern
->usage
);
133 if (hmem
) GlobalUnlock( hmem
);
134 if (!pattern
->info
) return FALSE
;
135 pattern
->bits
.ptr
= (char *)pattern
->info
+ get_dib_info_size( pattern
->info
, pattern
->usage
);
136 brush
->lbStyle
= BS_DIBPATTERN
;
140 case BS_DIBPATTERN8X8
:
144 WARN( "invalid brush style %u\n", brush
->lbStyle
);
149 void free_brush_pattern( struct brush_pattern
*pattern
)
151 if (pattern
->bits
.free
) pattern
->bits
.free( &pattern
->bits
);
152 HeapFree( GetProcessHeap(), 0, pattern
->info
);
155 BOOL
get_brush_bitmap_info( HBRUSH handle
, BITMAPINFO
*info
, void **bits
, UINT
*usage
)
160 if (!(brush
= GDI_GetObjPtr( handle
, OBJ_BRUSH
))) return FALSE
;
162 if (brush
->pattern
.info
)
164 memcpy( info
, brush
->pattern
.info
, get_dib_info_size( brush
->pattern
.info
, brush
->pattern
.usage
));
165 if (info
->bmiHeader
.biBitCount
<= 8 && !info
->bmiHeader
.biClrUsed
)
166 fill_default_color_table( info
);
167 *bits
= brush
->pattern
.bits
.ptr
;
168 *usage
= brush
->pattern
.usage
;
171 GDI_ReleaseObj( handle
);
176 /***********************************************************************
177 * CreateBrushIndirect (GDI32.@)
179 * Create a logical brush with a given style, color or pattern.
182 * brush [I] Pointer to a LOGBRUSH structure describing the desired brush.
185 * A handle to the created brush, or a NULL handle if the brush cannot be
189 * - The brush returned should be freed by the caller using DeleteObject()
190 * when it is no longer required.
191 * - Windows 95 and earlier cannot create brushes from bitmaps or DIBs larger
192 * than 8x8 pixels. If a larger bitmap is given, only a portion of the bitmap
195 HBRUSH WINAPI
CreateBrushIndirect( const LOGBRUSH
* brush
)
200 if (!(ptr
= HeapAlloc( GetProcessHeap(), 0, sizeof(*ptr
) ))) return 0;
202 ptr
->logbrush
= *brush
;
204 if (store_brush_pattern( &ptr
->logbrush
, &ptr
->pattern
) &&
205 (hbrush
= alloc_gdi_handle( &ptr
->header
, OBJ_BRUSH
, &brush_funcs
)))
207 TRACE("%p\n", hbrush
);
211 free_brush_pattern( &ptr
->pattern
);
212 HeapFree( GetProcessHeap(), 0, ptr
);
217 /***********************************************************************
218 * CreateHatchBrush (GDI32.@)
220 * Create a logical brush with a hatched pattern.
223 * style [I] Direction of lines for the hatch pattern (HS_* values from "wingdi.h")
224 * color [I] Colour of the hatched pattern
227 * A handle to the created brush, or a NULL handle if the brush cannot
231 * - This function uses CreateBrushIndirect() to create the brush.
232 * - The brush returned should be freed by the caller using DeleteObject()
233 * when it is no longer required.
235 HBRUSH WINAPI
CreateHatchBrush( INT style
, COLORREF color
)
239 TRACE("%d %06x\n", style
, color
);
241 logbrush
.lbStyle
= BS_HATCHED
;
242 logbrush
.lbColor
= color
;
243 logbrush
.lbHatch
= style
;
245 return CreateBrushIndirect( &logbrush
);
249 /***********************************************************************
250 * CreatePatternBrush (GDI32.@)
252 * Create a logical brush with a pattern from a bitmap.
255 * hbitmap [I] Bitmap containing pattern for the brush
258 * A handle to the created brush, or a NULL handle if the brush cannot
262 * - This function uses CreateBrushIndirect() to create the brush.
263 * - The brush returned should be freed by the caller using DeleteObject()
264 * when it is no longer required.
266 HBRUSH WINAPI
CreatePatternBrush( HBITMAP hbitmap
)
268 LOGBRUSH logbrush
= { BS_PATTERN
, 0, 0 };
269 TRACE("%p\n", hbitmap
);
271 logbrush
.lbHatch
= (ULONG_PTR
)hbitmap
;
272 return CreateBrushIndirect( &logbrush
);
276 /***********************************************************************
277 * CreateDIBPatternBrush (GDI32.@)
279 * Create a logical brush with a pattern from a DIB.
282 * hbitmap [I] Global object containing BITMAPINFO structure for the pattern
283 * coloruse [I] Specifies color format, if provided
286 * A handle to the created brush, or a NULL handle if the brush cannot
290 * - This function uses CreateBrushIndirect() to create the brush.
291 * - The brush returned should be freed by the caller using DeleteObject()
292 * when it is no longer required.
293 * - This function is for compatibility only. CreateDIBPatternBrushPt() should
296 HBRUSH WINAPI
CreateDIBPatternBrush( HGLOBAL hbitmap
, UINT coloruse
)
300 TRACE("%p\n", hbitmap
);
302 logbrush
.lbStyle
= BS_DIBPATTERN
;
303 logbrush
.lbColor
= coloruse
;
305 logbrush
.lbHatch
= (ULONG_PTR
)hbitmap
;
307 return CreateBrushIndirect( &logbrush
);
311 /***********************************************************************
312 * CreateDIBPatternBrushPt (GDI32.@)
314 * Create a logical brush with a pattern from a DIB.
317 * data [I] Pointer to a BITMAPINFO structure and image data for the pattern
318 * coloruse [I] Specifies color format, if provided
321 * A handle to the created brush, or a NULL handle if the brush cannot
325 * - This function uses CreateBrushIndirect() to create the brush.
326 * - The brush returned should be freed by the caller using DeleteObject()
327 * when it is no longer required.
329 HBRUSH WINAPI
CreateDIBPatternBrushPt( const void* data
, UINT coloruse
)
331 const BITMAPINFO
*info
=data
;
337 TRACE("%p %dx%d %dbpp\n", info
, info
->bmiHeader
.biWidth
,
338 info
->bmiHeader
.biHeight
, info
->bmiHeader
.biBitCount
);
340 logbrush
.lbStyle
= BS_DIBPATTERNPT
;
341 logbrush
.lbColor
= coloruse
;
342 logbrush
.lbHatch
= (ULONG_PTR
)data
;
344 return CreateBrushIndirect( &logbrush
);
348 /***********************************************************************
349 * CreateSolidBrush (GDI32.@)
351 * Create a logical brush consisting of a single colour.
354 * color [I] Colour to make the solid brush
357 * A handle to the newly created brush, or a NULL handle if the brush cannot
361 * - This function uses CreateBrushIndirect() to create the brush.
362 * - The brush returned should be freed by the caller using DeleteObject()
363 * when it is no longer required.
365 HBRUSH WINAPI
CreateSolidBrush( COLORREF color
)
369 TRACE("%06x\n", color
);
371 logbrush
.lbStyle
= BS_SOLID
;
372 logbrush
.lbColor
= color
;
373 logbrush
.lbHatch
= 0;
375 return CreateBrushIndirect( &logbrush
);
379 /***********************************************************************
380 * SetBrushOrgEx (GDI32.@)
382 * Set the brush origin for a device context.
385 * hdc [I] Device context to set the brush origin for
388 * oldorg [O] If non NULL, destination for previously set brush origin.
391 * Success: TRUE. The origin is set to (x,y), and oldorg is updated if given.
393 BOOL WINAPI
SetBrushOrgEx( HDC hdc
, INT x
, INT y
, LPPOINT oldorg
)
395 DC
*dc
= get_dc_ptr( hdc
);
397 if (!dc
) return FALSE
;
400 oldorg
->x
= dc
->brushOrgX
;
401 oldorg
->y
= dc
->brushOrgY
;
405 release_dc_ptr( dc
);
409 /***********************************************************************
410 * FixBrushOrgEx (GDI32.@)
415 * This function is no longer documented by MSDN, but in Win95 GDI32 it
416 * is the same as SetBrushOrgEx().
418 BOOL WINAPI
FixBrushOrgEx( HDC hdc
, INT x
, INT y
, LPPOINT oldorg
)
420 return SetBrushOrgEx(hdc
,x
,y
,oldorg
);
424 /***********************************************************************
427 static HGDIOBJ
BRUSH_SelectObject( HGDIOBJ handle
, HDC hdc
)
431 DC
*dc
= get_dc_ptr( hdc
);
435 SetLastError( ERROR_INVALID_HANDLE
);
439 if ((brush
= GDI_GetObjPtr( handle
, OBJ_BRUSH
)))
441 PHYSDEV physdev
= GET_DC_PHYSDEV( dc
, pSelectBrush
);
442 struct brush_pattern
*pattern
= &brush
->pattern
;
444 if (!pattern
->info
) pattern
= NULL
;
446 GDI_inc_ref_count( handle
);
447 GDI_ReleaseObj( handle
);
449 if (!physdev
->funcs
->pSelectBrush( physdev
, handle
, pattern
))
451 GDI_dec_ref_count( handle
);
457 GDI_dec_ref_count( ret
);
460 release_dc_ptr( dc
);
465 /***********************************************************************
468 static BOOL
BRUSH_DeleteObject( HGDIOBJ handle
)
470 BRUSHOBJ
*brush
= free_gdi_handle( handle
);
472 if (!brush
) return FALSE
;
473 free_brush_pattern( &brush
->pattern
);
474 return HeapFree( GetProcessHeap(), 0, brush
);
478 /***********************************************************************
481 static INT
BRUSH_GetObject( HGDIOBJ handle
, INT count
, LPVOID buffer
)
483 BRUSHOBJ
*brush
= GDI_GetObjPtr( handle
, OBJ_BRUSH
);
485 if (!brush
) return 0;
488 if (count
> sizeof(brush
->logbrush
)) count
= sizeof(brush
->logbrush
);
489 memcpy( buffer
, &brush
->logbrush
, count
);
491 else count
= sizeof(brush
->logbrush
);
492 GDI_ReleaseObj( handle
);