1 /*
2 * GDI brush objects
3 *
4 * Copyright 1993, 1994 Alexandre Julliard
5 *
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.
10 *
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.
15 *
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
19 */
20
21 #include "config.h"
22
23 #include <stdarg.h>
24 #include <string.h>
25
26 #include "windef.h"
27 #include "winbase.h"
28 #include "wingdi.h"
29 #include "gdi_private.h"
30 #include "wine/debug.h"
31
32 WINE_DEFAULT_DEBUG_CHANNEL(gdi);
33
34 /* GDI logical brush object */
35 typedef struct
36 {
37 GDIOBJHDR header;
38 LOGBRUSH logbrush;
39 struct brush_pattern pattern;
40 } BRUSHOBJ;
41
42 #define NB_HATCH_STYLES 6
43
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 );
47
48 static const struct gdi_obj_funcs brush_funcs =
49 {
50 BRUSH_SelectObject, /* pSelectObject */
51 BRUSH_GetObject, /* pGetObjectA */
52 BRUSH_GetObject, /* pGetObjectW */
53 NULL, /* pUnrealizeObject */
54 BRUSH_DeleteObject /* pDeleteObject */
55 };
56
57
58 /* fetch the contents of the brush bitmap and cache them in the brush pattern */
59 void cache_pattern_bits( PHYSDEV physdev, struct brush_pattern *pattern )
60 {
61 struct gdi_image_bits bits;
62 struct bitblt_coords src;
63 BITMAPINFO *info;
64 BITMAPOBJ *bmp;
65
66 if (pattern->info) return; /* already cached */
67 if (!(bmp = GDI_GetObjPtr( pattern->bitmap, OBJ_BITMAP ))) return;
68
69 /* we don't need to cache if we are selecting into the same type of DC */
70 if (physdev && bmp->funcs == physdev->funcs) goto done;
71
72 if (!(info = HeapAlloc( GetProcessHeap(), 0, FIELD_OFFSET( BITMAPINFO, bmiColors[256] )))) goto done;
73
74 src.visrect.left = src.x = 0;
75 src.visrect.top = src.y = 0;
76 src.visrect.right = src.width = bmp->dib.dsBm.bmWidth;
77 src.visrect.bottom = src.height = bmp->dib.dsBm.bmHeight;
78 if (bmp->funcs->pGetImage( NULL, pattern->bitmap, info, &bits, &src ))
79 {
80 HeapFree( GetProcessHeap(), 0, info );
81 goto done;
82 }
83
84 /* release the unneeded space */
85 HeapReAlloc( GetProcessHeap(), HEAP_REALLOC_IN_PLACE_ONLY, info,
86 get_dib_info_size( info, DIB_RGB_COLORS ));
87 pattern->info = info;
88 pattern->bits = bits;
89 pattern->usage = DIB_RGB_COLORS;
90
91 done:
92 GDI_ReleaseObj( pattern->bitmap );
93 }
94
95 static BOOL copy_bitmap( struct brush_pattern *brush, HBITMAP bitmap )
96 {
97 BITMAPINFO *info;
98 BITMAPOBJ *bmp = GDI_GetObjPtr( bitmap, OBJ_BITMAP );
99
100 if (!bmp) return FALSE;
101
102 if (!is_bitmapobj_dib( bmp ))
103 {
104 if ((brush->bitmap = CreateBitmap( bmp->dib.dsBm.bmWidth, bmp->dib.dsBm.bmHeight,
105 bmp->dib.dsBm.bmPlanes, bmp->dib.dsBm.bmBitsPixel, NULL )))
106 {
107 if (bmp->funcs->pCopyBitmap( bitmap, brush->bitmap ))
108 {
109 BITMAPOBJ *copy = GDI_GetObjPtr( brush->bitmap, OBJ_BITMAP );
110 copy->funcs = bmp->funcs;
111 GDI_ReleaseObj( copy );
112 }
113 else
114 {
115 DeleteObject( brush->bitmap );
116 brush->bitmap = 0;
117 }
118 }
119 GDI_ReleaseObj( bitmap );
120 return brush->bitmap != 0;
121 }
122
123 info = HeapAlloc( GetProcessHeap(), 0,
124 get_dib_info_size( (BITMAPINFO *)&bmp->dib.dsBmih, DIB_RGB_COLORS ));
125 if (!info) goto done;
126 info->bmiHeader = bmp->dib.dsBmih;
127 if (info->bmiHeader.biCompression == BI_BITFIELDS)
128 memcpy( &info->bmiHeader + 1, bmp->dib.dsBitfields, sizeof(bmp->dib.dsBitfields) );
129 else if (info->bmiHeader.biClrUsed)
130 memcpy( &info->bmiHeader + 1, bmp->color_table, info->bmiHeader.biClrUsed * sizeof(RGBQUAD) );
131 if (!(brush->bits.ptr = HeapAlloc( GetProcessHeap(), 0, info->bmiHeader.biSizeImage )))
132 {
133 HeapFree( GetProcessHeap(), 0, info );
134 goto done;
135 }
136 memcpy( brush->bits.ptr, bmp->dib.dsBm.bmBits, info->bmiHeader.biSizeImage );
137 brush->bits.is_copy = TRUE;
138 brush->bits.free = free_heap_bits;
139 brush->info = info;
140 brush->usage = DIB_RGB_COLORS;
141
142 done:
143 GDI_ReleaseObj( bitmap );
144 return brush->info != NULL;
145 }
146
147 BOOL store_brush_pattern( LOGBRUSH *brush, struct brush_pattern *pattern )
148 {
149 HGLOBAL hmem = 0;
150
151 pattern->bitmap = 0;
152 pattern->info = NULL;
153 pattern->bits.free = NULL;
154
155 switch (brush->lbStyle)
156 {
157 case BS_SOLID:
158 case BS_HOLLOW:
159 return TRUE;
160
161 case BS_HATCHED:
162 if (brush->lbHatch > HS_DIAGCROSS)
163 {
164 if (brush->lbHatch >= HS_API_MAX) return FALSE;
165 brush->lbStyle = BS_SOLID;
166 brush->lbHatch = 0;
167 }
168 return TRUE;
169
170 case BS_PATTERN8X8:
171 brush->lbStyle = BS_PATTERN;
172 /* fall through */
173 case BS_PATTERN:
174 brush->lbColor = 0;
175 return copy_bitmap( pattern, (HBITMAP)brush->lbHatch );
176
177 case BS_DIBPATTERN:
178 hmem = (HGLOBAL)brush->lbHatch;
179 if (!(brush->lbHatch = (ULONG_PTR)GlobalLock( hmem ))) return FALSE;
180 /* fall through */
181 case BS_DIBPATTERNPT:
182 pattern->usage = brush->lbColor;
183 pattern->info = copy_packed_dib( (BITMAPINFO *)brush->lbHatch, pattern->usage );
184 if (hmem) GlobalUnlock( hmem );
185 if (!pattern->info) return FALSE;
186 pattern->bits.ptr = (char *)pattern->info + get_dib_info_size( pattern->info, pattern->usage );
187 brush->lbStyle = BS_DIBPATTERN;
188 brush->lbColor = 0;
189 return TRUE;
190
191 case BS_DIBPATTERN8X8:
192 case BS_MONOPATTERN:
193 case BS_INDEXED:
194 default:
195 WARN( "invalid brush style %u\n", brush->lbStyle );
196 return FALSE;
197 }
198 }
199
200 void free_brush_pattern( struct brush_pattern *pattern )
201 {
202 if (pattern->bits.free) pattern->bits.free( &pattern->bits );
203 if (pattern->bitmap) DeleteObject( pattern->bitmap );
204 HeapFree( GetProcessHeap(), 0, pattern->info );
205 }
206
207 BOOL get_brush_bitmap_info( HBRUSH handle, BITMAPINFO *info, void **bits, UINT *usage )
208 {
209 BRUSHOBJ *brush;
210 BOOL ret = FALSE;
211
212 if (!(brush = GDI_GetObjPtr( handle, OBJ_BRUSH ))) return FALSE;
213
214 if (!brush->pattern.info) cache_pattern_bits( NULL, &brush->pattern );
215
216 if (brush->pattern.info)
217 {
218 memcpy( info, brush->pattern.info, get_dib_info_size( brush->pattern.info, brush->pattern.usage ));
219 if (info->bmiHeader.biBitCount <= 8 && !info->bmiHeader.biClrUsed)
220 fill_default_color_table( info );
221 *bits = brush->pattern.bits.ptr;
222 *usage = brush->pattern.usage;
223 ret = TRUE;
224 }
225 GDI_ReleaseObj( handle );
226 return ret;
227 }
228
229
230 /***********************************************************************
231 * CreateBrushIndirect (GDI32.@)
232 *
233 * Create a logical brush with a given style, color or pattern.
234 *
235 * PARAMS
236 * brush [I] Pointer to a LOGBRUSH structure describing the desired brush.
237 *
238 * RETURNS
239 * A handle to the created brush, or a NULL handle if the brush cannot be
240 * created.
241 *
242 * NOTES
243 * - The brush returned should be freed by the caller using DeleteObject()
244 * when it is no longer required.
245 * - Windows 95 and earlier cannot create brushes from bitmaps or DIBs larger
246 * than 8x8 pixels. If a larger bitmap is given, only a portion of the bitmap
247 * is used.
248 */
249 HBRUSH WINAPI CreateBrushIndirect( const LOGBRUSH * brush )
250 {
251 BRUSHOBJ * ptr;
252 HBRUSH hbrush;
253
254 if (!(ptr = HeapAlloc( GetProcessHeap(), 0, sizeof(*ptr) ))) return 0;
255
256 ptr->logbrush = *brush;
257
258 if (store_brush_pattern( &ptr->logbrush, &ptr->pattern ) &&
259 (hbrush = alloc_gdi_handle( &ptr->header, OBJ_BRUSH, &brush_funcs )))
260 {
261 TRACE("%p\n", hbrush);
262 return hbrush;
263 }
264
265 free_brush_pattern( &ptr->pattern );
266 HeapFree( GetProcessHeap(), 0, ptr );
267 return 0;
268 }
269
270
271 /***********************************************************************
272 * CreateHatchBrush (GDI32.@)
273 *
274 * Create a logical brush with a hatched pattern.
275 *
276 * PARAMS
277 * style [I] Direction of lines for the hatch pattern (HS_* values from "wingdi.h")
278 * color [I] Colour of the hatched pattern
279 *
280 * RETURNS
281 * A handle to the created brush, or a NULL handle if the brush cannot
282 * be created.
283 *
284 * NOTES
285 * - This function uses CreateBrushIndirect() to create the brush.
286 * - The brush returned should be freed by the caller using DeleteObject()
287 * when it is no longer required.
288 */
289 HBRUSH WINAPI CreateHatchBrush( INT style, COLORREF color )
290 {
291 LOGBRUSH logbrush;
292
293 TRACE("%d %06x\n", style, color );
294
295 logbrush.lbStyle = BS_HATCHED;
296 logbrush.lbColor = color;
297 logbrush.lbHatch = style;
298
299 return CreateBrushIndirect( &logbrush );
300 }
301
302
303 /***********************************************************************
304 * CreatePatternBrush (GDI32.@)
305 *
306 * Create a logical brush with a pattern from a bitmap.
307 *
308 * PARAMS
309 * hbitmap [I] Bitmap containing pattern for the brush
310 *
311 * RETURNS
312 * A handle to the created brush, or a NULL handle if the brush cannot
313 * be created.
314 *
315 * NOTES
316 * - This function uses CreateBrushIndirect() to create the brush.
317 * - The brush returned should be freed by the caller using DeleteObject()
318 * when it is no longer required.
319 */
320 HBRUSH WINAPI CreatePatternBrush( HBITMAP hbitmap )
321 {
322 LOGBRUSH logbrush = { BS_PATTERN, 0, 0 };
323 TRACE("%p\n", hbitmap );
324
325 logbrush.lbHatch = (ULONG_PTR)hbitmap;
326 return CreateBrushIndirect( &logbrush );
327 }
328
329
330 /***********************************************************************
331 * CreateDIBPatternBrush (GDI32.@)
332 *
333 * Create a logical brush with a pattern from a DIB.
334 *
335 * PARAMS
336 * hbitmap [I] Global object containing BITMAPINFO structure for the pattern
337 * coloruse [I] Specifies color format, if provided
338 *
339 * RETURNS
340 * A handle to the created brush, or a NULL handle if the brush cannot
341 * be created.
342 *
343 * NOTES
344 * - This function uses CreateBrushIndirect() to create the brush.
345 * - The brush returned should be freed by the caller using DeleteObject()
346 * when it is no longer required.
347 * - This function is for compatibility only. CreateDIBPatternBrushPt() should
348 * be used instead.
349 */
350 HBRUSH WINAPI CreateDIBPatternBrush( HGLOBAL hbitmap, UINT coloruse )
351 {
352 LOGBRUSH logbrush;
353
354 TRACE("%p\n", hbitmap );
355
356 logbrush.lbStyle = BS_DIBPATTERN;
357 logbrush.lbColor = coloruse;
358
359 logbrush.lbHatch = (ULONG_PTR)hbitmap;
360
361 return CreateBrushIndirect( &logbrush );
362 }
363
364
365 /***********************************************************************
366 * CreateDIBPatternBrushPt (GDI32.@)
367 *
368 * Create a logical brush with a pattern from a DIB.
369 *
370 * PARAMS
371 * data [I] Pointer to a BITMAPINFO structure and image data for the pattern
372 * coloruse [I] Specifies color format, if provided
373 *
374 * RETURNS
375 * A handle to the created brush, or a NULL handle if the brush cannot
376 * be created.
377 *
378 * NOTES
379 * - This function uses CreateBrushIndirect() to create the brush.
380 * - The brush returned should be freed by the caller using DeleteObject()
381 * when it is no longer required.
382 */
383 HBRUSH WINAPI CreateDIBPatternBrushPt( const void* data, UINT coloruse )
384 {
385 const BITMAPINFO *info=data;
386 LOGBRUSH logbrush;
387
388 if (!data)
389 return NULL;
390
391 TRACE("%p %dx%d %dbpp\n", info, info->bmiHeader.biWidth,
392 info->bmiHeader.biHeight, info->bmiHeader.biBitCount);
393
394 logbrush.lbStyle = BS_DIBPATTERNPT;
395 logbrush.lbColor = coloruse;
396 logbrush.lbHatch = (ULONG_PTR)data;
397
398 return CreateBrushIndirect( &logbrush );
399 }
400
401
402 /***********************************************************************
403 * CreateSolidBrush (GDI32.@)
404 *
405 * Create a logical brush consisting of a single colour.
406 *
407 * PARAMS
408 * color [I] Colour to make the solid brush
409 *
410 * RETURNS
411 * A handle to the newly created brush, or a NULL handle if the brush cannot
412 * be created.
413 *
414 * NOTES
415 * - This function uses CreateBrushIndirect() to create the brush.
416 * - The brush returned should be freed by the caller using DeleteObject()
417 * when it is no longer required.
418 */
419 HBRUSH WINAPI CreateSolidBrush( COLORREF color )
420 {
421 LOGBRUSH logbrush;
422
423 TRACE("%06x\n", color );
424
425 logbrush.lbStyle = BS_SOLID;
426 logbrush.lbColor = color;
427 logbrush.lbHatch = 0;
428
429 return CreateBrushIndirect( &logbrush );
430 }
431
432
433 /***********************************************************************
434 * SetBrushOrgEx (GDI32.@)
435 *
436 * Set the brush origin for a device context.
437 *
438 * PARAMS
439 * hdc [I] Device context to set the brush origin for
440 * x [I] New x origin
441 * y [I] New y origin
442 * oldorg [O] If non NULL, destination for previously set brush origin.
443 *
444 * RETURNS
445 * Success: TRUE. The origin is set to (x,y), and oldorg is updated if given.
446 */
447 BOOL WINAPI SetBrushOrgEx( HDC hdc, INT x, INT y, LPPOINT oldorg )
448 {
449 DC *dc = get_dc_ptr( hdc );
450
451 if (!dc) return FALSE;
452 if (oldorg)
453 {
454 oldorg->x = dc->brushOrgX;
455 oldorg->y = dc->brushOrgY;
456 }
457 dc->brushOrgX = x;
458 dc->brushOrgY = y;
459 release_dc_ptr( dc );
460 return TRUE;
461 }
462
463 /***********************************************************************
464 * FixBrushOrgEx (GDI32.@)
465 *
466 * See SetBrushOrgEx.
467 *
468 * NOTES
469 * This function is no longer documented by MSDN, but in Win95 GDI32 it
470 * is the same as SetBrushOrgEx().
471 */
472 BOOL WINAPI FixBrushOrgEx( HDC hdc, INT x, INT y, LPPOINT oldorg )
473 {
474 return SetBrushOrgEx(hdc,x,y,oldorg);
475 }
476
477
478 /***********************************************************************
479 * BRUSH_SelectObject
480 */
481 static HGDIOBJ BRUSH_SelectObject( HGDIOBJ handle, HDC hdc )
482 {
483 BRUSHOBJ *brush;
484 HGDIOBJ ret = 0;
485 DC *dc = get_dc_ptr( hdc );
486
487 if (!dc)
488 {
489 SetLastError( ERROR_INVALID_HANDLE );
490 return 0;
491 }
492
493 if ((brush = GDI_GetObjPtr( handle, OBJ_BRUSH )))
494 {
495 PHYSDEV physdev = GET_DC_PHYSDEV( dc, pSelectBrush );
496 struct brush_pattern *pattern = &brush->pattern;
497
498 if (!pattern->info)
499 {
500 if (pattern->bitmap) cache_pattern_bits( physdev, pattern );
501 else pattern = NULL;
502 }
503
504 GDI_inc_ref_count( handle );
505 GDI_ReleaseObj( handle );
506
507 if (!physdev->funcs->pSelectBrush( physdev, handle, pattern ))
508 {
509 GDI_dec_ref_count( handle );
510 }
511 else
512 {
513 ret = dc->hBrush;
514 dc->hBrush = handle;
515 GDI_dec_ref_count( ret );
516 }
517 }
518 release_dc_ptr( dc );
519 return ret;
520 }
521
522
523 /***********************************************************************
524 * BRUSH_DeleteObject
525 */
526 static BOOL BRUSH_DeleteObject( HGDIOBJ handle )
527 {
528 BRUSHOBJ *brush = free_gdi_handle( handle );
529
530 if (!brush) return FALSE;
531 free_brush_pattern( &brush->pattern );
532 return HeapFree( GetProcessHeap(), 0, brush );
533 }
534
535
536 /***********************************************************************
537 * BRUSH_GetObject
538 */
539 static INT BRUSH_GetObject( HGDIOBJ handle, INT count, LPVOID buffer )
540 {
541 BRUSHOBJ *brush = GDI_GetObjPtr( handle, OBJ_BRUSH );
542
543 if (!brush) return 0;
544 if (buffer)
545 {
546 if (count > sizeof(brush->logbrush)) count = sizeof(brush->logbrush);
547 memcpy( buffer, &brush->logbrush, count );
548 }
549 else count = sizeof(brush->logbrush);
550 GDI_ReleaseObj( handle );
551 return count;
552 }
553
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.