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