7f324f33bd335504cd026783566957072f84d5a8
[reactos.git] / reactos / dll / win32 / gdiplus / brush.c
1 /*
2 * Copyright (C) 2007 Google (Evan Stade)
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17 */
18
19 #include <stdarg.h>
20
21 #include "windef.h"
22 #include "winbase.h"
23 #include "winuser.h"
24 #include "wingdi.h"
25
26 #define COBJMACROS
27 #include "objbase.h"
28 #include "olectl.h"
29 #include "ole2.h"
30
31 #include "gdiplus.h"
32 #include "gdiplus_private.h"
33 #include "wine/debug.h"
34
35 WINE_DEFAULT_DEBUG_CHANNEL(gdiplus);
36
37 GpStatus WINGDIPAPI GdipCloneBrush(GpBrush *brush, GpBrush **clone)
38 {
39 if(!brush || !clone)
40 return InvalidParameter;
41
42 switch(brush->bt){
43 case BrushTypeSolidColor:
44 *clone = GdipAlloc(sizeof(GpSolidFill));
45 if (!*clone) return OutOfMemory;
46
47 memcpy(*clone, brush, sizeof(GpSolidFill));
48
49 (*clone)->gdibrush = CreateBrushIndirect(&(*clone)->lb);
50 break;
51 case BrushTypePathGradient:{
52 GpPathGradient *src, *dest;
53 INT count;
54
55 *clone = GdipAlloc(sizeof(GpPathGradient));
56 if (!*clone) return OutOfMemory;
57
58 src = (GpPathGradient*) brush,
59 dest = (GpPathGradient*) *clone;
60 count = src->pathdata.Count;
61
62 memcpy(dest, src, sizeof(GpPathGradient));
63
64 dest->pathdata.Count = count;
65 dest->pathdata.Points = GdipAlloc(count * sizeof(PointF));
66 dest->pathdata.Types = GdipAlloc(count);
67
68 if(!dest->pathdata.Points || !dest->pathdata.Types){
69 GdipFree(dest->pathdata.Points);
70 GdipFree(dest->pathdata.Types);
71 GdipFree(dest);
72 return OutOfMemory;
73 }
74
75 memcpy(dest->pathdata.Points, src->pathdata.Points, count * sizeof(PointF));
76 memcpy(dest->pathdata.Types, src->pathdata.Types, count);
77
78 break;
79 }
80 case BrushTypeLinearGradient:
81 *clone = GdipAlloc(sizeof(GpLineGradient));
82 if(!*clone) return OutOfMemory;
83
84 memcpy(*clone, brush, sizeof(GpLineGradient));
85
86 (*clone)->gdibrush = CreateSolidBrush((*clone)->lb.lbColor);
87 break;
88 case BrushTypeTextureFill:
89 *clone = GdipAlloc(sizeof(GpTexture));
90 if(!*clone) return OutOfMemory;
91
92 memcpy(*clone, brush, sizeof(GpTexture));
93
94 (*clone)->gdibrush = CreateBrushIndirect(&(*clone)->lb);
95 break;
96 default:
97 ERR("not implemented for brush type %d\n", brush->bt);
98 return NotImplemented;
99 }
100
101 return Ok;
102 }
103
104 GpStatus WINGDIPAPI GdipCreateLineBrush(GDIPCONST GpPointF* startpoint,
105 GDIPCONST GpPointF* endpoint, ARGB startcolor, ARGB endcolor,
106 GpWrapMode wrap, GpLineGradient **line)
107 {
108 COLORREF col = ARGB2COLORREF(startcolor);
109
110 if(!line || !startpoint || !endpoint || wrap == WrapModeClamp)
111 return InvalidParameter;
112
113 *line = GdipAlloc(sizeof(GpLineGradient));
114 if(!*line) return OutOfMemory;
115
116 (*line)->brush.lb.lbStyle = BS_SOLID;
117 (*line)->brush.lb.lbColor = col;
118 (*line)->brush.lb.lbHatch = 0;
119 (*line)->brush.gdibrush = CreateSolidBrush(col);
120 (*line)->brush.bt = BrushTypeLinearGradient;
121
122 (*line)->startpoint.X = startpoint->X;
123 (*line)->startpoint.Y = startpoint->Y;
124 (*line)->endpoint.X = endpoint->X;
125 (*line)->endpoint.Y = endpoint->Y;
126 (*line)->startcolor = startcolor;
127 (*line)->endcolor = endcolor;
128 (*line)->wrap = wrap;
129 (*line)->gamma = FALSE;
130
131 return Ok;
132 }
133
134 GpStatus WINGDIPAPI GdipCreateLineBrushFromRectI(GDIPCONST GpRect* rect,
135 ARGB startcolor, ARGB endcolor, LinearGradientMode mode, GpWrapMode wrap,
136 GpLineGradient **line)
137 {
138 GpPointF start, end;
139
140 if(!line || !rect)
141 return InvalidParameter;
142
143 start.X = (REAL) rect->X;
144 start.Y = (REAL) rect->Y;
145 end.X = (REAL) (rect->X + rect->Width);
146 end.Y = (REAL) (rect->Y + rect->Height);
147
148 return GdipCreateLineBrush(&start, &end, startcolor, endcolor, wrap, line);
149 }
150
151 GpStatus WINGDIPAPI GdipCreatePathGradient(GDIPCONST GpPointF* points,
152 INT count, GpWrapMode wrap, GpPathGradient **grad)
153 {
154 COLORREF col = ARGB2COLORREF(0xffffffff);
155
156 if(!points || !grad)
157 return InvalidParameter;
158
159 if(count <= 0)
160 return OutOfMemory;
161
162 *grad = GdipAlloc(sizeof(GpPathGradient));
163 if (!*grad) return OutOfMemory;
164
165 (*grad)->pathdata.Count = count;
166 (*grad)->pathdata.Points = GdipAlloc(count * sizeof(PointF));
167 (*grad)->pathdata.Types = GdipAlloc(count);
168
169 if(!(*grad)->pathdata.Points || !(*grad)->pathdata.Types){
170 GdipFree((*grad)->pathdata.Points);
171 GdipFree((*grad)->pathdata.Types);
172 GdipFree(*grad);
173 return OutOfMemory;
174 }
175
176 memcpy((*grad)->pathdata.Points, points, count * sizeof(PointF));
177 memset((*grad)->pathdata.Types, PathPointTypeLine, count);
178
179 (*grad)->brush.lb.lbStyle = BS_SOLID;
180 (*grad)->brush.lb.lbColor = col;
181 (*grad)->brush.lb.lbHatch = 0;
182
183 (*grad)->brush.gdibrush = CreateSolidBrush(col);
184 (*grad)->brush.bt = BrushTypePathGradient;
185 (*grad)->centercolor = 0xffffffff;
186 (*grad)->wrap = wrap;
187 (*grad)->gamma = FALSE;
188 (*grad)->center.X = 0.0;
189 (*grad)->center.Y = 0.0;
190 (*grad)->focus.X = 0.0;
191 (*grad)->focus.Y = 0.0;
192
193 return Ok;
194 }
195
196 /* FIXME: path gradient brushes not truly supported (drawn as solid brushes) */
197 GpStatus WINGDIPAPI GdipCreatePathGradientFromPath(GDIPCONST GpPath* path,
198 GpPathGradient **grad)
199 {
200 COLORREF col = ARGB2COLORREF(0xffffffff);
201
202 if(!path || !grad)
203 return InvalidParameter;
204
205 *grad = GdipAlloc(sizeof(GpPathGradient));
206 if (!*grad) return OutOfMemory;
207
208 (*grad)->pathdata.Count = path->pathdata.Count;
209 (*grad)->pathdata.Points = GdipAlloc(path->pathdata.Count * sizeof(PointF));
210 (*grad)->pathdata.Types = GdipAlloc(path->pathdata.Count);
211
212 if(!(*grad)->pathdata.Points || !(*grad)->pathdata.Types){
213 GdipFree((*grad)->pathdata.Points);
214 GdipFree((*grad)->pathdata.Types);
215 GdipFree(*grad);
216 return OutOfMemory;
217 }
218
219 memcpy((*grad)->pathdata.Points, path->pathdata.Points,
220 path->pathdata.Count * sizeof(PointF));
221 memcpy((*grad)->pathdata.Types, path->pathdata.Types, path->pathdata.Count);
222
223 (*grad)->brush.lb.lbStyle = BS_SOLID;
224 (*grad)->brush.lb.lbColor = col;
225 (*grad)->brush.lb.lbHatch = 0;
226
227 (*grad)->brush.gdibrush = CreateSolidBrush(col);
228 (*grad)->brush.bt = BrushTypePathGradient;
229 (*grad)->centercolor = 0xffffffff;
230 (*grad)->wrap = WrapModeClamp;
231 (*grad)->gamma = FALSE;
232 /* FIXME: this should be set to the "centroid" of the path by default */
233 (*grad)->center.X = 0.0;
234 (*grad)->center.Y = 0.0;
235 (*grad)->focus.X = 0.0;
236 (*grad)->focus.Y = 0.0;
237
238 return Ok;
239 }
240
241 GpStatus WINGDIPAPI GdipCreateSolidFill(ARGB color, GpSolidFill **sf)
242 {
243 COLORREF col = ARGB2COLORREF(color);
244
245 if(!sf) return InvalidParameter;
246
247 *sf = GdipAlloc(sizeof(GpSolidFill));
248 if (!*sf) return OutOfMemory;
249
250 (*sf)->brush.lb.lbStyle = BS_SOLID;
251 (*sf)->brush.lb.lbColor = col;
252 (*sf)->brush.lb.lbHatch = 0;
253
254 (*sf)->brush.gdibrush = CreateSolidBrush(col);
255 (*sf)->brush.bt = BrushTypeSolidColor;
256 (*sf)->color = color;
257
258 return Ok;
259 }
260
261 /* FIXME: imageattr ignored */
262 GpStatus WINGDIPAPI GdipCreateTextureIA(GpImage *image,
263 GDIPCONST GpImageAttributes *imageattr, REAL x, REAL y, REAL width,
264 REAL height, GpTexture **texture)
265 {
266 HDC hdc;
267 OLE_HANDLE hbm;
268 HBITMAP old = NULL;
269 BITMAPINFO bmi;
270 BITMAPINFOHEADER *bmih;
271 INT n_x, n_y, n_width, n_height, abs_height, stride, image_stride, i, bytespp;
272 BOOL bm_is_selected;
273 BYTE *dibits, *buff, *textbits;
274
275 if(!image || !texture || x < 0.0 || y < 0.0 || width < 0.0 || height < 0.0)
276 return InvalidParameter;
277
278 if(image->type != ImageTypeBitmap){
279 FIXME("not implemented for image type %d\n", image->type);
280 return NotImplemented;
281 }
282
283 n_x = roundr(x);
284 n_y = roundr(y);
285 n_width = roundr(width);
286 n_height = roundr(height);
287
288 if(n_x + n_width > ((GpBitmap*)image)->width ||
289 n_y + n_height > ((GpBitmap*)image)->height)
290 return InvalidParameter;
291
292 IPicture_get_Handle(image->picture, &hbm);
293 if(!hbm) return GenericError;
294 IPicture_get_CurDC(image->picture, &hdc);
295 bm_is_selected = (hdc != 0);
296
297 bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
298 bmi.bmiHeader.biBitCount = 0;
299
300 if(!bm_is_selected){
301 hdc = CreateCompatibleDC(0);
302 old = SelectObject(hdc, (HBITMAP)hbm);
303 }
304
305 /* fill out bmi */
306 GetDIBits(hdc, (HBITMAP)hbm, 0, 0, NULL, &bmi, DIB_RGB_COLORS);
307
308 bytespp = bmi.bmiHeader.biBitCount / 8;
309 abs_height = abs(bmi.bmiHeader.biHeight);
310
311 if(n_x > bmi.bmiHeader.biWidth || n_x + n_width > bmi.bmiHeader.biWidth ||
312 n_y > abs_height || n_y + n_height > abs_height)
313 return InvalidParameter;
314
315 dibits = GdipAlloc(bmi.bmiHeader.biSizeImage);
316
317 if(dibits) /* this is not a good place to error out */
318 GetDIBits(hdc, (HBITMAP)hbm, 0, abs_height, dibits, &bmi, DIB_RGB_COLORS);
319
320 if(!bm_is_selected){
321 SelectObject(hdc, old);
322 DeleteDC(hdc);
323 }
324
325 if(!dibits)
326 return OutOfMemory;
327
328 image_stride = (bmi.bmiHeader.biWidth * bytespp + 3) & ~3;
329 stride = (n_width * bytespp + 3) & ~3;
330 buff = GdipAlloc(sizeof(BITMAPINFOHEADER) + stride * n_height);
331 if(!buff){
332 GdipFree(dibits);
333 return OutOfMemory;
334 }
335
336 bmih = (BITMAPINFOHEADER*)buff;
337 textbits = (BYTE*) (bmih + 1);
338 bmih->biSize = sizeof(BITMAPINFOHEADER);
339 bmih->biWidth = n_width;
340 bmih->biHeight = n_height;
341 bmih->biCompression = BI_RGB;
342 bmih->biSizeImage = stride * n_height;
343 bmih->biBitCount = bmi.bmiHeader.biBitCount;
344 bmih->biClrUsed = 0;
345 bmih->biPlanes = 1;
346
347 /* image is flipped */
348 if(bmi.bmiHeader.biHeight > 0){
349 dibits += bmi.bmiHeader.biSizeImage;
350 image_stride *= -1;
351 textbits += stride * (n_height - 1);
352 stride *= -1;
353 }
354
355 for(i = 0; i < n_height; i++)
356 memcpy(&textbits[i * stride],
357 &dibits[n_x * bytespp + (n_y + i) * image_stride],
358 abs(stride));
359
360 *texture = GdipAlloc(sizeof(GpTexture));
361 if (!*texture) return OutOfMemory;
362
363 (*texture)->brush.lb.lbStyle = BS_DIBPATTERNPT;
364 (*texture)->brush.lb.lbColor = DIB_RGB_COLORS;
365 (*texture)->brush.lb.lbHatch = (ULONG_PTR)buff;
366
367 (*texture)->brush.gdibrush = CreateBrushIndirect(&(*texture)->brush.lb);
368 (*texture)->brush.bt = BrushTypeTextureFill;
369
370 GdipFree(dibits);
371 GdipFree(buff);
372
373 return Ok;
374 }
375
376 GpStatus WINGDIPAPI GdipGetBrushType(GpBrush *brush, GpBrushType *type)
377 {
378 if(!brush || !type) return InvalidParameter;
379
380 *type = brush->bt;
381
382 return Ok;
383 }
384
385 GpStatus WINGDIPAPI GdipDeleteBrush(GpBrush *brush)
386 {
387 if(!brush) return InvalidParameter;
388
389 switch(brush->bt)
390 {
391 case BrushTypePathGradient:
392 GdipFree(((GpPathGradient*) brush)->pathdata.Points);
393 GdipFree(((GpPathGradient*) brush)->pathdata.Types);
394 break;
395 case BrushTypeSolidColor:
396 case BrushTypeLinearGradient:
397 case BrushTypeTextureFill:
398 default:
399 break;
400 }
401
402 DeleteObject(brush->gdibrush);
403 GdipFree(brush);
404
405 return Ok;
406 }
407
408 GpStatus WINGDIPAPI GdipGetLineGammaCorrection(GpLineGradient *line,
409 BOOL *usinggamma)
410 {
411 if(!line)
412 return InvalidParameter;
413
414 *usinggamma = line->gamma;
415
416 return Ok;
417 }
418
419 GpStatus WINGDIPAPI GdipGetPathGradientCenterPoint(GpPathGradient *grad,
420 GpPointF *point)
421 {
422 if(!grad || !point)
423 return InvalidParameter;
424
425 point->X = grad->center.X;
426 point->Y = grad->center.Y;
427
428 return Ok;
429 }
430
431 GpStatus WINGDIPAPI GdipGetPathGradientFocusScales(GpPathGradient *grad,
432 REAL *x, REAL *y)
433 {
434 if(!grad || !x || !y)
435 return InvalidParameter;
436
437 *x = grad->focus.X;
438 *y = grad->focus.Y;
439
440 return Ok;
441 }
442
443 GpStatus WINGDIPAPI GdipGetPathGradientGammaCorrection(GpPathGradient *grad,
444 BOOL *gamma)
445 {
446 if(!grad || !gamma)
447 return InvalidParameter;
448
449 *gamma = grad->gamma;
450
451 return Ok;
452 }
453
454 GpStatus WINGDIPAPI GdipGetPathGradientPointCount(GpPathGradient *grad,
455 INT *count)
456 {
457 if(!grad || !count)
458 return InvalidParameter;
459
460 *count = grad->pathdata.Count;
461
462 return Ok;
463 }
464
465 GpStatus WINGDIPAPI GdipGetPathGradientSurroundColorsWithCount(GpPathGradient
466 *grad, ARGB *argb, INT *count)
467 {
468 static int calls;
469
470 if(!grad || !argb || !count || (*count < grad->pathdata.Count))
471 return InvalidParameter;
472
473 if(!(calls++))
474 FIXME("not implemented\n");
475
476 return NotImplemented;
477 }
478
479 GpStatus WINGDIPAPI GdipGetSolidFillColor(GpSolidFill *sf, ARGB *argb)
480 {
481 if(!sf || !argb)
482 return InvalidParameter;
483
484 *argb = sf->color;
485
486 return Ok;
487 }
488
489 GpStatus WINGDIPAPI GdipSetLineBlend(GpLineGradient *brush,
490 GDIPCONST REAL *blend, GDIPCONST REAL* positions, INT count)
491 {
492 static int calls;
493
494 if(!brush || !blend || !positions || count <= 0)
495 return InvalidParameter;
496
497 if(!(calls++))
498 FIXME("not implemented\n");
499
500 return Ok;
501 }
502
503 GpStatus WINGDIPAPI GdipSetLineGammaCorrection(GpLineGradient *line,
504 BOOL usegamma)
505 {
506 if(!line)
507 return InvalidParameter;
508
509 line->gamma = usegamma;
510
511 return Ok;
512 }
513
514 GpStatus WINGDIPAPI GdipSetLineSigmaBlend(GpLineGradient *line, REAL focus,
515 REAL scale)
516 {
517 static int calls;
518
519 if(!line || focus < 0.0 || focus > 1.0 || scale < 0.0 || scale > 1.0)
520 return InvalidParameter;
521
522 if(!(calls++))
523 FIXME("not implemented\n");
524
525 return NotImplemented;
526 }
527
528 GpStatus WINGDIPAPI GdipSetLineWrapMode(GpLineGradient *line,
529 GpWrapMode wrap)
530 {
531 if(!line || wrap == WrapModeClamp)
532 return InvalidParameter;
533
534 line->wrap = wrap;
535
536 return Ok;
537 }
538
539 GpStatus WINGDIPAPI GdipSetPathGradientCenterColor(GpPathGradient *grad,
540 ARGB argb)
541 {
542 if(!grad)
543 return InvalidParameter;
544
545 grad->centercolor = argb;
546 grad->brush.lb.lbColor = ARGB2COLORREF(argb);
547
548 DeleteObject(grad->brush.gdibrush);
549 grad->brush.gdibrush = CreateSolidBrush(grad->brush.lb.lbColor);
550
551 return Ok;
552 }
553
554 GpStatus WINGDIPAPI GdipSetPathGradientCenterPoint(GpPathGradient *grad,
555 GpPointF *point)
556 {
557 if(!grad || !point)
558 return InvalidParameter;
559
560 grad->center.X = point->X;
561 grad->center.Y = point->Y;
562
563 return Ok;
564 }
565
566 GpStatus WINGDIPAPI GdipSetPathGradientFocusScales(GpPathGradient *grad,
567 REAL x, REAL y)
568 {
569 if(!grad)
570 return InvalidParameter;
571
572 grad->focus.X = x;
573 grad->focus.Y = y;
574
575 return Ok;
576 }
577
578 GpStatus WINGDIPAPI GdipSetPathGradientGammaCorrection(GpPathGradient *grad,
579 BOOL gamma)
580 {
581 if(!grad)
582 return InvalidParameter;
583
584 grad->gamma = gamma;
585
586 return Ok;
587 }
588
589 GpStatus WINGDIPAPI GdipSetPathGradientSigmaBlend(GpPathGradient *grad,
590 REAL focus, REAL scale)
591 {
592 static int calls;
593
594 if(!grad || focus < 0.0 || focus > 1.0 || scale < 0.0 || scale > 1.0)
595 return InvalidParameter;
596
597 if(!(calls++))
598 FIXME("not implemented\n");
599
600 return NotImplemented;
601 }
602
603 GpStatus WINGDIPAPI GdipSetPathGradientSurroundColorsWithCount(GpPathGradient
604 *grad, ARGB *argb, INT *count)
605 {
606 static int calls;
607
608 if(!grad || !argb || !count || (*count <= 0) ||
609 (*count > grad->pathdata.Count))
610 return InvalidParameter;
611
612 if(!(calls++))
613 FIXME("not implemented\n");
614
615 return NotImplemented;
616 }
617
618 GpStatus WINGDIPAPI GdipSetPathGradientWrapMode(GpPathGradient *grad,
619 GpWrapMode wrap)
620 {
621 if(!grad)
622 return InvalidParameter;
623
624 grad->wrap = wrap;
625
626 return Ok;
627 }
628
629 GpStatus WINGDIPAPI GdipSetSolidFillColor(GpSolidFill *sf, ARGB argb)
630 {
631 if(!sf)
632 return InvalidParameter;
633
634 sf->color = argb;
635 sf->brush.lb.lbColor = ARGB2COLORREF(argb);
636
637 DeleteObject(sf->brush.gdibrush);
638 sf->brush.gdibrush = CreateSolidBrush(sf->brush.lb.lbColor);
639
640 return Ok;
641 }
642
643 GpStatus WINGDIPAPI GdipSetTextureTransform(GpTexture *texture,
644 GDIPCONST GpMatrix *matrix)
645 {
646 static int calls;
647
648 if(!texture || !matrix)
649 return InvalidParameter;
650
651 if(!(calls++))
652 FIXME("not implemented\n");
653
654 return Ok;
655 }
656
657 GpStatus WINGDIPAPI GdipSetLineColors(GpLineGradient *brush, ARGB color1,
658 ARGB color2)
659 {
660 static int calls;
661
662 if(!(calls++))
663 FIXME("not implemented\n");
664
665 return NotImplemented;
666 }
667
668 GpStatus WINGDIPAPI GdipSetLineLinearBlend(GpLineGradient *brush, REAL focus,
669 REAL scale)
670 {
671 static int calls;
672
673 if(!(calls++))
674 FIXME("not implemented\n");
675
676 return NotImplemented;
677 }
678
679 GpStatus WINGDIPAPI GdipSetLinePresetBlend(GpLineGradient *brush,
680 GDIPCONST ARGB *blend, GDIPCONST REAL* positions, INT count)
681 {
682 static int calls;
683
684 if(!(calls++))
685 FIXME("not implemented\n");
686
687 return NotImplemented;
688 }
689
690 GpStatus WINGDIPAPI GdipSetLineTransform(GpLineGradient *brush,
691 GDIPCONST GpMatrix *matrix)
692 {
693 static int calls;
694
695 if(!(calls++))
696 FIXME("not implemented\n");
697
698 return NotImplemented;
699 }