[LIBTIFF]
[reactos.git] / reactos / win32ss / gdi / ntgdi / brush.cpp
1 /*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS win32 subsystem
4 * PURPOSE: BRUSH class implementation
5 * PROGRAMER: Timo Kreuzer (timo.kreuzer@reactos.org)
6 *
7 * REFERENCES: http://support.microsoft.com/kb/kbview/108497
8 */
9
10 #include "brush.hpp"
11
12 DBG_DEFAULT_CHANNEL(GdiBrush);
13
14 BRUSH::BRUSH(
15 _In_ FLONG flAttrs,
16 _In_ COLORREF crColor,
17 _In_ ULONG iHatch,
18 _In_opt_ HBITMAP hbmPattern,
19 _In_opt_ PVOID pvClient,
20 _In_ GDILOOBJTYPE loobjtype = GDILoObjType_LO_BRUSH_TYPE)
21 : BASEOBJECT(loobjtype)
22 {
23 static ULONG ulGlobalBrushUnique = 0;
24
25 /* Get a unique value */
26 this->ulBrushUnique = InterlockedIncrementUL(&ulGlobalBrushUnique);
27
28 /* Start with kmode brush attribute */
29 this->pBrushAttr = &this->BrushAttr;
30
31 /* Set parameters */
32 this->flAttrs = flAttrs;
33 this->iHatch = iHatch;
34 this->hbmPattern = hbmPattern;
35 this->hbmClient = (HBITMAP)pvClient;
36 this->pBrushAttr->lbColor = crColor;
37
38 /* Initialize the other fields */
39 this->ptOrigin.x = 0;
40 this->ptOrigin.y = 0;
41 this->bCacheGrabbed = FALSE;
42 this->crBack = 0;
43 this->crFore = 0;
44 this->ulPalTime = 0;
45 this->ulSurfTime = 0;
46 this->pvRBrush = NULL;
47 this->hdev = NULL;
48
49 /* FIXME: should be done only in PEN constructor,
50 but our destructor needs it! */
51 this->dwStyleCount = 0;
52 this->pStyle = NULL;
53 }
54
55 BRUSH::~BRUSH(
56 VOID)
57 {
58 /* Check if we have a user mode brush attribute */
59 if (this->pBrushAttr != &this->BrushAttr)
60 {
61 /* Free memory to the process GDI pool */
62 GdiPoolFree(GetBrushAttrPool(), this->pBrushAttr);
63 }
64
65 /* Delete the pattern bitmap */
66 if (this->hbmPattern != NULL)
67 {
68 GreSetBitmapOwner(this->hbmPattern, BASEOBJECT::OWNER::POWNED);
69 GreDeleteObject(this->hbmPattern);
70 }
71
72 /* Delete styles */
73 if ((this->pStyle != NULL) && !(this->flAttrs & BR_IS_DEFAULTSTYLE))
74 {
75 ExFreePoolWithTag(this->pStyle, GDITAG_PENSTYLE);
76 }
77 }
78
79 VOID
80 BRUSH::vDeleteObject(
81 _In_ PVOID pvObject)
82 {
83 PBRUSH pbr = static_cast<PBRUSH>(pvObject);
84 NT_ASSERT((GDI_HANDLE_GET_TYPE(pbr->hHmgr()) == GDILoObjType_LO_BRUSH_TYPE) ||
85 (GDI_HANDLE_GET_TYPE(pbr->hHmgr()) == GDILoObjType_LO_PEN_TYPE) ||
86 (GDI_HANDLE_GET_TYPE(pbr->hHmgr()) == GDILoObjType_LO_EXTPEN_TYPE));
87 delete pbr;
88 }
89
90 BOOL
91 BRUSH::bAllocateBrushAttr(
92 VOID)
93 {
94 PBRUSH_ATTR pBrushAttr;
95 NT_ASSERT(this->pBrushAttr == &this->BrushAttr);
96
97 /* Allocate a brush attribute from the pool */
98 pBrushAttr = static_cast<PBRUSH_ATTR>(GdiPoolAllocate(GetBrushAttrPool()));
99 if (pBrushAttr == NULL)
100 {
101 ERR("Could not allocate brush attr\n");
102 return FALSE;
103 }
104
105 /* Copy the content from the kernel mode brush attribute */
106 this->pBrushAttr = pBrushAttr;
107 *this->pBrushAttr = this->BrushAttr;
108
109 /* Set the object attribute in the handle table */
110 vSetObjectAttr(pBrushAttr);
111
112 return TRUE;
113 }
114
115 VOID
116 BRUSH::vSetSolidColor(
117 _In_ COLORREF crColor)
118 {
119 NT_ASSERT(this->flAttrs & BR_IS_SOLID);
120
121 /* Set new color and reset the pal times */
122 this->pBrushAttr->lbColor = crColor & 0xFFFFFF;
123 this->ulPalTime = -1;
124 this->ulSurfTime = -1;
125 }
126
127 HBITMAP
128 BRUSH::hbmGetBitmapHandle(
129 _Out_ PUINT puUsage) const
130 {
131 /* Return the color usage based on flags */
132 *puUsage = (this->flAttrs & BR_IS_DIBPALCOLORS) ? DIB_PAL_COLORS :
133 (this->flAttrs & BR_IS_DIBPALINDICES) ? DIB_PAL_INDICES :
134 DIB_RGB_COLORS;
135
136 return this->hbmPattern;
137 }
138
139 UINT
140 BRUSH::cjGetObject(
141 _In_ UINT cjSize,
142 _Out_bytecap_(cjSize) PLOGBRUSH plb) const
143 {
144 /* Check if only size is requested */
145 if (plb == NULL)
146 return sizeof(LOGBRUSH);
147
148 /* Check if size is ok */
149 if (cjSize == 0)
150 return 0;
151
152 /* Set color */
153 plb->lbColor = this->BrushAttr.lbColor;
154
155 /* Set style and hatch based on the attribute flags */
156 if (this->flAttrs & BR_IS_SOLID)
157 {
158 plb->lbStyle = BS_SOLID;
159 plb->lbHatch = 0;
160 }
161 else if (this->flAttrs & BR_IS_HATCH)
162 {
163 plb->lbStyle = BS_HATCHED;
164 plb->lbHatch = this->iHatch;
165 }
166 else if (this->flAttrs & BR_IS_DIB)
167 {
168 plb->lbStyle = BS_DIBPATTERN;
169 plb->lbHatch = (ULONG_PTR)this->hbmClient;
170 }
171 else if (this->flAttrs & BR_IS_BITMAP)
172 {
173 plb->lbStyle = BS_PATTERN;
174 plb->lbHatch = (ULONG_PTR)this->hbmClient;
175 }
176 else if (this->flAttrs & BR_IS_NULL)
177 {
178 plb->lbStyle = BS_NULL;
179 plb->lbHatch = 0;
180 }
181 else
182 {
183 NT_ASSERT(FALSE);
184 }
185
186 return sizeof(LOGBRUSH);
187 }
188
189 static
190 HBRUSH
191 CreateBrushInternal(
192 _In_ ULONG flAttrs,
193 _In_ COLORREF crColor,
194 _In_ ULONG iHatch,
195 _In_opt_ HBITMAP hbmPattern,
196 _In_opt_ PVOID pvClient)
197 {
198 BASEOBJECT::OWNER owner;
199 PBRUSH pbr;
200 HBRUSH hbr;
201
202 NT_ASSERT(((flAttrs & BR_IS_BITMAP) == 0) || (hbmPattern != NULL));
203
204 /* Create the brush (brush takes ownership of the bitmap) */
205 pbr = new BRUSH(flAttrs, crColor, iHatch, hbmPattern, pvClient);
206 if (pbr == NULL)
207 {
208 ERR("Failed to allocate a brush\n");
209 GreSetBitmapOwner(hbmPattern, BASEOBJECT::OWNER::POWNED);
210 GreDeleteObject(hbmPattern);
211 return NULL;
212 }
213
214 /* Check if this is a global brush */
215 if (!(flAttrs & BR_IS_GLOBAL))
216 {
217 /* Not a global brush, so allocate a user mode brush attribute */
218 if (!pbr->bAllocateBrushAttr())
219 {
220 ERR("Failed to allocate brush attribute\n");
221 delete pbr;
222 return NULL;
223 }
224 }
225
226 /* Set the owner, either public or process owned */
227 owner = (flAttrs & BR_IS_GLOBAL) ? BASEOBJECT::OWNER::PUBLIC :
228 BASEOBJECT::OWNER::POWNED;
229
230 /* Insert the object into the GDI handle table */
231 hbr = static_cast<HBRUSH>(pbr->hInsertObject(owner));
232 if (hbr == NULL)
233 {
234 ERR("Failed to insert brush\n");
235 delete pbr;
236 return NULL;
237 }
238
239 /* Unlock the brush */
240 pbr->vUnlock();
241
242 return hbr;
243 }
244
245
246 /* C interface ***************************************************************/
247
248 extern "C" {
249
250 VOID
251 NTAPI
252 BRUSH_vDeleteObject(
253 PVOID pvObject)
254 {
255 BRUSH::vDeleteObject(pvObject);
256 }
257
258 INT
259 FASTCALL
260 BRUSH_GetObject(
261 PBRUSH pbr,
262 INT cjBuffer,
263 LPLOGBRUSH plbBuffer)
264 {
265 return pbr->cjGetObject(cjBuffer, plbBuffer);
266 }
267
268 HBRUSH
269 NTAPI
270 IntGdiCreateNullBrush(
271 VOID)
272 {
273 /* Call the internal function */
274 return CreateBrushInternal(BR_IS_NULL | BR_IS_GLOBAL, 0, 0, NULL, NULL);
275 }
276
277 HBRUSH
278 APIENTRY
279 IntGdiCreateSolidBrush(
280 COLORREF crColor)
281 {
282 /* Call the internal function */
283 return CreateBrushInternal(BR_IS_SOLID | BR_IS_GLOBAL,
284 crColor,
285 0,
286 NULL,
287 NULL);
288 }
289
290 HBRUSH
291 NTAPI
292 IntGdiCreatePatternBrush(
293 HBITMAP hbmPattern)
294 {
295 NT_ASSERT(hbmPattern != NULL);
296 GreSetBitmapOwner(hbmPattern, BASEOBJECT::OWNER::PUBLIC);
297 return CreateBrushInternal(BR_IS_BITMAP | BR_IS_GLOBAL,
298 0,
299 0,
300 hbmPattern,
301 NULL);
302 }
303
304 VOID
305 NTAPI
306 IntGdiSetSolidBrushColor(
307 _In_ HBRUSH hbr,
308 _In_ COLORREF crColor)
309 {
310 PBRUSH pbr;
311
312 /* Lock the brush */
313 pbr = BRUSH::LockAny(hbr);
314 if (pbr == NULL)
315 {
316 ERR("Failed to lock brush %p\n", hbr);
317 return;
318 }
319
320 /* Call the member function */
321 pbr->vSetSolidColor(crColor);
322
323 /* Unlock the brush */
324 pbr->vUnlock();
325 }
326
327 __kernel_entry
328 HBRUSH
329 APIENTRY
330 NtGdiCreateSolidBrush(
331 _In_ COLORREF crColor,
332 _In_opt_ HBRUSH hbr)
333 {
334 if (hbr != NULL)
335 {
336 WARN("hbr is not supported, ignoring\n");
337 }
338
339 /* Call the internal function */
340 return CreateBrushInternal(BR_IS_SOLID, crColor, 0, NULL, NULL);
341 }
342
343 __kernel_entry
344 HBRUSH
345 APIENTRY
346 NtGdiCreateHatchBrushInternal(
347 _In_ ULONG iHatch,
348 _In_ COLORREF crColor,
349 _In_ BOOL bPen)
350 {
351 FLONG flAttr;
352
353 if (bPen)
354 {
355 WARN("bPen is not supported, ignoring\n");
356 }
357
358 /* Check what kind if hatch style this is */
359 if (iHatch < HS_DDI_MAX)
360 {
361 flAttr = BR_IS_HATCH;
362 }
363 else if (iHatch < HS_API_MAX)
364 {
365 flAttr = BR_IS_SOLID;
366 }
367 else
368 {
369 ERR("Invalid iHatch: %lu\n", iHatch);
370 return NULL;
371 }
372
373 /* Call the internal function */
374 return CreateBrushInternal(flAttr, crColor, iHatch, NULL, NULL);
375 }
376
377 __kernel_entry
378 HBRUSH
379 APIENTRY
380 NtGdiCreatePatternBrushInternal(
381 _In_ HBITMAP hbmClient,
382 _In_ BOOL bPen,
383 _In_ BOOL b8X8)
384 {
385 HBITMAP hbmPattern;
386
387 if (b8X8)
388 {
389 WARN("b8X8 is not supported, ignoring\n");
390 }
391
392 if (bPen)
393 {
394 WARN("bPen is not supported, ignoring\n");
395 }
396
397 /* Copy the bitmap */
398 hbmPattern = BITMAP_CopyBitmap(hbmClient);
399 if (hbmPattern == NULL)
400 {
401 ERR("Failed to copy the bitmap %p\n", hbmPattern);
402 return NULL;
403 }
404
405 /* Call the internal function (will delete hbmPattern on failure) */
406 return CreateBrushInternal(BR_IS_BITMAP, 0, 0, hbmPattern, hbmClient);
407 }
408
409 __kernel_entry
410 HBRUSH
411 APIENTRY
412 NtGdiCreateDIBBrush(
413 _In_reads_bytes_(cj) PVOID pv,
414 _In_ FLONG uUsage,
415 _In_ UINT cj,
416 _In_ BOOL b8X8,
417 _In_ BOOL bPen,
418 _In_ PVOID pvClient)
419 {
420 PVOID pvPackedDIB;
421 FLONG flAttrs;
422 HBITMAP hbm;
423 HBRUSH hbr = NULL;
424
425 if (b8X8)
426 {
427 WARN("b8X8 is not supported, ignoring\n");
428 }
429
430 if (bPen)
431 {
432 WARN("bPen is not supported, ignoring\n");
433 }
434
435 if (uUsage > DIB_PAL_INDICES)
436 {
437 ERR("Invalid uUsage value: %lu\n", uUsage);
438 EngSetLastError(ERROR_INVALID_PARAMETER);
439 return NULL;
440 }
441
442 /* Allocate a buffer for the packed DIB */
443 pvPackedDIB = ExAllocatePoolWithTag(PagedPool, cj, GDITAG_TEMP);
444 if (pvPackedDIB == NULL)
445 {
446 ERR("Failed to allocate temp buffer of %u bytes\n", cj);
447 return NULL;
448 }
449
450 /* Probe and copy the packed DIB */
451 _SEH2_TRY
452 {
453 ProbeForRead(pv, cj, 1);
454 RtlCopyMemory(pvPackedDIB, pv, cj);
455 }
456 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
457 {
458 ERR("Got exception, pv = %p, cj = %lu\n", pv, cj);
459 goto cleanup;
460 }
461 _SEH2_END;
462
463 flAttrs = BR_IS_BITMAP | BR_IS_DIB;
464
465 /* Check what kind of color table we have */
466 if (uUsage == DIB_PAL_COLORS)
467 {
468 /* Remember it and use DIB_PAL_BRUSHHACK to create a "special" palette */
469 flAttrs |= BR_IS_DIBPALCOLORS;
470 uUsage = DIB_PAL_BRUSHHACK;
471 }
472 else if (uUsage == DIB_PAL_INDICES)
473 {
474 /* No color table, bitmap contains device palette indices */
475 flAttrs |= BR_IS_DIBPALINDICES;
476
477 /* FIXME: This makes tests pass, but needs investigation. */
478 flAttrs |= BR_IS_NULL;
479 }
480
481 /* Create a bitmap from the DIB */
482 hbm = GreCreateDIBitmapFromPackedDIB(pvPackedDIB, cj, uUsage);
483 if (hbm == NULL)
484 {
485 ERR("Failed to create bitmap from DIB\n");
486 goto cleanup;
487 }
488
489 /* Call the internal function (will delete hbm on failure) */
490 hbr = CreateBrushInternal(flAttrs, 0, 0, hbm, pvClient);
491
492 cleanup:
493
494 ExFreePoolWithTag(pvPackedDIB, GDITAG_TEMP);
495
496 return hbr;
497 }
498
499 __kernel_entry
500 HBITMAP
501 APIENTRY
502 NtGdiGetObjectBitmapHandle(
503 _In_ HBRUSH hbr,
504 _Out_ UINT *piUsage)
505 {
506 PBRUSH pbr;
507 HBITMAP hbm;
508 UINT uUsage;
509
510 /* Lock the brush */
511 pbr = BRUSH::LockForRead(hbr);
512 if (pbr == NULL)
513 {
514 ERR("Failed to lock brush %p\n", hbr);
515 return NULL;
516 }
517
518 /* Call the member function */
519 hbm = pbr->hbmGetBitmapHandle(&uUsage);
520
521 /* Unlock the brush */
522 pbr->vUnlock();
523
524 _SEH2_TRY
525 {
526 ProbeForWrite(piUsage, sizeof(*piUsage), 1);
527 *piUsage = uUsage;
528 }
529 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
530 {
531 ERR("Got exception! piUsage = %p\n", piUsage);
532 hbm = NULL;
533 }
534 _SEH2_END;
535
536 return hbm;
537 }
538
539 __kernel_entry
540 HBRUSH
541 APIENTRY
542 NtGdiSetBrushAttributes(
543 _In_ HBRUSH hbr,
544 _In_ DWORD dwFlags)
545 {
546 __debugbreak();
547 return NULL;
548 }
549
550 __kernel_entry
551 HBRUSH
552 APIENTRY
553 NtGdiClearBrushAttributes(
554 _In_ HBRUSH hbr,
555 _In_ DWORD dwFlags)
556 {
557 __debugbreak();
558 return NULL;
559 }
560
561 } /* extern "C" */