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