dlls/gdiplus/brush.c

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