iccvid: New Spanish translations.
[wine] / dlls / 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 /******************************************************************************
38  * GdipCloneBrush [GDIPLUS.@]
39  */
40 GpStatus WINGDIPAPI GdipCloneBrush(GpBrush *brush, GpBrush **clone)
41 {
42     TRACE("(%p, %p)\n", brush, clone);
43
44     if(!brush || !clone)
45         return InvalidParameter;
46
47     switch(brush->bt){
48         case BrushTypeSolidColor:
49         {
50             GpSolidFill *fill;
51             *clone = GdipAlloc(sizeof(GpSolidFill));
52             if (!*clone) return OutOfMemory;
53
54             fill = (GpSolidFill*)*clone;
55
56             memcpy(*clone, brush, sizeof(GpSolidFill));
57
58             (*clone)->gdibrush = CreateBrushIndirect(&(*clone)->lb);
59             fill->bmp = ARGB2BMP(fill->color);
60             break;
61         }
62         case BrushTypeHatchFill:
63         {
64             GpHatch *hatch = (GpHatch*)brush;
65
66             return GdipCreateHatchBrush(hatch->hatchstyle, hatch->forecol, hatch->backcol, (GpHatch**)clone);
67         }
68         case BrushTypePathGradient:{
69             GpPathGradient *src, *dest;
70             INT count;
71
72             *clone = GdipAlloc(sizeof(GpPathGradient));
73             if (!*clone) return OutOfMemory;
74
75             src = (GpPathGradient*) brush,
76             dest = (GpPathGradient*) *clone;
77             count = src->pathdata.Count;
78
79             memcpy(dest, src, sizeof(GpPathGradient));
80
81             dest->pathdata.Count = count;
82             dest->pathdata.Points = GdipAlloc(count * sizeof(PointF));
83             dest->pathdata.Types = GdipAlloc(count);
84
85             if(!dest->pathdata.Points || !dest->pathdata.Types){
86                 GdipFree(dest->pathdata.Points);
87                 GdipFree(dest->pathdata.Types);
88                 GdipFree(dest);
89                 return OutOfMemory;
90             }
91
92             memcpy(dest->pathdata.Points, src->pathdata.Points, count * sizeof(PointF));
93             memcpy(dest->pathdata.Types, src->pathdata.Types, count);
94
95             /* blending */
96             count = src->blendcount;
97             dest->blendcount = count;
98             dest->blendfac = GdipAlloc(count * sizeof(REAL));
99             dest->blendpos = GdipAlloc(count * sizeof(REAL));
100
101             if(!dest->blendfac || !dest->blendpos){
102                 GdipFree(dest->pathdata.Points);
103                 GdipFree(dest->pathdata.Types);
104                 GdipFree(dest->blendfac);
105                 GdipFree(dest->blendpos);
106                 GdipFree(dest);
107                 return OutOfMemory;
108             }
109
110             memcpy(dest->blendfac, src->blendfac, count * sizeof(REAL));
111             memcpy(dest->blendpos, src->blendpos, count * sizeof(REAL));
112
113             break;
114         }
115         case BrushTypeLinearGradient:{
116             GpLineGradient *dest, *src;
117             INT count, pcount;
118
119             dest = GdipAlloc(sizeof(GpLineGradient));
120             if(!dest)    return OutOfMemory;
121
122             src = (GpLineGradient*)brush;
123
124             memcpy(dest, src, sizeof(GpLineGradient));
125
126             dest->brush.gdibrush = CreateSolidBrush(dest->brush.lb.lbColor);
127
128             count = dest->blendcount;
129             dest->blendfac = GdipAlloc(count * sizeof(REAL));
130             dest->blendpos = GdipAlloc(count * sizeof(REAL));
131             pcount = dest->pblendcount;
132             if (pcount)
133             {
134                 dest->pblendcolor = GdipAlloc(pcount * sizeof(ARGB));
135                 dest->pblendpos = GdipAlloc(pcount * sizeof(REAL));
136             }
137
138             if (!dest->blendfac || !dest->blendpos ||
139                 (pcount && (!dest->pblendcolor || !dest->pblendpos)))
140             {
141                 GdipFree(dest->blendfac);
142                 GdipFree(dest->blendpos);
143                 GdipFree(dest->pblendcolor);
144                 GdipFree(dest->pblendpos);
145                 DeleteObject(dest->brush.gdibrush);
146                 GdipFree(dest);
147                 return OutOfMemory;
148             }
149
150             memcpy(dest->blendfac, src->blendfac, count * sizeof(REAL));
151             memcpy(dest->blendpos, src->blendpos, count * sizeof(REAL));
152
153             if (pcount)
154             {
155                 memcpy(dest->pblendcolor, src->pblendcolor, pcount * sizeof(ARGB));
156                 memcpy(dest->pblendpos, src->pblendpos, pcount * sizeof(REAL));
157             }
158
159             *clone = &dest->brush;
160             break;
161         }
162         case BrushTypeTextureFill:
163         {
164             GpStatus stat;
165             GpTexture *texture = (GpTexture*)brush;
166             GpTexture *new_texture;
167
168             stat = GdipCreateTexture(texture->image, texture->wrap, &new_texture);
169
170             if (stat == Ok)
171             {
172                 memcpy(new_texture->transform, texture->transform, sizeof(GpMatrix));
173                 *clone = (GpBrush*)new_texture;
174             }
175             else
176                 *clone = NULL;
177
178             return stat;
179         }
180         default:
181             ERR("not implemented for brush type %d\n", brush->bt);
182             return NotImplemented;
183     }
184
185     TRACE("<-- %p\n", *clone);
186     return Ok;
187 }
188
189 static const char HatchBrushes[][8] = {
190     { 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00 }, /* HatchStyleHorizontal */
191     { 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08 }, /* HatchStyleVertical */
192     { 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80 }, /* HatchStyleForwardDiagonal */
193     { 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01 }, /* HatchStyleBackwardDiagonal */
194     { 0x08, 0x08, 0x08, 0xff, 0x08, 0x08, 0x08, 0x08 }, /* HatchStyleCross */
195     { 0x81, 0x42, 0x24, 0x18, 0x18, 0x24, 0x42, 0x81 }, /* HatchStyleDiagonalCross */
196     { 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x80 }, /* HatchStyle05Percent */
197     { 0x00, 0x02, 0x00, 0x88, 0x00, 0x20, 0x00, 0x88 }, /* HatchStyle10Percent */
198     { 0x00, 0x22, 0x00, 0xcc, 0x00, 0x22, 0x00, 0xcc }, /* HatchStyle20Percent */
199     { 0x00, 0xcc, 0x00, 0xcc, 0x00, 0xcc, 0x00, 0xcc }, /* HatchStyle25Percent */
200     { 0x00, 0xcc, 0x04, 0xcc, 0x00, 0xcc, 0x40, 0xcc }, /* HatchStyle30Percent */
201     { 0x44, 0xcc, 0x22, 0xcc, 0x44, 0xcc, 0x22, 0xcc }, /* HatchStyle40Percent */
202     { 0x55, 0xcc, 0x55, 0xcc, 0x55, 0xcc, 0x55, 0xcc }, /* HatchStyle50Percent */
203     { 0x55, 0xcd, 0x55, 0xee, 0x55, 0xdc, 0x55, 0xee }, /* HatchStyle60Percent */
204     { 0x55, 0xdd, 0x55, 0xff, 0x55, 0xdd, 0x55, 0xff }, /* HatchStyle70Percent */
205     { 0x55, 0xff, 0x55, 0xff, 0x55, 0xff, 0x55, 0xff }, /* HatchStyle75Percent */
206     { 0x55, 0xff, 0x59, 0xff, 0x55, 0xff, 0x99, 0xff }, /* HatchStyle80Percent */
207     { 0x77, 0xff, 0xdd, 0xff, 0x77, 0xff, 0xfd, 0xff }, /* HatchStyle90Percent */
208     { 0x11, 0x22, 0x44, 0x88, 0x11, 0x22, 0x44, 0x88 }, /* HatchStyleLightDownwardDiagonal */
209     { 0x88, 0x44, 0x22, 0x11, 0x88, 0x44, 0x22, 0x11 }, /* HatchStyleLightUpwardDiagonal */
210     { 0x99, 0x33, 0x66, 0xcc, 0x99, 0x33, 0x66, 0xcc }, /* HatchStyleDarkDownwardDiagonal */
211     { 0xcc, 0x66, 0x33, 0x99, 0xcc, 0x66, 0x33, 0x99 }, /* HatchStyleDarkUpwardDiagonal */
212     { 0xc1, 0x83, 0x07, 0x0e, 0x1c, 0x38, 0x70, 0xe0 }, /* HatchStyleWideDownwardDiagonal */
213     { 0xe0, 0x70, 0x38, 0x1c, 0x0e, 0x07, 0x83, 0xc1 }, /* HatchStyleWideUpwardDiagonal */
214     { 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88 }, /* HatchStyleLightVertical */
215     { 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff }, /* HatchStyleLightHorizontal */
216     { 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa }, /* HatchStyleNarrowVertical */
217     { 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff }, /* HatchStyleNarrowHorizontal */
218     { 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc }, /* HatchStyleDarkVertical */
219     { 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff }, /* HatchStyleDarkHorizontal */
220 };
221
222 /******************************************************************************
223  * GdipCreateHatchBrush [GDIPLUS.@]
224  */
225 GpStatus WINGDIPAPI GdipCreateHatchBrush(HatchStyle hatchstyle, ARGB forecol, ARGB backcol, GpHatch **brush)
226 {
227     COLORREF fgcol = ARGB2COLORREF(forecol);
228     GpStatus stat = Ok;
229
230     TRACE("(%d, %d, %d, %p)\n", hatchstyle, forecol, backcol, brush);
231
232     if(!brush)  return InvalidParameter;
233
234     *brush = GdipAlloc(sizeof(GpHatch));
235     if (!*brush) return OutOfMemory;
236
237     if (hatchstyle < sizeof(HatchBrushes) / sizeof(HatchBrushes[0]))
238     {
239         HBITMAP hbmp;
240         HDC hdc;
241         BITMAPINFOHEADER bmih;
242         DWORD* bits;
243         int x, y;
244
245         hdc = CreateCompatibleDC(0);
246
247         if (hdc)
248         {
249             bmih.biSize = sizeof(bmih);
250             bmih.biWidth = 8;
251             bmih.biHeight = 8;
252             bmih.biPlanes = 1;
253             bmih.biBitCount = 32;
254             bmih.biCompression = BI_RGB;
255             bmih.biSizeImage = 0;
256
257             hbmp = CreateDIBSection(hdc, (BITMAPINFO*)&bmih, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
258
259             if (hbmp)
260             {
261                 for (y=0; y<8; y++)
262                     for (x=0; x<8; x++)
263                         if ((HatchBrushes[hatchstyle][y] & (0x80 >> x)) != 0)
264                             bits[y*8+x] = forecol;
265                         else
266                             bits[y*8+x] = backcol;
267             }
268             else
269                 stat = GenericError;
270
271             DeleteDC(hdc);
272         }
273         else
274             stat = GenericError;
275
276         if (stat == Ok)
277         {
278             (*brush)->brush.lb.lbStyle = BS_PATTERN;
279             (*brush)->brush.lb.lbColor = 0;
280             (*brush)->brush.lb.lbHatch = (ULONG_PTR)hbmp;
281             (*brush)->brush.gdibrush = CreateBrushIndirect(&(*brush)->brush.lb);
282
283             DeleteObject(hbmp);
284         }
285     }
286     else
287     {
288         FIXME("Unimplemented hatch style %d\n", hatchstyle);
289
290         (*brush)->brush.lb.lbStyle = BS_SOLID;
291         (*brush)->brush.lb.lbColor = fgcol;
292         (*brush)->brush.lb.lbHatch = 0;
293         (*brush)->brush.gdibrush = CreateBrushIndirect(&(*brush)->brush.lb);
294     }
295
296     if (stat == Ok)
297     {
298         (*brush)->brush.bt = BrushTypeHatchFill;
299         (*brush)->forecol = forecol;
300         (*brush)->backcol = backcol;
301         (*brush)->hatchstyle = hatchstyle;
302         TRACE("<-- %p\n", *brush);
303     }
304     else
305     {
306         GdipFree(*brush);
307         *brush = NULL;
308     }
309
310     return stat;
311 }
312
313 /******************************************************************************
314  * GdipCreateLineBrush [GDIPLUS.@]
315  */
316 GpStatus WINGDIPAPI GdipCreateLineBrush(GDIPCONST GpPointF* startpoint,
317     GDIPCONST GpPointF* endpoint, ARGB startcolor, ARGB endcolor,
318     GpWrapMode wrap, GpLineGradient **line)
319 {
320     COLORREF col = ARGB2COLORREF(startcolor);
321
322     TRACE("(%s, %s, %x, %x, %d, %p)\n", debugstr_pointf(startpoint),
323           debugstr_pointf(endpoint), startcolor, endcolor, wrap, line);
324
325     if(!line || !startpoint || !endpoint || wrap == WrapModeClamp)
326         return InvalidParameter;
327
328     *line = GdipAlloc(sizeof(GpLineGradient));
329     if(!*line)  return OutOfMemory;
330
331     (*line)->brush.lb.lbStyle = BS_SOLID;
332     (*line)->brush.lb.lbColor = col;
333     (*line)->brush.lb.lbHatch = 0;
334     (*line)->brush.gdibrush = CreateSolidBrush(col);
335     (*line)->brush.bt = BrushTypeLinearGradient;
336
337     (*line)->startpoint.X = startpoint->X;
338     (*line)->startpoint.Y = startpoint->Y;
339     (*line)->endpoint.X = endpoint->X;
340     (*line)->endpoint.Y = endpoint->Y;
341     (*line)->startcolor = startcolor;
342     (*line)->endcolor = endcolor;
343     (*line)->wrap = wrap;
344     (*line)->gamma = FALSE;
345
346     (*line)->rect.X = (startpoint->X < endpoint->X ? startpoint->X: endpoint->X);
347     (*line)->rect.Y = (startpoint->Y < endpoint->Y ? startpoint->Y: endpoint->Y);
348     (*line)->rect.Width  = fabs(startpoint->X - endpoint->X);
349     (*line)->rect.Height = fabs(startpoint->Y - endpoint->Y);
350
351     if ((*line)->rect.Width == 0)
352     {
353         (*line)->rect.X -= (*line)->rect.Height / 2.0f;
354         (*line)->rect.Width = (*line)->rect.Height;
355     }
356     else if ((*line)->rect.Height == 0)
357     {
358         (*line)->rect.Y -= (*line)->rect.Width / 2.0f;
359         (*line)->rect.Height = (*line)->rect.Width;
360     }
361
362     (*line)->blendcount = 1;
363     (*line)->blendfac = GdipAlloc(sizeof(REAL));
364     (*line)->blendpos = GdipAlloc(sizeof(REAL));
365
366     if (!(*line)->blendfac || !(*line)->blendpos)
367     {
368         GdipFree((*line)->blendfac);
369         GdipFree((*line)->blendpos);
370         DeleteObject((*line)->brush.gdibrush);
371         GdipFree(*line);
372         *line = NULL;
373         return OutOfMemory;
374     }
375
376     (*line)->blendfac[0] = 1.0f;
377     (*line)->blendpos[0] = 1.0f;
378
379     (*line)->pblendcolor = NULL;
380     (*line)->pblendpos = NULL;
381     (*line)->pblendcount = 0;
382
383     TRACE("<-- %p\n", *line);
384
385     return Ok;
386 }
387
388 GpStatus WINGDIPAPI GdipCreateLineBrushI(GDIPCONST GpPoint* startpoint,
389     GDIPCONST GpPoint* endpoint, ARGB startcolor, ARGB endcolor,
390     GpWrapMode wrap, GpLineGradient **line)
391 {
392     GpPointF stF;
393     GpPointF endF;
394
395     TRACE("(%p, %p, %x, %x, %d, %p)\n", startpoint, endpoint,
396           startcolor, endcolor, wrap, line);
397
398     if(!startpoint || !endpoint)
399         return InvalidParameter;
400
401     stF.X  = (REAL)startpoint->X;
402     stF.Y  = (REAL)startpoint->Y;
403     endF.X = (REAL)endpoint->X;
404     endF.X = (REAL)endpoint->Y;
405
406     return GdipCreateLineBrush(&stF, &endF, startcolor, endcolor, wrap, line);
407 }
408
409 GpStatus WINGDIPAPI GdipCreateLineBrushFromRect(GDIPCONST GpRectF* rect,
410     ARGB startcolor, ARGB endcolor, LinearGradientMode mode, GpWrapMode wrap,
411     GpLineGradient **line)
412 {
413     GpPointF start, end;
414     GpStatus stat;
415
416     TRACE("(%p, %x, %x, %d, %d, %p)\n", rect, startcolor, endcolor, mode,
417           wrap, line);
418
419     if(!line || !rect)
420         return InvalidParameter;
421
422     switch (mode)
423     {
424     case LinearGradientModeHorizontal:
425         start.X = rect->X;
426         start.Y = rect->Y;
427         end.X = rect->X + rect->Width;
428         end.Y = rect->Y;
429         break;
430     case LinearGradientModeVertical:
431         start.X = rect->X;
432         start.Y = rect->Y;
433         end.X = rect->X;
434         end.Y = rect->Y + rect->Height;
435         break;
436     case LinearGradientModeForwardDiagonal:
437         start.X = rect->X;
438         start.Y = rect->Y;
439         end.X = rect->X + rect->Width;
440         end.Y = rect->Y + rect->Height;
441         break;
442     case LinearGradientModeBackwardDiagonal:
443         start.X = rect->X + rect->Width;
444         start.Y = rect->Y;
445         end.X = rect->X;
446         end.Y = rect->Y + rect->Height;
447         break;
448     default:
449         return InvalidParameter;
450     }
451
452     stat = GdipCreateLineBrush(&start, &end, startcolor, endcolor, wrap, line);
453
454     if (stat == Ok)
455         (*line)->rect = *rect;
456
457     return stat;
458 }
459
460 GpStatus WINGDIPAPI GdipCreateLineBrushFromRectI(GDIPCONST GpRect* rect,
461     ARGB startcolor, ARGB endcolor, LinearGradientMode mode, GpWrapMode wrap,
462     GpLineGradient **line)
463 {
464     GpRectF rectF;
465
466     TRACE("(%p, %x, %x, %d, %d, %p)\n", rect, startcolor, endcolor, mode,
467           wrap, line);
468
469     rectF.X      = (REAL) rect->X;
470     rectF.Y      = (REAL) rect->Y;
471     rectF.Width  = (REAL) rect->Width;
472     rectF.Height = (REAL) rect->Height;
473
474     return GdipCreateLineBrushFromRect(&rectF, startcolor, endcolor, mode, wrap, line);
475 }
476
477 /******************************************************************************
478  * GdipCreateLineBrushFromRectWithAngle [GDIPLUS.@]
479  */
480 GpStatus WINGDIPAPI GdipCreateLineBrushFromRectWithAngle(GDIPCONST GpRectF* rect,
481     ARGB startcolor, ARGB endcolor, REAL angle, BOOL isAngleScalable, GpWrapMode wrap,
482     GpLineGradient **line)
483 {
484     GpStatus stat;
485     LinearGradientMode mode;
486     REAL width, height, exofs, eyofs;
487     REAL sin_angle, cos_angle, sin_cos_angle;
488
489     TRACE("(%p, %x, %x, %.2f, %d, %d, %p)\n", rect, startcolor, endcolor, angle, isAngleScalable,
490           wrap, line);
491
492     sin_angle = sinf(deg2rad(angle));
493     cos_angle = cosf(deg2rad(angle));
494     sin_cos_angle = sin_angle * cos_angle;
495
496     if (isAngleScalable)
497     {
498         width = height = 1.0;
499     }
500     else
501     {
502         width = rect->Width;
503         height = rect->Height;
504     }
505
506     if (sin_cos_angle >= 0)
507         mode = LinearGradientModeForwardDiagonal;
508     else
509         mode = LinearGradientModeBackwardDiagonal;
510
511     stat = GdipCreateLineBrushFromRect(rect, startcolor, endcolor, mode, wrap, line);
512
513     if (stat == Ok)
514     {
515         if (sin_cos_angle >= 0)
516         {
517             exofs = width * sin_cos_angle + height * cos_angle * cos_angle;
518             eyofs = width * sin_angle * sin_angle + height * sin_cos_angle;
519         }
520         else
521         {
522             exofs = width * sin_angle * sin_angle + height * sin_cos_angle;
523             eyofs = -width * sin_cos_angle + height * sin_angle * sin_angle;
524         }
525
526         if (isAngleScalable)
527         {
528             exofs = exofs * rect->Width;
529             eyofs = eyofs * rect->Height;
530         }
531
532         if (sin_angle >= 0)
533         {
534             (*line)->endpoint.X = rect->X + exofs;
535             (*line)->endpoint.Y = rect->Y + eyofs;
536         }
537         else
538         {
539             (*line)->endpoint.X = (*line)->startpoint.X;
540             (*line)->endpoint.Y = (*line)->startpoint.Y;
541             (*line)->startpoint.X = rect->X + exofs;
542             (*line)->startpoint.Y = rect->Y + eyofs;
543         }
544     }
545
546     return stat;
547 }
548
549 GpStatus WINGDIPAPI GdipCreateLineBrushFromRectWithAngleI(GDIPCONST GpRect* rect,
550     ARGB startcolor, ARGB endcolor, REAL angle, BOOL isAngleScalable, GpWrapMode wrap,
551     GpLineGradient **line)
552 {
553     TRACE("(%p, %x, %x, %.2f, %d, %d, %p)\n", rect, startcolor, endcolor, angle, isAngleScalable,
554           wrap, line);
555
556     return GdipCreateLineBrushFromRectI(rect, startcolor, endcolor, LinearGradientModeForwardDiagonal,
557                                         wrap, line);
558 }
559
560 GpStatus WINGDIPAPI GdipCreatePathGradient(GDIPCONST GpPointF* points,
561     INT count, GpWrapMode wrap, GpPathGradient **grad)
562 {
563     COLORREF col = ARGB2COLORREF(0xffffffff);
564
565     TRACE("(%p, %d, %d, %p)\n", points, count, wrap, grad);
566
567     if(!points || !grad)
568         return InvalidParameter;
569
570     if(count <= 0)
571         return OutOfMemory;
572
573     *grad = GdipAlloc(sizeof(GpPathGradient));
574     if (!*grad) return OutOfMemory;
575
576     (*grad)->blendfac = GdipAlloc(sizeof(REAL));
577     if(!(*grad)->blendfac){
578         GdipFree(*grad);
579         return OutOfMemory;
580     }
581     (*grad)->blendfac[0] = 1.0;
582     (*grad)->blendpos    = NULL;
583     (*grad)->blendcount  = 1;
584
585     (*grad)->pathdata.Count = count;
586     (*grad)->pathdata.Points = GdipAlloc(count * sizeof(PointF));
587     (*grad)->pathdata.Types = GdipAlloc(count);
588
589     if(!(*grad)->pathdata.Points || !(*grad)->pathdata.Types){
590         GdipFree((*grad)->pathdata.Points);
591         GdipFree((*grad)->pathdata.Types);
592         GdipFree(*grad);
593         return OutOfMemory;
594     }
595
596     memcpy((*grad)->pathdata.Points, points, count * sizeof(PointF));
597     memset((*grad)->pathdata.Types, PathPointTypeLine, count);
598
599     (*grad)->brush.lb.lbStyle = BS_SOLID;
600     (*grad)->brush.lb.lbColor = col;
601     (*grad)->brush.lb.lbHatch = 0;
602
603     (*grad)->brush.gdibrush = CreateSolidBrush(col);
604     (*grad)->brush.bt = BrushTypePathGradient;
605     (*grad)->centercolor = 0xffffffff;
606     (*grad)->wrap = wrap;
607     (*grad)->gamma = FALSE;
608     (*grad)->center.X = 0.0;
609     (*grad)->center.Y = 0.0;
610     (*grad)->focus.X = 0.0;
611     (*grad)->focus.Y = 0.0;
612
613     TRACE("<-- %p\n", *grad);
614
615     return Ok;
616 }
617
618 GpStatus WINGDIPAPI GdipCreatePathGradientI(GDIPCONST GpPoint* points,
619     INT count, GpWrapMode wrap, GpPathGradient **grad)
620 {
621     GpPointF *pointsF;
622     GpStatus ret;
623     INT i;
624
625     TRACE("(%p, %d, %d, %p)\n", points, count, wrap, grad);
626
627     if(!points || !grad)
628         return InvalidParameter;
629
630     if(count <= 0)
631         return OutOfMemory;
632
633     pointsF = GdipAlloc(sizeof(GpPointF) * count);
634     if(!pointsF)
635         return OutOfMemory;
636
637     for(i = 0; i < count; i++){
638         pointsF[i].X = (REAL)points[i].X;
639         pointsF[i].Y = (REAL)points[i].Y;
640     }
641
642     ret = GdipCreatePathGradient(pointsF, count, wrap, grad);
643     GdipFree(pointsF);
644
645     return ret;
646 }
647
648 /******************************************************************************
649  * GdipCreatePathGradientFromPath [GDIPLUS.@]
650  *
651  * FIXME: path gradient brushes not truly supported (drawn as solid brushes)
652  */
653 GpStatus WINGDIPAPI GdipCreatePathGradientFromPath(GDIPCONST GpPath* path,
654     GpPathGradient **grad)
655 {
656     COLORREF col = ARGB2COLORREF(0xffffffff);
657
658     TRACE("(%p, %p)\n", path, grad);
659
660     if(!path || !grad)
661         return InvalidParameter;
662
663     *grad = GdipAlloc(sizeof(GpPathGradient));
664     if (!*grad) return OutOfMemory;
665
666     (*grad)->blendfac = GdipAlloc(sizeof(REAL));
667     if(!(*grad)->blendfac){
668         GdipFree(*grad);
669         return OutOfMemory;
670     }
671     (*grad)->blendfac[0] = 1.0;
672     (*grad)->blendpos    = NULL;
673     (*grad)->blendcount  = 1;
674
675     (*grad)->pathdata.Count = path->pathdata.Count;
676     (*grad)->pathdata.Points = GdipAlloc(path->pathdata.Count * sizeof(PointF));
677     (*grad)->pathdata.Types = GdipAlloc(path->pathdata.Count);
678
679     if(!(*grad)->pathdata.Points || !(*grad)->pathdata.Types){
680         GdipFree((*grad)->pathdata.Points);
681         GdipFree((*grad)->pathdata.Types);
682         GdipFree(*grad);
683         return OutOfMemory;
684     }
685
686     memcpy((*grad)->pathdata.Points, path->pathdata.Points,
687            path->pathdata.Count * sizeof(PointF));
688     memcpy((*grad)->pathdata.Types, path->pathdata.Types, path->pathdata.Count);
689
690     (*grad)->brush.lb.lbStyle = BS_SOLID;
691     (*grad)->brush.lb.lbColor = col;
692     (*grad)->brush.lb.lbHatch = 0;
693
694     (*grad)->brush.gdibrush = CreateSolidBrush(col);
695     (*grad)->brush.bt = BrushTypePathGradient;
696     (*grad)->centercolor = 0xffffffff;
697     (*grad)->wrap = WrapModeClamp;
698     (*grad)->gamma = FALSE;
699     /* FIXME: this should be set to the "centroid" of the path by default */
700     (*grad)->center.X = 0.0;
701     (*grad)->center.Y = 0.0;
702     (*grad)->focus.X = 0.0;
703     (*grad)->focus.Y = 0.0;
704
705     TRACE("<-- %p\n", *grad);
706
707     return Ok;
708 }
709
710 /******************************************************************************
711  * GdipCreateSolidFill [GDIPLUS.@]
712  */
713 GpStatus WINGDIPAPI GdipCreateSolidFill(ARGB color, GpSolidFill **sf)
714 {
715     COLORREF col = ARGB2COLORREF(color);
716
717     TRACE("(%x, %p)\n", color, sf);
718
719     if(!sf)  return InvalidParameter;
720
721     *sf = GdipAlloc(sizeof(GpSolidFill));
722     if (!*sf) return OutOfMemory;
723
724     (*sf)->brush.lb.lbStyle = BS_SOLID;
725     (*sf)->brush.lb.lbColor = col;
726     (*sf)->brush.lb.lbHatch = 0;
727
728     (*sf)->brush.gdibrush = CreateSolidBrush(col);
729     (*sf)->brush.bt = BrushTypeSolidColor;
730     (*sf)->color = color;
731     (*sf)->bmp = ARGB2BMP(color);
732
733     TRACE("<-- %p\n", *sf);
734
735     return Ok;
736 }
737
738 /******************************************************************************
739  * GdipCreateTexture [GDIPLUS.@]
740  *
741  * PARAMS
742  *  image       [I] image to use
743  *  wrapmode    [I] optional
744  *  texture     [O] pointer to the resulting texturebrush
745  *
746  * RETURNS
747  *  SUCCESS: Ok
748  *  FAILURE: element of GpStatus
749  */
750 GpStatus WINGDIPAPI GdipCreateTexture(GpImage *image, GpWrapMode wrapmode,
751         GpTexture **texture)
752 {
753     UINT width, height;
754     GpImageAttributes attributes;
755     GpStatus stat;
756
757     TRACE("%p, %d %p\n", image, wrapmode, texture);
758
759     if (!(image && texture))
760         return InvalidParameter;
761
762     stat = GdipGetImageWidth(image, &width);
763     if (stat != Ok) return stat;
764     stat = GdipGetImageHeight(image, &height);
765     if (stat != Ok) return stat;
766     attributes.wrap = wrapmode;
767
768     return GdipCreateTextureIA(image, &attributes, 0, 0, width, height,
769             texture);
770 }
771
772 /******************************************************************************
773  * GdipCreateTexture2 [GDIPLUS.@]
774  */
775 GpStatus WINGDIPAPI GdipCreateTexture2(GpImage *image, GpWrapMode wrapmode,
776         REAL x, REAL y, REAL width, REAL height, GpTexture **texture)
777 {
778     GpImageAttributes attributes;
779
780     TRACE("%p %d %f %f %f %f %p\n", image, wrapmode,
781             x, y, width, height, texture);
782
783     attributes.wrap = wrapmode;
784     return GdipCreateTextureIA(image, &attributes, x, y, width, height,
785             texture);
786 }
787
788 /******************************************************************************
789  * GdipCreateTextureIA [GDIPLUS.@]
790  *
791  * FIXME: imageattr ignored
792  */
793 GpStatus WINGDIPAPI GdipCreateTextureIA(GpImage *image,
794     GDIPCONST GpImageAttributes *imageattr, REAL x, REAL y, REAL width,
795     REAL height, GpTexture **texture)
796 {
797     HBITMAP hbm;
798     GpStatus status;
799     GpImage *new_image=NULL;
800
801     TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f, %p)\n", image, imageattr, x, y, width, height,
802            texture);
803
804     *texture = NULL;
805
806     if(!image || !texture || x < 0.0 || y < 0.0 || width < 0.0 || height < 0.0)
807         return InvalidParameter;
808
809     if(image->type != ImageTypeBitmap){
810         FIXME("not implemented for image type %d\n", image->type);
811         return NotImplemented;
812     }
813
814     status = GdipCloneBitmapArea(x, y, width, height, PixelFormatDontCare, (GpBitmap*)image, (GpBitmap**)&new_image);
815     if (status != Ok)
816         return status;
817
818     hbm = ((GpBitmap*)new_image)->hbitmap;
819     if(!hbm)
820     {
821         status = GenericError;
822         goto exit;
823     }
824
825     *texture = GdipAlloc(sizeof(GpTexture));
826     if (!*texture){
827         status = OutOfMemory;
828         goto exit;
829     }
830
831     if((status = GdipCreateMatrix(&(*texture)->transform)) != Ok){
832         goto exit;
833     }
834
835     (*texture)->brush.lb.lbStyle = BS_PATTERN;
836     (*texture)->brush.lb.lbColor = 0;
837     (*texture)->brush.lb.lbHatch = (ULONG_PTR)hbm;
838
839     (*texture)->brush.gdibrush = CreateBrushIndirect(&(*texture)->brush.lb);
840     (*texture)->brush.bt = BrushTypeTextureFill;
841     (*texture)->wrap = imageattr->wrap;
842     (*texture)->image = new_image;
843
844 exit:
845     if (status == Ok)
846     {
847         TRACE("<-- %p\n", *texture);
848     }
849     else
850     {
851         if (*texture)
852         {
853             GdipDeleteMatrix((*texture)->transform);
854             GdipFree(*texture);
855             *texture = NULL;
856         }
857         GdipDisposeImage(new_image);
858         TRACE("<-- error %u\n", status);
859     }
860
861     return status;
862 }
863
864 /******************************************************************************
865  * GdipCreateTextureIAI [GDIPLUS.@]
866  */
867 GpStatus WINGDIPAPI GdipCreateTextureIAI(GpImage *image, GDIPCONST GpImageAttributes *imageattr,
868     INT x, INT y, INT width, INT height, GpTexture **texture)
869 {
870     TRACE("(%p, %p, %d, %d, %d, %d, %p)\n", image, imageattr, x, y, width, height,
871            texture);
872
873     return GdipCreateTextureIA(image,imageattr,(REAL)x,(REAL)y,(REAL)width,(REAL)height,texture);
874 }
875
876 GpStatus WINGDIPAPI GdipCreateTexture2I(GpImage *image, GpWrapMode wrapmode,
877         INT x, INT y, INT width, INT height, GpTexture **texture)
878 {
879     GpImageAttributes imageattr;
880
881     TRACE("%p %d %d %d %d %d %p\n", image, wrapmode, x, y, width, height,
882             texture);
883
884     imageattr.wrap = wrapmode;
885
886     return GdipCreateTextureIA(image, &imageattr, x, y, width, height, texture);
887 }
888
889 GpStatus WINGDIPAPI GdipGetBrushType(GpBrush *brush, GpBrushType *type)
890 {
891     TRACE("(%p, %p)\n", brush, type);
892
893     if(!brush || !type)  return InvalidParameter;
894
895     *type = brush->bt;
896
897     return Ok;
898 }
899
900 GpStatus WINGDIPAPI GdipGetHatchBackgroundColor(GpHatch *brush, ARGB *backcol)
901 {
902     TRACE("(%p, %p)\n", brush, backcol);
903
904     if(!brush || !backcol)  return InvalidParameter;
905
906     *backcol = brush->backcol;
907
908     return Ok;
909 }
910
911 GpStatus WINGDIPAPI GdipGetHatchForegroundColor(GpHatch *brush, ARGB *forecol)
912 {
913     TRACE("(%p, %p)\n", brush, forecol);
914
915     if(!brush || !forecol)  return InvalidParameter;
916
917     *forecol = brush->forecol;
918
919     return Ok;
920 }
921
922 GpStatus WINGDIPAPI GdipGetHatchStyle(GpHatch *brush, HatchStyle *hatchstyle)
923 {
924     TRACE("(%p, %p)\n", brush, hatchstyle);
925
926     if(!brush || !hatchstyle)  return InvalidParameter;
927
928     *hatchstyle = brush->hatchstyle;
929
930     return Ok;
931 }
932
933 GpStatus WINGDIPAPI GdipDeleteBrush(GpBrush *brush)
934 {
935     TRACE("(%p)\n", brush);
936
937     if(!brush)  return InvalidParameter;
938
939     switch(brush->bt)
940     {
941         case BrushTypePathGradient:
942             GdipFree(((GpPathGradient*) brush)->pathdata.Points);
943             GdipFree(((GpPathGradient*) brush)->pathdata.Types);
944             GdipFree(((GpPathGradient*) brush)->blendfac);
945             GdipFree(((GpPathGradient*) brush)->blendpos);
946             break;
947         case BrushTypeSolidColor:
948             if (((GpSolidFill*)brush)->bmp)
949                 DeleteObject(((GpSolidFill*)brush)->bmp);
950             break;
951         case BrushTypeLinearGradient:
952             GdipFree(((GpLineGradient*)brush)->blendfac);
953             GdipFree(((GpLineGradient*)brush)->blendpos);
954             GdipFree(((GpLineGradient*)brush)->pblendcolor);
955             GdipFree(((GpLineGradient*)brush)->pblendpos);
956             break;
957         case BrushTypeTextureFill:
958             GdipDeleteMatrix(((GpTexture*)brush)->transform);
959             GdipDisposeImage(((GpTexture*)brush)->image);
960             break;
961         default:
962             break;
963     }
964
965     DeleteObject(brush->gdibrush);
966     GdipFree(brush);
967
968     return Ok;
969 }
970
971 GpStatus WINGDIPAPI GdipGetLineGammaCorrection(GpLineGradient *line,
972     BOOL *usinggamma)
973 {
974     TRACE("(%p, %p)\n", line, usinggamma);
975
976     if(!line || !usinggamma)
977         return InvalidParameter;
978
979     *usinggamma = line->gamma;
980
981     return Ok;
982 }
983
984 GpStatus WINGDIPAPI GdipGetLineWrapMode(GpLineGradient *brush, GpWrapMode *wrapmode)
985 {
986     TRACE("(%p, %p)\n", brush, wrapmode);
987
988     if(!brush || !wrapmode)
989         return InvalidParameter;
990
991     *wrapmode = brush->wrap;
992
993     return Ok;
994 }
995
996 GpStatus WINGDIPAPI GdipGetPathGradientBlend(GpPathGradient *brush, REAL *blend,
997     REAL *positions, INT count)
998 {
999     TRACE("(%p, %p, %p, %d)\n", brush, blend, positions, count);
1000
1001     if(!brush || !blend || !positions || count <= 0)
1002         return InvalidParameter;
1003
1004     if(count < brush->blendcount)
1005         return InsufficientBuffer;
1006
1007     memcpy(blend, brush->blendfac, count*sizeof(REAL));
1008     if(brush->blendcount > 1){
1009         memcpy(positions, brush->blendpos, count*sizeof(REAL));
1010     }
1011
1012     return Ok;
1013 }
1014
1015 GpStatus WINGDIPAPI GdipGetPathGradientBlendCount(GpPathGradient *brush, INT *count)
1016 {
1017     TRACE("(%p, %p)\n", brush, count);
1018
1019     if(!brush || !count)
1020         return InvalidParameter;
1021
1022     *count = brush->blendcount;
1023
1024     return Ok;
1025 }
1026
1027 GpStatus WINGDIPAPI GdipGetPathGradientCenterPoint(GpPathGradient *grad,
1028     GpPointF *point)
1029 {
1030     TRACE("(%p, %p)\n", grad, point);
1031
1032     if(!grad || !point)
1033         return InvalidParameter;
1034
1035     point->X = grad->center.X;
1036     point->Y = grad->center.Y;
1037
1038     return Ok;
1039 }
1040
1041 GpStatus WINGDIPAPI GdipGetPathGradientCenterPointI(GpPathGradient *grad,
1042     GpPoint *point)
1043 {
1044     GpStatus ret;
1045     GpPointF ptf;
1046
1047     TRACE("(%p, %p)\n", grad, point);
1048
1049     if(!point)
1050         return InvalidParameter;
1051
1052     ret = GdipGetPathGradientCenterPoint(grad,&ptf);
1053
1054     if(ret == Ok){
1055         point->X = roundr(ptf.X);
1056         point->Y = roundr(ptf.Y);
1057     }
1058
1059     return ret;
1060 }
1061
1062 GpStatus WINGDIPAPI GdipGetPathGradientFocusScales(GpPathGradient *grad,
1063     REAL *x, REAL *y)
1064 {
1065     TRACE("(%p, %p, %p)\n", grad, x, y);
1066
1067     if(!grad || !x || !y)
1068         return InvalidParameter;
1069
1070     *x = grad->focus.X;
1071     *y = grad->focus.Y;
1072
1073     return Ok;
1074 }
1075
1076 GpStatus WINGDIPAPI GdipGetPathGradientGammaCorrection(GpPathGradient *grad,
1077     BOOL *gamma)
1078 {
1079     TRACE("(%p, %p)\n", grad, gamma);
1080
1081     if(!grad || !gamma)
1082         return InvalidParameter;
1083
1084     *gamma = grad->gamma;
1085
1086     return Ok;
1087 }
1088
1089 GpStatus WINGDIPAPI GdipGetPathGradientPointCount(GpPathGradient *grad,
1090     INT *count)
1091 {
1092     TRACE("(%p, %p)\n", grad, count);
1093
1094     if(!grad || !count)
1095         return InvalidParameter;
1096
1097     *count = grad->pathdata.Count;
1098
1099     return Ok;
1100 }
1101
1102 GpStatus WINGDIPAPI GdipGetPathGradientRect(GpPathGradient *brush, GpRectF *rect)
1103 {
1104     GpRectF r;
1105     GpPath* path;
1106     GpStatus stat;
1107
1108     TRACE("(%p, %p)\n", brush, rect);
1109
1110     if(!brush || !rect)
1111         return InvalidParameter;
1112
1113     stat = GdipCreatePath2(brush->pathdata.Points, brush->pathdata.Types,
1114                            brush->pathdata.Count, FillModeAlternate, &path);
1115     if(stat != Ok)  return stat;
1116
1117     stat = GdipGetPathWorldBounds(path, &r, NULL, NULL);
1118     if(stat != Ok){
1119         GdipDeletePath(path);
1120         return stat;
1121     }
1122
1123     memcpy(rect, &r, sizeof(GpRectF));
1124
1125     GdipDeletePath(path);
1126
1127     return Ok;
1128 }
1129
1130 GpStatus WINGDIPAPI GdipGetPathGradientRectI(GpPathGradient *brush, GpRect *rect)
1131 {
1132     GpRectF rectf;
1133     GpStatus stat;
1134
1135     TRACE("(%p, %p)\n", brush, rect);
1136
1137     if(!brush || !rect)
1138         return InvalidParameter;
1139
1140     stat = GdipGetPathGradientRect(brush, &rectf);
1141     if(stat != Ok)  return stat;
1142
1143     rect->X = roundr(rectf.X);
1144     rect->Y = roundr(rectf.Y);
1145     rect->Width  = roundr(rectf.Width);
1146     rect->Height = roundr(rectf.Height);
1147
1148     return Ok;
1149 }
1150
1151 GpStatus WINGDIPAPI GdipGetPathGradientSurroundColorsWithCount(GpPathGradient
1152     *grad, ARGB *argb, INT *count)
1153 {
1154     static int calls;
1155
1156     TRACE("(%p,%p,%p)\n", grad, argb, count);
1157
1158     if(!grad || !argb || !count || (*count < grad->pathdata.Count))
1159         return InvalidParameter;
1160
1161     if(!(calls++))
1162         FIXME("not implemented\n");
1163
1164     return NotImplemented;
1165 }
1166
1167 GpStatus WINGDIPAPI GdipGetPathGradientWrapMode(GpPathGradient *brush,
1168     GpWrapMode *wrapmode)
1169 {
1170     TRACE("(%p, %p)\n", brush, wrapmode);
1171
1172     if(!brush || !wrapmode)
1173         return InvalidParameter;
1174
1175     *wrapmode = brush->wrap;
1176
1177     return Ok;
1178 }
1179
1180 GpStatus WINGDIPAPI GdipGetSolidFillColor(GpSolidFill *sf, ARGB *argb)
1181 {
1182     TRACE("(%p, %p)\n", sf, argb);
1183
1184     if(!sf || !argb)
1185         return InvalidParameter;
1186
1187     *argb = sf->color;
1188
1189     return Ok;
1190 }
1191
1192 /******************************************************************************
1193  * GdipGetTextureImage [GDIPLUS.@]
1194  */
1195 GpStatus WINGDIPAPI GdipGetTextureImage(GpTexture *brush, GpImage **image)
1196 {
1197     TRACE("(%p, %p)\n", brush, image);
1198
1199     if(!brush || !image)
1200         return InvalidParameter;
1201
1202     return GdipCloneImage(brush->image, image);
1203 }
1204
1205 /******************************************************************************
1206  * GdipGetTextureTransform [GDIPLUS.@]
1207  */
1208 GpStatus WINGDIPAPI GdipGetTextureTransform(GpTexture *brush, GpMatrix *matrix)
1209 {
1210     TRACE("(%p, %p)\n", brush, matrix);
1211
1212     if(!brush || !matrix)
1213         return InvalidParameter;
1214
1215     memcpy(matrix, brush->transform, sizeof(GpMatrix));
1216
1217     return Ok;
1218 }
1219
1220 /******************************************************************************
1221  * GdipGetTextureWrapMode [GDIPLUS.@]
1222  */
1223 GpStatus WINGDIPAPI GdipGetTextureWrapMode(GpTexture *brush, GpWrapMode *wrapmode)
1224 {
1225     TRACE("(%p, %p)\n", brush, wrapmode);
1226
1227     if(!brush || !wrapmode)
1228         return InvalidParameter;
1229
1230     *wrapmode = brush->wrap;
1231
1232     return Ok;
1233 }
1234
1235 /******************************************************************************
1236  * GdipMultiplyTextureTransform [GDIPLUS.@]
1237  */
1238 GpStatus WINGDIPAPI GdipMultiplyTextureTransform(GpTexture* brush,
1239     GDIPCONST GpMatrix *matrix, GpMatrixOrder order)
1240 {
1241     TRACE("(%p, %p, %d)\n", brush, matrix, order);
1242
1243     if(!brush || !matrix)
1244         return InvalidParameter;
1245
1246     return GdipMultiplyMatrix(brush->transform, matrix, order);
1247 }
1248
1249 /******************************************************************************
1250  * GdipResetTextureTransform [GDIPLUS.@]
1251  */
1252 GpStatus WINGDIPAPI GdipResetTextureTransform(GpTexture* brush)
1253 {
1254     TRACE("(%p)\n", brush);
1255
1256     if(!brush)
1257         return InvalidParameter;
1258
1259     return GdipSetMatrixElements(brush->transform, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0);
1260 }
1261
1262 /******************************************************************************
1263  * GdipScaleTextureTransform [GDIPLUS.@]
1264  */
1265 GpStatus WINGDIPAPI GdipScaleTextureTransform(GpTexture* brush,
1266     REAL sx, REAL sy, GpMatrixOrder order)
1267 {
1268     TRACE("(%p, %.2f, %.2f, %d)\n", brush, sx, sy, order);
1269
1270     if(!brush)
1271         return InvalidParameter;
1272
1273     return GdipScaleMatrix(brush->transform, sx, sy, order);
1274 }
1275
1276 GpStatus WINGDIPAPI GdipSetLineBlend(GpLineGradient *brush,
1277     GDIPCONST REAL *factors, GDIPCONST REAL* positions, INT count)
1278 {
1279     REAL *new_blendfac, *new_blendpos;
1280
1281     TRACE("(%p, %p, %p, %i)\n", brush, factors, positions, count);
1282
1283     if(!brush || !factors || !positions || count <= 0 ||
1284        (count >= 2 && (positions[0] != 0.0f || positions[count-1] != 1.0f)))
1285         return InvalidParameter;
1286
1287     new_blendfac = GdipAlloc(count * sizeof(REAL));
1288     new_blendpos = GdipAlloc(count * sizeof(REAL));
1289
1290     if (!new_blendfac || !new_blendpos)
1291     {
1292         GdipFree(new_blendfac);
1293         GdipFree(new_blendpos);
1294         return OutOfMemory;
1295     }
1296
1297     memcpy(new_blendfac, factors, count * sizeof(REAL));
1298     memcpy(new_blendpos, positions, count * sizeof(REAL));
1299
1300     GdipFree(brush->blendfac);
1301     GdipFree(brush->blendpos);
1302
1303     brush->blendcount = count;
1304     brush->blendfac = new_blendfac;
1305     brush->blendpos = new_blendpos;
1306
1307     return Ok;
1308 }
1309
1310 GpStatus WINGDIPAPI GdipGetLineBlend(GpLineGradient *brush, REAL *factors,
1311     REAL *positions, INT count)
1312 {
1313     TRACE("(%p, %p, %p, %i)\n", brush, factors, positions, count);
1314
1315     if (!brush || !factors || !positions || count <= 0)
1316         return InvalidParameter;
1317
1318     if (count < brush->blendcount)
1319         return InsufficientBuffer;
1320
1321     memcpy(factors, brush->blendfac, brush->blendcount * sizeof(REAL));
1322     memcpy(positions, brush->blendpos, brush->blendcount * sizeof(REAL));
1323
1324     return Ok;
1325 }
1326
1327 GpStatus WINGDIPAPI GdipGetLineBlendCount(GpLineGradient *brush, INT *count)
1328 {
1329     TRACE("(%p, %p)\n", brush, count);
1330
1331     if (!brush || !count)
1332         return InvalidParameter;
1333
1334     *count = brush->blendcount;
1335
1336     return Ok;
1337 }
1338
1339 GpStatus WINGDIPAPI GdipSetLineGammaCorrection(GpLineGradient *line,
1340     BOOL usegamma)
1341 {
1342     TRACE("(%p, %d)\n", line, usegamma);
1343
1344     if(!line)
1345         return InvalidParameter;
1346
1347     line->gamma = usegamma;
1348
1349     return Ok;
1350 }
1351
1352 GpStatus WINGDIPAPI GdipSetLineSigmaBlend(GpLineGradient *line, REAL focus,
1353     REAL scale)
1354 {
1355     REAL factors[33];
1356     REAL positions[33];
1357     int num_points = 0;
1358     int i;
1359     const int precision = 16;
1360     REAL erf_range; /* we use values erf(-erf_range) through erf(+erf_range) */
1361     REAL min_erf;
1362     REAL scale_erf;
1363
1364     TRACE("(%p, %0.2f, %0.2f)\n", line, focus, scale);
1365
1366     if(!line || focus < 0.0 || focus > 1.0 || scale < 0.0 || scale > 1.0)
1367         return InvalidParameter;
1368
1369     /* we want 2 standard deviations */
1370     erf_range = 2.0 / sqrt(2);
1371
1372     /* calculate the constants we need to normalize the error function to be
1373         between 0.0 and scale over the range we need */
1374     min_erf = erf(-erf_range);
1375     scale_erf = scale / (-2.0 * min_erf);
1376
1377     if (focus != 0.0)
1378     {
1379         positions[0] = 0.0;
1380         factors[0] = 0.0;
1381         for (i=1; i<precision; i++)
1382         {
1383             positions[i] = focus * i / precision;
1384             factors[i] = scale_erf * (erf(2 * erf_range * i / precision - erf_range) - min_erf);
1385         }
1386         num_points += precision;
1387     }
1388
1389     positions[num_points] = focus;
1390     factors[num_points] = scale;
1391     num_points += 1;
1392
1393     if (focus != 1.0)
1394     {
1395         for (i=1; i<precision; i++)
1396         {
1397             positions[i+num_points-1] = (focus + ((1.0-focus) * i / precision));
1398             factors[i+num_points-1] = scale_erf * (erf(erf_range - 2 * erf_range * i / precision) - min_erf);
1399         }
1400         num_points += precision;
1401         positions[num_points-1] = 1.0;
1402         factors[num_points-1] = 0.0;
1403     }
1404
1405     return GdipSetLineBlend(line, factors, positions, num_points);
1406 }
1407
1408 GpStatus WINGDIPAPI GdipSetLineWrapMode(GpLineGradient *line,
1409     GpWrapMode wrap)
1410 {
1411     TRACE("(%p, %d)\n", line, wrap);
1412
1413     if(!line || wrap == WrapModeClamp)
1414         return InvalidParameter;
1415
1416     line->wrap = wrap;
1417
1418     return Ok;
1419 }
1420
1421 GpStatus WINGDIPAPI GdipSetPathGradientBlend(GpPathGradient *brush, GDIPCONST REAL *blend,
1422     GDIPCONST REAL *pos, INT count)
1423 {
1424     static int calls;
1425
1426     TRACE("(%p,%p,%p,%i)\n", brush, blend, pos, count);
1427
1428     if(!(calls++))
1429         FIXME("not implemented\n");
1430
1431     return NotImplemented;
1432 }
1433
1434 GpStatus WINGDIPAPI GdipSetPathGradientPresetBlend(GpPathGradient *brush,
1435     GDIPCONST ARGB *blend, GDIPCONST REAL *pos, INT count)
1436 {
1437     FIXME("(%p,%p,%p,%i): stub\n", brush, blend, pos, count);
1438     return NotImplemented;
1439 }
1440
1441 GpStatus WINGDIPAPI GdipSetPathGradientCenterColor(GpPathGradient *grad,
1442     ARGB argb)
1443 {
1444     TRACE("(%p, %x)\n", grad, argb);
1445
1446     if(!grad)
1447         return InvalidParameter;
1448
1449     grad->centercolor = argb;
1450     grad->brush.lb.lbColor = ARGB2COLORREF(argb);
1451
1452     DeleteObject(grad->brush.gdibrush);
1453     grad->brush.gdibrush = CreateSolidBrush(grad->brush.lb.lbColor);
1454
1455     return Ok;
1456 }
1457
1458 GpStatus WINGDIPAPI GdipSetPathGradientCenterPoint(GpPathGradient *grad,
1459     GpPointF *point)
1460 {
1461     TRACE("(%p, %s)\n", grad, debugstr_pointf(point));
1462
1463     if(!grad || !point)
1464         return InvalidParameter;
1465
1466     grad->center.X = point->X;
1467     grad->center.Y = point->Y;
1468
1469     return Ok;
1470 }
1471
1472 GpStatus WINGDIPAPI GdipSetPathGradientCenterPointI(GpPathGradient *grad,
1473     GpPoint *point)
1474 {
1475     GpPointF ptf;
1476
1477     TRACE("(%p, %p)\n", grad, point);
1478
1479     if(!point)
1480         return InvalidParameter;
1481
1482     ptf.X = (REAL)point->X;
1483     ptf.Y = (REAL)point->Y;
1484
1485     return GdipSetPathGradientCenterPoint(grad,&ptf);
1486 }
1487
1488 GpStatus WINGDIPAPI GdipSetPathGradientFocusScales(GpPathGradient *grad,
1489     REAL x, REAL y)
1490 {
1491     TRACE("(%p, %.2f, %.2f)\n", grad, x, y);
1492
1493     if(!grad)
1494         return InvalidParameter;
1495
1496     grad->focus.X = x;
1497     grad->focus.Y = y;
1498
1499     return Ok;
1500 }
1501
1502 GpStatus WINGDIPAPI GdipSetPathGradientGammaCorrection(GpPathGradient *grad,
1503     BOOL gamma)
1504 {
1505     TRACE("(%p, %d)\n", grad, gamma);
1506
1507     if(!grad)
1508         return InvalidParameter;
1509
1510     grad->gamma = gamma;
1511
1512     return Ok;
1513 }
1514
1515 GpStatus WINGDIPAPI GdipSetPathGradientSigmaBlend(GpPathGradient *grad,
1516     REAL focus, REAL scale)
1517 {
1518     static int calls;
1519
1520     TRACE("(%p,%0.2f,%0.2f)\n", grad, focus, scale);
1521
1522     if(!grad || focus < 0.0 || focus > 1.0 || scale < 0.0 || scale > 1.0)
1523         return InvalidParameter;
1524
1525     if(!(calls++))
1526         FIXME("not implemented\n");
1527
1528     return NotImplemented;
1529 }
1530
1531 GpStatus WINGDIPAPI GdipSetPathGradientSurroundColorsWithCount(GpPathGradient
1532     *grad, ARGB *argb, INT *count)
1533 {
1534     static int calls;
1535
1536     TRACE("(%p,%p,%p)\n", grad, argb, count);
1537
1538     if(!grad || !argb || !count || (*count <= 0) ||
1539         (*count > grad->pathdata.Count))
1540         return InvalidParameter;
1541
1542     if(!(calls++))
1543         FIXME("not implemented\n");
1544
1545     return NotImplemented;
1546 }
1547
1548 GpStatus WINGDIPAPI GdipSetPathGradientWrapMode(GpPathGradient *grad,
1549     GpWrapMode wrap)
1550 {
1551     TRACE("(%p, %d)\n", grad, wrap);
1552
1553     if(!grad)
1554         return InvalidParameter;
1555
1556     grad->wrap = wrap;
1557
1558     return Ok;
1559 }
1560
1561 GpStatus WINGDIPAPI GdipSetSolidFillColor(GpSolidFill *sf, ARGB argb)
1562 {
1563     TRACE("(%p, %x)\n", sf, argb);
1564
1565     if(!sf)
1566         return InvalidParameter;
1567
1568     sf->color = argb;
1569     sf->brush.lb.lbColor = ARGB2COLORREF(argb);
1570
1571     DeleteObject(sf->brush.gdibrush);
1572     sf->brush.gdibrush = CreateSolidBrush(sf->brush.lb.lbColor);
1573
1574     return Ok;
1575 }
1576
1577 /******************************************************************************
1578  * GdipSetTextureTransform [GDIPLUS.@]
1579  */
1580 GpStatus WINGDIPAPI GdipSetTextureTransform(GpTexture *texture,
1581     GDIPCONST GpMatrix *matrix)
1582 {
1583     TRACE("(%p, %p)\n", texture, matrix);
1584
1585     if(!texture || !matrix)
1586         return InvalidParameter;
1587
1588     memcpy(texture->transform, matrix, sizeof(GpMatrix));
1589
1590     return Ok;
1591 }
1592
1593 /******************************************************************************
1594  * GdipSetTextureWrapMode [GDIPLUS.@]
1595  *
1596  * WrapMode not used, only stored
1597  */
1598 GpStatus WINGDIPAPI GdipSetTextureWrapMode(GpTexture *brush, GpWrapMode wrapmode)
1599 {
1600     TRACE("(%p, %d)\n", brush, wrapmode);
1601
1602     if(!brush)
1603         return InvalidParameter;
1604
1605     brush->wrap = wrapmode;
1606
1607     return Ok;
1608 }
1609
1610 GpStatus WINGDIPAPI GdipSetLineColors(GpLineGradient *brush, ARGB color1,
1611     ARGB color2)
1612 {
1613     TRACE("(%p, %x, %x)\n", brush, color1, color2);
1614
1615     if(!brush)
1616         return InvalidParameter;
1617
1618     brush->startcolor = color1;
1619     brush->endcolor   = color2;
1620
1621     return Ok;
1622 }
1623
1624 GpStatus WINGDIPAPI GdipGetLineColors(GpLineGradient *brush, ARGB *colors)
1625 {
1626     TRACE("(%p, %p)\n", brush, colors);
1627
1628     if(!brush || !colors)
1629         return InvalidParameter;
1630
1631     colors[0] = brush->startcolor;
1632     colors[1] = brush->endcolor;
1633
1634     return Ok;
1635 }
1636
1637 /******************************************************************************
1638  * GdipRotateTextureTransform [GDIPLUS.@]
1639  */
1640 GpStatus WINGDIPAPI GdipRotateTextureTransform(GpTexture* brush, REAL angle,
1641     GpMatrixOrder order)
1642 {
1643     TRACE("(%p, %.2f, %d)\n", brush, angle, order);
1644
1645     if(!brush)
1646         return InvalidParameter;
1647
1648     return GdipRotateMatrix(brush->transform, angle, order);
1649 }
1650
1651 GpStatus WINGDIPAPI GdipSetLineLinearBlend(GpLineGradient *brush, REAL focus,
1652     REAL scale)
1653 {
1654     REAL factors[3];
1655     REAL positions[3];
1656     int num_points = 0;
1657
1658     TRACE("(%p,%.2f,%.2f)\n", brush, focus, scale);
1659
1660     if (!brush) return InvalidParameter;
1661
1662     if (focus != 0.0)
1663     {
1664         factors[num_points] = 0.0;
1665         positions[num_points] = 0.0;
1666         num_points++;
1667     }
1668
1669     factors[num_points] = scale;
1670     positions[num_points] = focus;
1671     num_points++;
1672
1673     if (focus != 1.0)
1674     {
1675         factors[num_points] = 0.0;
1676         positions[num_points] = 1.0;
1677         num_points++;
1678     }
1679
1680     return GdipSetLineBlend(brush, factors, positions, num_points);
1681 }
1682
1683 GpStatus WINGDIPAPI GdipSetLinePresetBlend(GpLineGradient *brush,
1684     GDIPCONST ARGB *blend, GDIPCONST REAL* positions, INT count)
1685 {
1686     ARGB *new_color;
1687     REAL *new_pos;
1688     TRACE("(%p,%p,%p,%i)\n", brush, blend, positions, count);
1689
1690     if (!brush || !blend || !positions || count < 2 ||
1691         positions[0] != 0.0f || positions[count-1] != 1.0f)
1692     {
1693         return InvalidParameter;
1694     }
1695
1696     new_color = GdipAlloc(count * sizeof(ARGB));
1697     new_pos = GdipAlloc(count * sizeof(REAL));
1698     if (!new_color || !new_pos)
1699     {
1700         GdipFree(new_color);
1701         GdipFree(new_pos);
1702         return OutOfMemory;
1703     }
1704
1705     memcpy(new_color, blend, sizeof(ARGB) * count);
1706     memcpy(new_pos, positions, sizeof(REAL) * count);
1707
1708     GdipFree(brush->pblendcolor);
1709     GdipFree(brush->pblendpos);
1710
1711     brush->pblendcolor = new_color;
1712     brush->pblendpos = new_pos;
1713     brush->pblendcount = count;
1714
1715     return Ok;
1716 }
1717
1718 GpStatus WINGDIPAPI GdipGetLinePresetBlend(GpLineGradient *brush,
1719     ARGB *blend, REAL* positions, INT count)
1720 {
1721     if (!brush || !blend || !positions || count < 2)
1722         return InvalidParameter;
1723
1724     if (brush->pblendcount == 0)
1725         return GenericError;
1726
1727     if (count < brush->pblendcount)
1728         return InsufficientBuffer;
1729
1730     memcpy(blend, brush->pblendcolor, sizeof(ARGB) * brush->pblendcount);
1731     memcpy(positions, brush->pblendpos, sizeof(REAL) * brush->pblendcount);
1732
1733     return Ok;
1734 }
1735
1736 GpStatus WINGDIPAPI GdipGetLinePresetBlendCount(GpLineGradient *brush,
1737     INT *count)
1738 {
1739     if (!brush || !count)
1740         return InvalidParameter;
1741
1742     *count = brush->pblendcount;
1743
1744     return Ok;
1745 }
1746
1747 GpStatus WINGDIPAPI GdipResetLineTransform(GpLineGradient *brush)
1748 {
1749     static int calls;
1750
1751     TRACE("(%p)\n", brush);
1752
1753     if(!(calls++))
1754         FIXME("not implemented\n");
1755
1756     return NotImplemented;
1757 }
1758
1759 GpStatus WINGDIPAPI GdipSetLineTransform(GpLineGradient *brush,
1760     GDIPCONST GpMatrix *matrix)
1761 {
1762     static int calls;
1763
1764     TRACE("(%p,%p)\n", brush,  matrix);
1765
1766     if(!(calls++))
1767         FIXME("not implemented\n");
1768
1769     return NotImplemented;
1770 }
1771
1772 GpStatus WINGDIPAPI GdipScaleLineTransform(GpLineGradient *brush, REAL sx, REAL sy,
1773     GpMatrixOrder order)
1774 {
1775     static int calls;
1776
1777     TRACE("(%p,%0.2f,%0.2f,%u)\n", brush, sx, sy, order);
1778
1779     if(!(calls++))
1780         FIXME("not implemented\n");
1781
1782     return NotImplemented;
1783 }
1784
1785 GpStatus WINGDIPAPI GdipTranslateLineTransform(GpLineGradient* brush,
1786         REAL dx, REAL dy, GpMatrixOrder order)
1787 {
1788     FIXME("stub: %p %f %f %d\n", brush, dx, dy, order);
1789
1790     return NotImplemented;
1791 }
1792
1793 /******************************************************************************
1794  * GdipTranslateTextureTransform [GDIPLUS.@]
1795  */
1796 GpStatus WINGDIPAPI GdipTranslateTextureTransform(GpTexture* brush, REAL dx, REAL dy,
1797     GpMatrixOrder order)
1798 {
1799     TRACE("(%p, %.2f, %.2f, %d)\n", brush, dx, dy, order);
1800
1801     if(!brush)
1802         return InvalidParameter;
1803
1804     return GdipTranslateMatrix(brush->transform, dx, dy, order);
1805 }
1806
1807 GpStatus WINGDIPAPI GdipGetLineRect(GpLineGradient *brush, GpRectF *rect)
1808 {
1809     TRACE("(%p, %p)\n", brush, rect);
1810
1811     if(!brush || !rect)
1812         return InvalidParameter;
1813
1814     *rect = brush->rect;
1815
1816     return Ok;
1817 }
1818
1819 GpStatus WINGDIPAPI GdipGetLineRectI(GpLineGradient *brush, GpRect *rect)
1820 {
1821     GpRectF  rectF;
1822     GpStatus ret;
1823
1824     TRACE("(%p, %p)\n", brush, rect);
1825
1826     if(!rect)
1827         return InvalidParameter;
1828
1829     ret = GdipGetLineRect(brush, &rectF);
1830
1831     if(ret == Ok){
1832         rect->X      = roundr(rectF.X);
1833         rect->Y      = roundr(rectF.Y);
1834         rect->Width  = roundr(rectF.Width);
1835         rect->Height = roundr(rectF.Height);
1836     }
1837
1838     return ret;
1839 }
1840
1841 GpStatus WINGDIPAPI GdipRotateLineTransform(GpLineGradient* brush,
1842     REAL angle, GpMatrixOrder order)
1843 {
1844     static int calls;
1845
1846     TRACE("(%p,%0.2f,%u)\n", brush, angle, order);
1847
1848     if(!brush)
1849         return InvalidParameter;
1850
1851     if(!(calls++))
1852         FIXME("(%p, %.2f, %d) stub\n", brush, angle, order);
1853
1854     return NotImplemented;
1855 }