reactos/dll/win32/gdiplus/brush.c

   1 /*
   2  * Copyright (C) 2007 Google (Evan Stade)
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include <stdarg.h>
  20
  21 #include "windef.h"
  22 #include "winbase.h"
  23 #include "winuser.h"
  24 #include "wingdi.h"
  25
  26 #define COBJMACROS
  27 #include "objbase.h"
  28 #include "olectl.h"
  29 #include "ole2.h"
  30
  31 #include "gdiplus.h"
  32 #include "gdiplus_private.h"
  33 #include "wine/debug.h"
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(gdiplus);
  36
  37 /******************************************************************************
  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             *clone = GdipAlloc(sizeof(GpSolidFill));
  50             if (!*clone) return OutOfMemory;
  51
  52             memcpy(*clone, brush, sizeof(GpSolidFill));
  53
  54             (*clone)->gdibrush = CreateBrushIndirect(&(*clone)->lb);
  55             break;
  56         case BrushTypeHatchFill:
  57             *clone = GdipAlloc(sizeof(GpHatch));
  58             if (!*clone) return OutOfMemory;
  59
  60             memcpy(*clone, brush, sizeof(GpHatch));
  61
  62             (*clone)->gdibrush = CreateBrushIndirect(&(*clone)->lb);
  63             break;
  64         case BrushTypePathGradient:{
  65             GpPathGradient *src, *dest;
  66             INT count;
  67
  68             *clone = GdipAlloc(sizeof(GpPathGradient));
  69             if (!*clone) return OutOfMemory;
  70
  71             src = (GpPathGradient*) brush,
  72             dest = (GpPathGradient*) *clone;
  73             count = src->pathdata.Count;
  74
  75             memcpy(dest, src, sizeof(GpPathGradient));
  76
  77             dest->pathdata.Count = count;
  78             dest->pathdata.Points = GdipAlloc(count * sizeof(PointF));
  79             dest->pathdata.Types = GdipAlloc(count);
  80
  81             if(!dest->pathdata.Points || !dest->pathdata.Types){
  82                 GdipFree(dest->pathdata.Points);
  83                 GdipFree(dest->pathdata.Types);
  84                 GdipFree(dest);
  85                 return OutOfMemory;
  86             }
  87
  88             memcpy(dest->pathdata.Points, src->pathdata.Points, count * sizeof(PointF));
  89             memcpy(dest->pathdata.Types, src->pathdata.Types, count);
  90
  91             /* blending */
  92             count = src->blendcount;
  93             dest->blendcount = count;
  94             dest->blendfac = GdipAlloc(count * sizeof(REAL));
  95             dest->blendpos = GdipAlloc(count * sizeof(REAL));
  96
  97             if(!dest->blendfac || !dest->blendpos){
  98                 GdipFree(dest->pathdata.Points);
  99                 GdipFree(dest->pathdata.Types);
 100                 GdipFree(dest->blendfac);
 101                 GdipFree(dest->blendpos);
 102                 GdipFree(dest);
 103                 return OutOfMemory;
 104             }
 105
 106             memcpy(dest->blendfac, src->blendfac, count * sizeof(REAL));
 107             memcpy(dest->blendpos, src->blendpos, count * sizeof(REAL));
 108
 109             break;
 110         }
 111         case BrushTypeLinearGradient:
 112             *clone = GdipAlloc(sizeof(GpLineGradient));
 113             if(!*clone)    return OutOfMemory;
 114
 115             memcpy(*clone, brush, sizeof(GpLineGradient));
 116
 117             (*clone)->gdibrush = CreateSolidBrush((*clone)->lb.lbColor);
 118             break;
 119         case BrushTypeTextureFill:
 120             *clone = GdipAlloc(sizeof(GpTexture));
 121             if(!*clone)    return OutOfMemory;
 122
 123             memcpy(*clone, brush, sizeof(GpTexture));
 124
 125             (*clone)->gdibrush = CreateBrushIndirect(&(*clone)->lb);
 126             break;
 127         default:
 128             ERR("not implemented for brush type %d\n", brush->bt);
 129             return NotImplemented;
 130     }
 131
 132     return Ok;
 133 }
 134
 135 static LONG HatchStyleToHatch(HatchStyle hatchstyle)
 136 {
 137     switch (hatchstyle)
 138     {
 139         case HatchStyleHorizontal:        return HS_HORIZONTAL;
 140         case HatchStyleVertical:          return HS_VERTICAL;
 141         case HatchStyleForwardDiagonal:   return HS_FDIAGONAL;
 142         case HatchStyleBackwardDiagonal:  return HS_BDIAGONAL;
 143         case HatchStyleCross:             return HS_CROSS;
 144         case HatchStyleDiagonalCross:     return HS_DIAGCROSS;
 145         default:                          return 0;
 146     }
 147 }
 148
 149 /******************************************************************************
 150  * GdipCreateHatchBrush [GDIPLUS.@]
 151  */
 152 GpStatus WINGDIPAPI GdipCreateHatchBrush(HatchStyle hatchstyle, ARGB forecol, ARGB backcol, GpHatch **brush)
 153 {
 154     COLORREF fgcol = ARGB2COLORREF(forecol);
 155
 156     TRACE("(%d, %d, %d, %p)\n", hatchstyle, forecol, backcol, brush);
 157
 158     if(!brush)  return InvalidParameter;
 159
 160     *brush = GdipAlloc(sizeof(GpHatch));
 161     if (!*brush) return OutOfMemory;
 162
 163     switch (hatchstyle)
 164     {
 165         case HatchStyleHorizontal:
 166         case HatchStyleVertical:
 167         case HatchStyleForwardDiagonal:
 168         case HatchStyleBackwardDiagonal:
 169         case HatchStyleCross:
 170         case HatchStyleDiagonalCross:
 171             /* Brushes that map to BS_HATCHED */
 172             (*brush)->brush.lb.lbStyle = BS_HATCHED;
 173             (*brush)->brush.lb.lbColor = fgcol;
 174             (*brush)->brush.lb.lbHatch = HatchStyleToHatch(hatchstyle);
 175             break;
 176
 177         default:
 178             FIXME("Unimplemented hatch style %d\n", hatchstyle);
 179
 180             (*brush)->brush.lb.lbStyle = BS_SOLID;
 181             (*brush)->brush.lb.lbColor = fgcol;
 182             (*brush)->brush.lb.lbHatch = 0;
 183             break;
 184     }
 185
 186
 187     (*brush)->brush.gdibrush = CreateBrushIndirect(&(*brush)->brush.lb);
 188     (*brush)->brush.bt = BrushTypeHatchFill;
 189     (*brush)->forecol = forecol;
 190     (*brush)->backcol = backcol;
 191     (*brush)->hatchstyle = hatchstyle;
 192
 193     return Ok;
 194 }
 195
 196 /******************************************************************************
 197  * GdipCreateLineBrush [GDIPLUS.@]
 198  */
 199 GpStatus WINGDIPAPI GdipCreateLineBrush(GDIPCONST GpPointF* startpoint,
 200     GDIPCONST GpPointF* endpoint, ARGB startcolor, ARGB endcolor,
 201     GpWrapMode wrap, GpLineGradient **line)
 202 {
 203     COLORREF col = ARGB2COLORREF(startcolor);
 204
 205     TRACE("(%p, %p, %x, %x, %d, %p)\n", startpoint, endpoint,
 206           startcolor, endcolor, wrap, line);
 207
 208     if(!line || !startpoint || !endpoint || wrap == WrapModeClamp)
 209         return InvalidParameter;
 210
 211     *line = GdipAlloc(sizeof(GpLineGradient));
 212     if(!*line)  return OutOfMemory;
 213
 214     (*line)->brush.lb.lbStyle = BS_SOLID;
 215     (*line)->brush.lb.lbColor = col;
 216     (*line)->brush.lb.lbHatch = 0;
 217     (*line)->brush.gdibrush = CreateSolidBrush(col);
 218     (*line)->brush.bt = BrushTypeLinearGradient;
 219
 220     (*line)->startpoint.X = startpoint->X;
 221     (*line)->startpoint.Y = startpoint->Y;
 222     (*line)->endpoint.X = endpoint->X;
 223     (*line)->endpoint.Y = endpoint->Y;
 224     (*line)->startcolor = startcolor;
 225     (*line)->endcolor = endcolor;
 226     (*line)->wrap = wrap;
 227     (*line)->gamma = FALSE;
 228
 229     return Ok;
 230 }
 231
 232 GpStatus WINGDIPAPI GdipCreateLineBrushI(GDIPCONST GpPoint* startpoint,
 233     GDIPCONST GpPoint* endpoint, ARGB startcolor, ARGB endcolor,
 234     GpWrapMode wrap, GpLineGradient **line)
 235 {
 236     GpPointF stF;
 237     GpPointF endF;
 238
 239     TRACE("(%p, %p, %x, %x, %d, %p)\n", startpoint, endpoint,
 240           startcolor, endcolor, wrap, line);
 241
 242     if(!startpoint || !endpoint)
 243         return InvalidParameter;
 244
 245     stF.X  = (REAL)startpoint->X;
 246     stF.Y  = (REAL)startpoint->Y;
 247     endF.X = (REAL)endpoint->X;
 248     endF.X = (REAL)endpoint->Y;
 249
 250     return GdipCreateLineBrush(&stF, &endF, startcolor, endcolor, wrap, line);
 251 }
 252
 253 GpStatus WINGDIPAPI GdipCreateLineBrushFromRect(GDIPCONST GpRectF* rect,
 254     ARGB startcolor, ARGB endcolor, LinearGradientMode mode, GpWrapMode wrap,
 255     GpLineGradient **line)
 256 {
 257     GpPointF start, end;
 258
 259     TRACE("(%p, %x, %x, %d, %d, %p)\n", rect, startcolor, endcolor, mode,
 260           wrap, line);
 261
 262     if(!line || !rect)
 263         return InvalidParameter;
 264
 265     start.X = rect->X;
 266     start.Y = rect->Y;
 267     end.X = rect->X + rect->Width;
 268     end.Y = rect->Y + rect->Height;
 269
 270     return GdipCreateLineBrush(&start, &end, startcolor, endcolor, wrap, line);
 271 }
 272
 273 GpStatus WINGDIPAPI GdipCreateLineBrushFromRectI(GDIPCONST GpRect* rect,
 274     ARGB startcolor, ARGB endcolor, LinearGradientMode mode, GpWrapMode wrap,
 275     GpLineGradient **line)
 276 {
 277     GpRectF rectF;
 278
 279     TRACE("(%p, %x, %x, %d, %d, %p)\n", rect, startcolor, endcolor, mode,
 280           wrap, line);
 281
 282     rectF.X      = (REAL) rect->X;
 283     rectF.Y      = (REAL) rect->Y;
 284     rectF.Width  = (REAL) rect->Width;
 285     rectF.Height = (REAL) rect->Height;
 286
 287     return GdipCreateLineBrushFromRect(&rectF, startcolor, endcolor, mode, wrap, line);
 288 }
 289
 290 /******************************************************************************
 291  * GdipCreateLineBrushFromRectWithAngle [GDIPLUS.@]
 292  *
 293  * FIXME: angle value completely ignored. Don't know how to use it since native
 294  *        always set Brush rectangle to rect (independetly of this angle).
 295  *        Maybe it's used only on drawing.
 296  */
 297 GpStatus WINGDIPAPI GdipCreateLineBrushFromRectWithAngle(GDIPCONST GpRectF* rect,
 298     ARGB startcolor, ARGB endcolor, REAL angle, BOOL isAngleScalable, GpWrapMode wrap,
 299     GpLineGradient **line)
 300 {
 301     TRACE("(%p, %x, %x, %.2f, %d, %d, %p)\n", rect, startcolor, endcolor, angle, isAngleScalable,
 302           wrap, line);
 303
 304     return GdipCreateLineBrushFromRect(rect, startcolor, endcolor, LinearGradientModeForwardDiagonal,
 305                                        wrap, line);
 306 }
 307
 308 GpStatus WINGDIPAPI GdipCreateLineBrushFromRectWithAngleI(GDIPCONST GpRect* rect,
 309     ARGB startcolor, ARGB endcolor, REAL angle, BOOL isAngleScalable, GpWrapMode wrap,
 310     GpLineGradient **line)
 311 {
 312     TRACE("(%p, %x, %x, %.2f, %d, %d, %p)\n", rect, startcolor, endcolor, angle, isAngleScalable,
 313           wrap, line);
 314
 315     return GdipCreateLineBrushFromRectI(rect, startcolor, endcolor, LinearGradientModeForwardDiagonal,
 316                                         wrap, line);
 317 }
 318
 319 GpStatus WINGDIPAPI GdipCreatePathGradient(GDIPCONST GpPointF* points,
 320     INT count, GpWrapMode wrap, GpPathGradient **grad)
 321 {
 322     COLORREF col = ARGB2COLORREF(0xffffffff);
 323
 324     TRACE("(%p, %d, %d, %p)\n", points, count, wrap, grad);
 325
 326     if(!points || !grad)
 327         return InvalidParameter;
 328
 329     if(count <= 0)
 330         return OutOfMemory;
 331
 332     *grad = GdipAlloc(sizeof(GpPathGradient));
 333     if (!*grad) return OutOfMemory;
 334
 335     (*grad)->blendfac = GdipAlloc(sizeof(REAL));
 336     if(!(*grad)->blendfac){
 337         GdipFree(*grad);
 338         return OutOfMemory;
 339     }
 340     (*grad)->blendfac[0] = 1.0;
 341     (*grad)->blendpos    = NULL;
 342     (*grad)->blendcount  = 1;
 343
 344     (*grad)->pathdata.Count = count;
 345     (*grad)->pathdata.Points = GdipAlloc(count * sizeof(PointF));
 346     (*grad)->pathdata.Types = GdipAlloc(count);
 347
 348     if(!(*grad)->pathdata.Points || !(*grad)->pathdata.Types){
 349         GdipFree((*grad)->pathdata.Points);
 350         GdipFree((*grad)->pathdata.Types);
 351         GdipFree(*grad);
 352         return OutOfMemory;
 353     }
 354
 355     memcpy((*grad)->pathdata.Points, points, count * sizeof(PointF));
 356     memset((*grad)->pathdata.Types, PathPointTypeLine, count);
 357
 358     (*grad)->brush.lb.lbStyle = BS_SOLID;
 359     (*grad)->brush.lb.lbColor = col;
 360     (*grad)->brush.lb.lbHatch = 0;
 361
 362     (*grad)->brush.gdibrush = CreateSolidBrush(col);
 363     (*grad)->brush.bt = BrushTypePathGradient;
 364     (*grad)->centercolor = 0xffffffff;
 365     (*grad)->wrap = wrap;
 366     (*grad)->gamma = FALSE;
 367     (*grad)->center.X = 0.0;
 368     (*grad)->center.Y = 0.0;
 369     (*grad)->focus.X = 0.0;
 370     (*grad)->focus.Y = 0.0;
 371
 372     return Ok;
 373 }
 374
 375 GpStatus WINGDIPAPI GdipCreatePathGradientI(GDIPCONST GpPoint* points,
 376     INT count, GpWrapMode wrap, GpPathGradient **grad)
 377 {
 378     GpPointF *pointsF;
 379     GpStatus ret;
 380     INT i;
 381
 382     TRACE("(%p, %d, %d, %p)\n", points, count, wrap, grad);
 383
 384     if(!points || !grad)
 385         return InvalidParameter;
 386
 387     if(count <= 0)
 388         return OutOfMemory;
 389
 390     pointsF = GdipAlloc(sizeof(GpPointF) * count);
 391     if(!pointsF)
 392         return OutOfMemory;
 393
 394     for(i = 0; i < count; i++){
 395         pointsF[i].X = (REAL)points[i].X;
 396         pointsF[i].Y = (REAL)points[i].Y;
 397     }
 398
 399     ret = GdipCreatePathGradient(pointsF, count, wrap, grad);
 400     GdipFree(pointsF);
 401
 402     return ret;
 403 }
 404
 405 /******************************************************************************
 406  * GdipCreatePathGradientFromPath [GDIPLUS.@]
 407  *
 408  * FIXME: path gradient brushes not truly supported (drawn as solid brushes)
 409  */
 410 GpStatus WINGDIPAPI GdipCreatePathGradientFromPath(GDIPCONST GpPath* path,
 411     GpPathGradient **grad)
 412 {
 413     COLORREF col = ARGB2COLORREF(0xffffffff);
 414
 415     TRACE("(%p, %p)\n", path, grad);
 416
 417     if(!path || !grad)
 418         return InvalidParameter;
 419
 420     *grad = GdipAlloc(sizeof(GpPathGradient));
 421     if (!*grad) return OutOfMemory;
 422
 423     (*grad)->blendfac = GdipAlloc(sizeof(REAL));
 424     if(!(*grad)->blendfac){
 425         GdipFree(*grad);
 426         return OutOfMemory;
 427     }
 428     (*grad)->blendfac[0] = 1.0;
 429     (*grad)->blendpos    = NULL;
 430     (*grad)->blendcount  = 1;
 431
 432     (*grad)->pathdata.Count = path->pathdata.Count;
 433     (*grad)->pathdata.Points = GdipAlloc(path->pathdata.Count * sizeof(PointF));
 434     (*grad)->pathdata.Types = GdipAlloc(path->pathdata.Count);
 435
 436     if(!(*grad)->pathdata.Points || !(*grad)->pathdata.Types){
 437         GdipFree((*grad)->pathdata.Points);
 438         GdipFree((*grad)->pathdata.Types);
 439         GdipFree(*grad);
 440         return OutOfMemory;
 441     }
 442
 443     memcpy((*grad)->pathdata.Points, path->pathdata.Points,
 444            path->pathdata.Count * sizeof(PointF));
 445     memcpy((*grad)->pathdata.Types, path->pathdata.Types, path->pathdata.Count);
 446
 447     (*grad)->brush.lb.lbStyle = BS_SOLID;
 448     (*grad)->brush.lb.lbColor = col;
 449     (*grad)->brush.lb.lbHatch = 0;
 450
 451     (*grad)->brush.gdibrush = CreateSolidBrush(col);
 452     (*grad)->brush.bt = BrushTypePathGradient;
 453     (*grad)->centercolor = 0xffffffff;
 454     (*grad)->wrap = WrapModeClamp;
 455     (*grad)->gamma = FALSE;
 456     /* FIXME: this should be set to the "centroid" of the path by default */
 457     (*grad)->center.X = 0.0;
 458     (*grad)->center.Y = 0.0;
 459     (*grad)->focus.X = 0.0;
 460     (*grad)->focus.Y = 0.0;
 461
 462     return Ok;
 463 }
 464
 465 /******************************************************************************
 466  * GdipCreateSolidFill [GDIPLUS.@]
 467  */
 468 GpStatus WINGDIPAPI GdipCreateSolidFill(ARGB color, GpSolidFill **sf)
 469 {
 470     COLORREF col = ARGB2COLORREF(color);
 471
 472     TRACE("(%x, %p)\n", color, sf);
 473
 474     if(!sf)  return InvalidParameter;
 475
 476     *sf = GdipAlloc(sizeof(GpSolidFill));
 477     if (!*sf) return OutOfMemory;
 478
 479     (*sf)->brush.lb.lbStyle = BS_SOLID;
 480     (*sf)->brush.lb.lbColor = col;
 481     (*sf)->brush.lb.lbHatch = 0;
 482
 483     (*sf)->brush.gdibrush = CreateSolidBrush(col);
 484     (*sf)->brush.bt = BrushTypeSolidColor;
 485     (*sf)->color = color;
 486
 487     return Ok;
 488 }
 489
 490 /******************************************************************************
 491  * GdipCreateTexture [GDIPLUS.@]
 492  *
 493  * PARAMS
 494  *  image       [I] image to use
 495  *  wrapmode    [I] optional
 496  *  texture     [O] pointer to the resulting texturebrush
 497  *
 498  * RETURNS
 499  *  SUCCESS: Ok
 500  *  FAILURE: element of GpStatus
 501  */
 502 GpStatus WINGDIPAPI GdipCreateTexture(GpImage *image, GpWrapMode wrapmode,
 503         GpTexture **texture)
 504 {
 505     UINT width, height;
 506     GpImageAttributes attributes;
 507     GpStatus stat;
 508
 509     TRACE("%p, %d %p\n", image, wrapmode, texture);
 510
 511     if (!(image && texture))
 512         return InvalidParameter;
 513
 514     stat = GdipGetImageWidth(image, &width);
 515     if (stat != Ok) return stat;
 516     stat = GdipGetImageHeight(image, &height);
 517     if (stat != Ok) return stat;
 518     attributes.wrap = wrapmode;
 519
 520     return GdipCreateTextureIA(image, &attributes, 0, 0, width, height,
 521             texture);
 522 }
 523
 524 /******************************************************************************
 525  * GdipCreateTexture2 [GDIPLUS.@]
 526  */
 527 GpStatus WINGDIPAPI GdipCreateTexture2(GpImage *image, GpWrapMode wrapmode,
 528         REAL x, REAL y, REAL width, REAL height, GpTexture **texture)
 529 {
 530     GpImageAttributes attributes;
 531
 532     TRACE("%p %d %f %f %f %f %p\n", image, wrapmode,
 533             x, y, width, height, texture);
 534
 535     attributes.wrap = wrapmode;
 536     return GdipCreateTextureIA(image, &attributes, x, y, width, height,
 537             texture);
 538 }
 539
 540 /******************************************************************************
 541  * GdipCreateTextureIA [GDIPLUS.@]
 542  *
 543  * FIXME: imageattr ignored
 544  */
 545 GpStatus WINGDIPAPI GdipCreateTextureIA(GpImage *image,
 546     GDIPCONST GpImageAttributes *imageattr, REAL x, REAL y, REAL width,
 547     REAL height, GpTexture **texture)
 548 {
 549     HDC hdc;
 550     HBITMAP hbm, old = NULL;
 551     BITMAPINFO *pbmi;
 552     BITMAPINFOHEADER *bmih;
 553     INT n_x, n_y, n_width, n_height, abs_height, stride, image_stride, i, bytespp;
 554     BOOL bm_is_selected;
 555     BYTE *dibits, *buff, *textbits;
 556     GpStatus status;
 557
 558     TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f, %p)\n", image, imageattr, x, y, width, height,
 559            texture);
 560
 561     if(!image || !texture || x < 0.0 || y < 0.0 || width < 0.0 || height < 0.0)
 562         return InvalidParameter;
 563
 564     if(image->type != ImageTypeBitmap){
 565         FIXME("not implemented for image type %d\n", image->type);
 566         return NotImplemented;
 567     }
 568
 569     n_x = roundr(x);
 570     n_y = roundr(y);
 571     n_width = roundr(width);
 572     n_height = roundr(height);
 573
 574     if(n_x + n_width > ((GpBitmap*)image)->width ||
 575        n_y + n_height > ((GpBitmap*)image)->height)
 576         return InvalidParameter;
 577
 578     IPicture_get_Handle(image->picture, (OLE_HANDLE*)&hbm);
 579     if(!hbm)   return GenericError;
 580     IPicture_get_CurDC(image->picture, &hdc);
 581     bm_is_selected = (hdc != 0);
 582
 583     pbmi = GdipAlloc(sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD));
 584     if (!pbmi)
 585         return OutOfMemory;
 586     pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
 587     pbmi->bmiHeader.biBitCount = 0;
 588
 589     if(!bm_is_selected){
 590         hdc = CreateCompatibleDC(0);
 591         old = SelectObject(hdc, hbm);
 592     }
 593
 594     /* fill out bmi */
 595     GetDIBits(hdc, hbm, 0, 0, NULL, pbmi, DIB_RGB_COLORS);
 596
 597     bytespp = pbmi->bmiHeader.biBitCount / 8;
 598     abs_height = abs(pbmi->bmiHeader.biHeight);
 599
 600     if(n_x > pbmi->bmiHeader.biWidth || n_x + n_width > pbmi->bmiHeader.biWidth ||
 601        n_y > abs_height || n_y + n_height > abs_height){
 602         GdipFree(pbmi);
 603         return InvalidParameter;
 604     }
 605
 606     dibits = GdipAlloc(pbmi->bmiHeader.biSizeImage);
 607
 608     if(dibits)  /* this is not a good place to error out */
 609         GetDIBits(hdc, hbm, 0, abs_height, dibits, pbmi, DIB_RGB_COLORS);
 610
 611     if(!bm_is_selected){
 612         SelectObject(hdc, old);
 613         DeleteDC(hdc);
 614     }
 615
 616     if(!dibits){
 617         GdipFree(pbmi);
 618         return OutOfMemory;
 619     }
 620
 621     image_stride = (pbmi->bmiHeader.biWidth * bytespp + 3) & ~3;
 622     stride = (n_width * bytespp + 3) & ~3;
 623     buff = GdipAlloc(sizeof(BITMAPINFOHEADER) + stride * n_height);
 624     if(!buff){
 625         GdipFree(pbmi);
 626         GdipFree(dibits);
 627         return OutOfMemory;
 628     }
 629
 630     bmih = (BITMAPINFOHEADER*)buff;
 631     textbits = (BYTE*) (bmih + 1);
 632     bmih->biSize = sizeof(BITMAPINFOHEADER);
 633     bmih->biWidth = n_width;
 634     bmih->biHeight = n_height;
 635     bmih->biCompression = BI_RGB;
 636     bmih->biSizeImage = stride * n_height;
 637     bmih->biBitCount = pbmi->bmiHeader.biBitCount;
 638     bmih->biClrUsed = 0;
 639     bmih->biPlanes = 1;
 640
 641     /* image is flipped */
 642     if(pbmi->bmiHeader.biHeight > 0){
 643         dibits += pbmi->bmiHeader.biSizeImage;
 644         image_stride *= -1;
 645         textbits += stride * (n_height - 1);
 646         stride *= -1;
 647     }
 648
 649     GdipFree(pbmi);
 650
 651     for(i = 0; i < n_height; i++)
 652         memcpy(&textbits[i * stride],
 653                &dibits[n_x * bytespp + (n_y + i) * image_stride],
 654                abs(stride));
 655
 656     *texture = GdipAlloc(sizeof(GpTexture));
 657     if (!*texture){
 658         GdipFree(dibits);
 659         GdipFree(buff);
 660         return OutOfMemory;
 661     }
 662
 663     if((status = GdipCreateMatrix(&(*texture)->transform)) != Ok){
 664         GdipFree(*texture);
 665         GdipFree(dibits);
 666         GdipFree(buff);
 667         return status;
 668     }
 669
 670     (*texture)->brush.lb.lbStyle = BS_DIBPATTERNPT;
 671     (*texture)->brush.lb.lbColor = DIB_RGB_COLORS;
 672     (*texture)->brush.lb.lbHatch = (ULONG_PTR)buff;
 673
 674     (*texture)->brush.gdibrush = CreateBrushIndirect(&(*texture)->brush.lb);
 675     (*texture)->brush.bt = BrushTypeTextureFill;
 676     (*texture)->wrap = imageattr->wrap;
 677
 678     GdipFree(dibits);
 679     GdipFree(buff);
 680
 681     return Ok;
 682 }
 683
 684 /******************************************************************************
 685  * GdipCreateTextureIAI [GDIPLUS.@]
 686  */
 687 GpStatus WINGDIPAPI GdipCreateTextureIAI(GpImage *image, GDIPCONST GpImageAttributes *imageattr,
 688     INT x, INT y, INT width, INT height, GpTexture **texture)
 689 {
 690     TRACE("(%p, %p, %d, %d, %d, %d, %p)\n", image, imageattr, x, y, width, height,
 691            texture);
 692
 693     return GdipCreateTextureIA(image,imageattr,(REAL)x,(REAL)y,(REAL)width,(REAL)height,texture);
 694 }
 695
 696 GpStatus WINGDIPAPI GdipCreateTexture2I(GpImage *image, GpWrapMode wrapmode,
 697         INT x, INT y, INT width, INT height, GpTexture **texture)
 698 {
 699     GpImageAttributes imageattr;
 700
 701     TRACE("%p %d %d %d %d %d %p\n", image, wrapmode, x, y, width, height,
 702             texture);
 703
 704     imageattr.wrap = wrapmode;
 705
 706     return GdipCreateTextureIA(image, &imageattr, x, y, width, height, texture);
 707 }
 708
 709 GpStatus WINGDIPAPI GdipGetBrushType(GpBrush *brush, GpBrushType *type)
 710 {
 711     TRACE("(%p, %p)\n", brush, type);
 712
 713     if(!brush || !type)  return InvalidParameter;
 714
 715     *type = brush->bt;
 716
 717     return Ok;
 718 }
 719
 720 GpStatus WINGDIPAPI GdipGetHatchBackgroundColor(GpHatch *brush, ARGB *backcol)
 721 {
 722     TRACE("(%p, %p)\n", brush, backcol);
 723
 724     if(!brush || !backcol)  return InvalidParameter;
 725
 726     *backcol = brush->backcol;
 727
 728     return Ok;
 729 }
 730
 731 GpStatus WINGDIPAPI GdipGetHatchForegroundColor(GpHatch *brush, ARGB *forecol)
 732 {
 733     TRACE("(%p, %p)\n", brush, forecol);
 734
 735     if(!brush || !forecol)  return InvalidParameter;
 736
 737     *forecol = brush->forecol;
 738
 739     return Ok;
 740 }
 741
 742 GpStatus WINGDIPAPI GdipGetHatchStyle(GpHatch *brush, HatchStyle *hatchstyle)
 743 {
 744     TRACE("(%p, %p)\n", brush, hatchstyle);
 745
 746     if(!brush || !hatchstyle)  return InvalidParameter;
 747
 748     *hatchstyle = brush->hatchstyle;
 749
 750     return Ok;
 751 }
 752
 753 GpStatus WINGDIPAPI GdipDeleteBrush(GpBrush *brush)
 754 {
 755     TRACE("(%p)\n", brush);
 756
 757     if(!brush)  return InvalidParameter;
 758
 759     switch(brush->bt)
 760     {
 761         case BrushTypePathGradient:
 762             GdipFree(((GpPathGradient*) brush)->pathdata.Points);
 763             GdipFree(((GpPathGradient*) brush)->pathdata.Types);
 764             GdipFree(((GpPathGradient*) brush)->blendfac);
 765             GdipFree(((GpPathGradient*) brush)->blendpos);
 766             break;
 767         case BrushTypeSolidColor:
 768         case BrushTypeLinearGradient:
 769             break;
 770         case BrushTypeTextureFill:
 771             GdipDeleteMatrix(((GpTexture*)brush)->transform);
 772             break;
 773         default:
 774             break;
 775     }
 776
 777     DeleteObject(brush->gdibrush);
 778     GdipFree(brush);
 779
 780     return Ok;
 781 }
 782
 783 GpStatus WINGDIPAPI GdipGetLineGammaCorrection(GpLineGradient *line,
 784     BOOL *usinggamma)
 785 {
 786     TRACE("(%p, %p)\n", line, usinggamma);
 787
 788     if(!line || !usinggamma)
 789         return InvalidParameter;
 790
 791     *usinggamma = line->gamma;
 792
 793     return Ok;
 794 }
 795
 796 GpStatus WINGDIPAPI GdipGetLineWrapMode(GpLineGradient *brush, GpWrapMode *wrapmode)
 797 {
 798     TRACE("(%p, %p)\n", brush, wrapmode);
 799
 800     if(!brush || !wrapmode)
 801         return InvalidParameter;
 802
 803     *wrapmode = brush->wrap;
 804
 805     return Ok;
 806 }
 807
 808 GpStatus WINGDIPAPI GdipGetPathGradientBlend(GpPathGradient *brush, REAL *blend,
 809     REAL *positions, INT count)
 810 {
 811     TRACE("(%p, %p, %p, %d)\n", brush, blend, positions, count);
 812
 813     if(!brush || !blend || !positions || count <= 0)
 814         return InvalidParameter;
 815
 816     if(count < brush->blendcount)
 817         return InsufficientBuffer;
 818
 819     memcpy(blend, brush->blendfac, count*sizeof(REAL));
 820     if(brush->blendcount > 1){
 821         memcpy(positions, brush->blendpos, count*sizeof(REAL));
 822     }
 823
 824     return Ok;
 825 }
 826
 827 GpStatus WINGDIPAPI GdipGetPathGradientBlendCount(GpPathGradient *brush, INT *count)
 828 {
 829     TRACE("(%p, %p)\n", brush, count);
 830
 831     if(!brush || !count)
 832         return InvalidParameter;
 833
 834     *count = brush->blendcount;
 835
 836     return Ok;
 837 }
 838
 839 GpStatus WINGDIPAPI GdipGetPathGradientCenterPoint(GpPathGradient *grad,
 840     GpPointF *point)
 841 {
 842     TRACE("(%p, %p)\n", grad, point);
 843
 844     if(!grad || !point)
 845         return InvalidParameter;
 846
 847     point->X = grad->center.X;
 848     point->Y = grad->center.Y;
 849
 850     return Ok;
 851 }
 852
 853 GpStatus WINGDIPAPI GdipGetPathGradientCenterPointI(GpPathGradient *grad,
 854     GpPoint *point)
 855 {
 856     GpStatus ret;
 857     GpPointF ptf;
 858
 859     TRACE("(%p, %p)\n", grad, point);
 860
 861     if(!point)
 862         return InvalidParameter;
 863
 864     ret = GdipGetPathGradientCenterPoint(grad,&ptf);
 865
 866     if(ret == Ok){
 867         point->X = roundr(ptf.X);
 868         point->Y = roundr(ptf.Y);
 869     }
 870
 871     return ret;
 872 }
 873
 874 GpStatus WINGDIPAPI GdipGetPathGradientFocusScales(GpPathGradient *grad,
 875     REAL *x, REAL *y)
 876 {
 877     TRACE("(%p, %p, %p)\n", grad, x, y);
 878
 879     if(!grad || !x || !y)
 880         return InvalidParameter;
 881
 882     *x = grad->focus.X;
 883     *y = grad->focus.Y;
 884
 885     return Ok;
 886 }
 887
 888 GpStatus WINGDIPAPI GdipGetPathGradientGammaCorrection(GpPathGradient *grad,
 889     BOOL *gamma)
 890 {
 891     TRACE("(%p, %p)\n", grad, gamma);
 892
 893     if(!grad || !gamma)
 894         return InvalidParameter;
 895
 896     *gamma = grad->gamma;
 897
 898     return Ok;
 899 }
 900
 901 GpStatus WINGDIPAPI GdipGetPathGradientPointCount(GpPathGradient *grad,
 902     INT *count)
 903 {
 904     TRACE("(%p, %p)\n", grad, count);
 905
 906     if(!grad || !count)
 907         return InvalidParameter;
 908
 909     *count = grad->pathdata.Count;
 910
 911     return Ok;
 912 }
 913
 914 GpStatus WINGDIPAPI GdipGetPathGradientRect(GpPathGradient *brush, GpRectF *rect)
 915 {
 916     GpRectF r;
 917     GpPath* path;
 918     GpStatus stat;
 919
 920     TRACE("(%p, %p)\n", brush, rect);
 921
 922     if(!brush || !rect)
 923         return InvalidParameter;
 924
 925     stat = GdipCreatePath2(brush->pathdata.Points, brush->pathdata.Types,
 926                            brush->pathdata.Count, FillModeAlternate, &path);
 927     if(stat != Ok)  return stat;
 928
 929     stat = GdipGetPathWorldBounds(path, &r, NULL, NULL);
 930     if(stat != Ok){
 931         GdipDeletePath(path);
 932         return stat;
 933     }
 934
 935     memcpy(rect, &r, sizeof(GpRectF));
 936
 937     GdipDeletePath(path);
 938
 939     return Ok;
 940 }
 941
 942 GpStatus WINGDIPAPI GdipGetPathGradientRectI(GpPathGradient *brush, GpRect *rect)
 943 {
 944     GpRectF rectf;
 945     GpStatus stat;
 946
 947     TRACE("(%p, %p)\n", brush, rect);
 948
 949     if(!brush || !rect)
 950         return InvalidParameter;
 951
 952     stat = GdipGetPathGradientRect(brush, &rectf);
 953     if(stat != Ok)  return stat;
 954
 955     rect->X = roundr(rectf.X);
 956     rect->Y = roundr(rectf.Y);
 957     rect->Width  = roundr(rectf.Width);
 958     rect->Height = roundr(rectf.Height);
 959
 960     return Ok;
 961 }
 962
 963 GpStatus WINGDIPAPI GdipGetPathGradientSurroundColorsWithCount(GpPathGradient
 964     *grad, ARGB *argb, INT *count)
 965 {
 966     static int calls;
 967
 968     if(!grad || !argb || !count || (*count < grad->pathdata.Count))
 969         return InvalidParameter;
 970
 971     if(!(calls++))
 972         FIXME("not implemented\n");
 973
 974     return NotImplemented;
 975 }
 976
 977 GpStatus WINGDIPAPI GdipGetPathGradientWrapMode(GpPathGradient *brush,
 978     GpWrapMode *wrapmode)
 979 {
 980     TRACE("(%p, %p)\n", brush, wrapmode);
 981
 982     if(!brush || !wrapmode)
 983         return InvalidParameter;
 984
 985     *wrapmode = brush->wrap;
 986
 987     return Ok;
 988 }
 989
 990 GpStatus WINGDIPAPI GdipGetSolidFillColor(GpSolidFill *sf, ARGB *argb)
 991 {
 992     TRACE("(%p, %p)\n", sf, argb);
 993
 994     if(!sf || !argb)
 995         return InvalidParameter;
 996
 997     *argb = sf->color;
 998
 999     return Ok;
1000 }
1001
1002 /******************************************************************************
1003  * GdipGetTextureTransform [GDIPLUS.@]
1004  */
1005 GpStatus WINGDIPAPI GdipGetTextureTransform(GpTexture *brush, GpMatrix *matrix)
1006 {
1007     TRACE("(%p, %p)\n", brush, matrix);
1008
1009     if(!brush || !matrix)
1010         return InvalidParameter;
1011
1012     memcpy(matrix, brush->transform, sizeof(GpMatrix));
1013
1014     return Ok;
1015 }
1016
1017 /******************************************************************************
1018  * GdipGetTextureWrapMode [GDIPLUS.@]
1019  */
1020 GpStatus WINGDIPAPI GdipGetTextureWrapMode(GpTexture *brush, GpWrapMode *wrapmode)
1021 {
1022     TRACE("(%p, %p)\n", brush, wrapmode);
1023
1024     if(!brush || !wrapmode)
1025         return InvalidParameter;
1026
1027     *wrapmode = brush->wrap;
1028
1029     return Ok;
1030 }
1031
1032 /******************************************************************************
1033  * GdipMultiplyTextureTransform [GDIPLUS.@]
1034  */
1035 GpStatus WINGDIPAPI GdipMultiplyTextureTransform(GpTexture* brush,
1036     GDIPCONST GpMatrix *matrix, GpMatrixOrder order)
1037 {
1038     TRACE("(%p, %p, %d)\n", brush, matrix, order);
1039
1040     if(!brush || !matrix)
1041         return InvalidParameter;
1042
1043     return GdipMultiplyMatrix(brush->transform, matrix, order);
1044 }
1045
1046 /******************************************************************************
1047  * GdipResetTextureTransform [GDIPLUS.@]
1048  */
1049 GpStatus WINGDIPAPI GdipResetTextureTransform(GpTexture* brush)
1050 {
1051     TRACE("(%p)\n", brush);
1052
1053     if(!brush)
1054         return InvalidParameter;
1055
1056     return GdipSetMatrixElements(brush->transform, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0);
1057 }
1058
1059 /******************************************************************************
1060  * GdipScaleTextureTransform [GDIPLUS.@]
1061  */
1062 GpStatus WINGDIPAPI GdipScaleTextureTransform(GpTexture* brush,
1063     REAL sx, REAL sy, GpMatrixOrder order)
1064 {
1065     TRACE("(%p, %.2f, %.2f, %d)\n", brush, sx, sy, order);
1066
1067     if(!brush)
1068         return InvalidParameter;
1069
1070     return GdipScaleMatrix(brush->transform, sx, sy, order);
1071 }
1072
1073 GpStatus WINGDIPAPI GdipSetLineBlend(GpLineGradient *brush,
1074     GDIPCONST REAL *blend, GDIPCONST REAL* positions, INT count)
1075 {
1076     static int calls;
1077
1078     if(!brush || !blend || !positions || count <= 0)
1079         return InvalidParameter;
1080
1081     if(!(calls++))
1082         FIXME("not implemented\n");
1083
1084     return Ok;
1085 }
1086
1087 GpStatus WINGDIPAPI GdipSetLineGammaCorrection(GpLineGradient *line,
1088     BOOL usegamma)
1089 {
1090     TRACE("(%p, %d)\n", line, usegamma);
1091
1092     if(!line)
1093         return InvalidParameter;
1094
1095     line->gamma = usegamma;
1096
1097     return Ok;
1098 }
1099
1100 GpStatus WINGDIPAPI GdipSetLineSigmaBlend(GpLineGradient *line, REAL focus,
1101     REAL scale)
1102 {
1103     static int calls;
1104
1105     if(!line || focus < 0.0 || focus > 1.0 || scale < 0.0 || scale > 1.0)
1106         return InvalidParameter;
1107
1108     if(!(calls++))
1109         FIXME("not implemented\n");
1110
1111     return NotImplemented;
1112 }
1113
1114 GpStatus WINGDIPAPI GdipSetLineWrapMode(GpLineGradient *line,
1115     GpWrapMode wrap)
1116 {
1117     TRACE("(%p, %d)\n", line, wrap);
1118
1119     if(!line || wrap == WrapModeClamp)
1120         return InvalidParameter;
1121
1122     line->wrap = wrap;
1123
1124     return Ok;
1125 }
1126
1127 GpStatus WINGDIPAPI GdipSetPathGradientBlend(GpPathGradient *brush, GDIPCONST REAL *blend,
1128     GDIPCONST REAL *pos, INT count)
1129 {
1130     static int calls;
1131
1132     if(!(calls++))
1133         FIXME("not implemented\n");
1134
1135     return NotImplemented;
1136 }
1137
1138 GpStatus WINGDIPAPI GdipSetPathGradientCenterColor(GpPathGradient *grad,
1139     ARGB argb)
1140 {
1141     TRACE("(%p, %x)\n", grad, argb);
1142
1143     if(!grad)
1144         return InvalidParameter;
1145
1146     grad->centercolor = argb;
1147     grad->brush.lb.lbColor = ARGB2COLORREF(argb);
1148
1149     DeleteObject(grad->brush.gdibrush);
1150     grad->brush.gdibrush = CreateSolidBrush(grad->brush.lb.lbColor);
1151
1152     return Ok;
1153 }
1154
1155 GpStatus WINGDIPAPI GdipSetPathGradientCenterPoint(GpPathGradient *grad,
1156     GpPointF *point)
1157 {
1158     TRACE("(%p, %p)\n", grad, point);
1159
1160     if(!grad || !point)
1161         return InvalidParameter;
1162
1163     grad->center.X = point->X;
1164     grad->center.Y = point->Y;
1165
1166     return Ok;
1167 }
1168
1169 GpStatus WINGDIPAPI GdipSetPathGradientCenterPointI(GpPathGradient *grad,
1170     GpPoint *point)
1171 {
1172     GpPointF ptf;
1173
1174     TRACE("(%p, %p)\n", grad, point);
1175
1176     if(!point)
1177         return InvalidParameter;
1178
1179     ptf.X = (REAL)point->X;
1180     ptf.Y = (REAL)point->Y;
1181
1182     return GdipSetPathGradientCenterPoint(grad,&ptf);
1183 }
1184
1185 GpStatus WINGDIPAPI GdipSetPathGradientFocusScales(GpPathGradient *grad,
1186     REAL x, REAL y)
1187 {
1188     TRACE("(%p, %.2f, %.2f)\n", grad, x, y);
1189
1190     if(!grad)
1191         return InvalidParameter;
1192
1193     grad->focus.X = x;
1194     grad->focus.Y = y;
1195
1196     return Ok;
1197 }
1198
1199 GpStatus WINGDIPAPI GdipSetPathGradientGammaCorrection(GpPathGradient *grad,
1200     BOOL gamma)
1201 {
1202     TRACE("(%p, %d)\n", grad, gamma);
1203
1204     if(!grad)
1205         return InvalidParameter;
1206
1207     grad->gamma = gamma;
1208
1209     return Ok;
1210 }
1211
1212 GpStatus WINGDIPAPI GdipSetPathGradientSigmaBlend(GpPathGradient *grad,
1213     REAL focus, REAL scale)
1214 {
1215     static int calls;
1216
1217     if(!grad || focus < 0.0 || focus > 1.0 || scale < 0.0 || scale > 1.0)
1218         return InvalidParameter;
1219
1220     if(!(calls++))
1221         FIXME("not implemented\n");
1222
1223     return NotImplemented;
1224 }
1225
1226 GpStatus WINGDIPAPI GdipSetPathGradientSurroundColorsWithCount(GpPathGradient
1227     *grad, ARGB *argb, INT *count)
1228 {
1229     static int calls;
1230
1231     if(!grad || !argb || !count || (*count <= 0) ||
1232         (*count > grad->pathdata.Count))
1233         return InvalidParameter;
1234
1235     if(!(calls++))
1236         FIXME("not implemented\n");
1237
1238     return NotImplemented;
1239 }
1240
1241 GpStatus WINGDIPAPI GdipSetPathGradientWrapMode(GpPathGradient *grad,
1242     GpWrapMode wrap)
1243 {
1244     TRACE("(%p, %d)\n", grad, wrap);
1245
1246     if(!grad)
1247         return InvalidParameter;
1248
1249     grad->wrap = wrap;
1250
1251     return Ok;
1252 }
1253
1254 GpStatus WINGDIPAPI GdipSetSolidFillColor(GpSolidFill *sf, ARGB argb)
1255 {
1256     TRACE("(%p, %x)\n", sf, argb);
1257
1258     if(!sf)
1259         return InvalidParameter;
1260
1261     sf->color = argb;
1262     sf->brush.lb.lbColor = ARGB2COLORREF(argb);
1263
1264     DeleteObject(sf->brush.gdibrush);
1265     sf->brush.gdibrush = CreateSolidBrush(sf->brush.lb.lbColor);
1266
1267     return Ok;
1268 }
1269
1270 /******************************************************************************
1271  * GdipSetTextureTransform [GDIPLUS.@]
1272  */
1273 GpStatus WINGDIPAPI GdipSetTextureTransform(GpTexture *texture,
1274     GDIPCONST GpMatrix *matrix)
1275 {
1276     TRACE("(%p, %p)\n", texture, matrix);
1277
1278     if(!texture || !matrix)
1279         return InvalidParameter;
1280
1281     memcpy(texture->transform, matrix, sizeof(GpMatrix));
1282
1283     return Ok;
1284 }
1285
1286 /******************************************************************************
1287  * GdipSetTextureWrapMode [GDIPLUS.@]
1288  *
1289  * WrapMode not used, only stored
1290  */
1291 GpStatus WINGDIPAPI GdipSetTextureWrapMode(GpTexture *brush, GpWrapMode wrapmode)
1292 {
1293     TRACE("(%p, %d)\n", brush, wrapmode);
1294
1295     if(!brush)
1296         return InvalidParameter;
1297
1298     brush->wrap = wrapmode;
1299
1300     return Ok;
1301 }
1302
1303 GpStatus WINGDIPAPI GdipSetLineColors(GpLineGradient *brush, ARGB color1,
1304     ARGB color2)
1305 {
1306     TRACE("(%p, %x, %x)\n", brush, color1, color2);
1307
1308     if(!brush)
1309         return InvalidParameter;
1310
1311     brush->startcolor = color1;
1312     brush->endcolor   = color2;
1313
1314     return Ok;
1315 }
1316
1317 GpStatus WINGDIPAPI GdipGetLineColors(GpLineGradient *brush, ARGB *colors)
1318 {
1319     TRACE("(%p, %p)\n", brush, colors);
1320
1321     if(!brush || !colors)
1322         return InvalidParameter;
1323
1324     colors[0] = brush->startcolor;
1325     colors[1] = brush->endcolor;
1326
1327     return Ok;
1328 }
1329
1330 /******************************************************************************
1331  * GdipRotateTextureTransform [GDIPLUS.@]
1332  */
1333 GpStatus WINGDIPAPI GdipRotateTextureTransform(GpTexture* brush, REAL angle,
1334     GpMatrixOrder order)
1335 {
1336     TRACE("(%p, %.2f, %d)\n", brush, angle, order);
1337
1338     if(!brush)
1339         return InvalidParameter;
1340
1341     return GdipRotateMatrix(brush->transform, angle, order);
1342 }
1343
1344 GpStatus WINGDIPAPI GdipSetLineLinearBlend(GpLineGradient *brush, REAL focus,
1345     REAL scale)
1346 {
1347     static int calls;
1348
1349     if(!(calls++))
1350         FIXME("not implemented\n");
1351
1352     return NotImplemented;
1353 }
1354
1355 GpStatus WINGDIPAPI GdipSetLinePresetBlend(GpLineGradient *brush,
1356     GDIPCONST ARGB *blend, GDIPCONST REAL* positions, INT count)
1357 {
1358     static int calls;
1359
1360     if(!(calls++))
1361         FIXME("not implemented\n");
1362
1363     return NotImplemented;
1364 }
1365
1366 GpStatus WINGDIPAPI GdipSetLineTransform(GpLineGradient *brush,
1367     GDIPCONST GpMatrix *matrix)
1368 {
1369     static int calls;
1370
1371     if(!(calls++))
1372         FIXME("not implemented\n");
1373
1374     return NotImplemented;
1375 }
1376
1377 GpStatus WINGDIPAPI GdipTranslateLineTransform(GpLineGradient* brush,
1378         REAL dx, REAL dy, GpMatrixOrder order)
1379 {
1380     FIXME("stub: %p %f %f %d\n", brush, dx, dy, order);
1381
1382     return NotImplemented;
1383 }
1384
1385 /******************************************************************************
1386  * GdipTranslateTextureTransform [GDIPLUS.@]
1387  */
1388 GpStatus WINGDIPAPI GdipTranslateTextureTransform(GpTexture* brush, REAL dx, REAL dy,
1389     GpMatrixOrder order)
1390 {
1391     TRACE("(%p, %.2f, %.2f, %d)\n", brush, dx, dy, order);
1392
1393     if(!brush)
1394         return InvalidParameter;
1395
1396     return GdipTranslateMatrix(brush->transform, dx, dy, order);
1397 }
1398
1399 GpStatus WINGDIPAPI GdipGetLineRect(GpLineGradient *brush, GpRectF *rect)
1400 {
1401     TRACE("(%p, %p)\n", brush, rect);
1402
1403     if(!brush || !rect)
1404         return InvalidParameter;
1405
1406     rect->X = (brush->startpoint.X < brush->endpoint.X ? brush->startpoint.X: brush->endpoint.X);
1407     rect->Y = (brush->startpoint.Y < brush->endpoint.Y ? brush->startpoint.Y: brush->endpoint.Y);
1408
1409     rect->Width  = fabs(brush->startpoint.X - brush->endpoint.X);
1410     rect->Height = fabs(brush->startpoint.Y - brush->endpoint.Y);
1411
1412     return Ok;
1413 }
1414
1415 GpStatus WINGDIPAPI GdipGetLineRectI(GpLineGradient *brush, GpRect *rect)
1416 {
1417     GpRectF  rectF;
1418     GpStatus ret;
1419
1420     TRACE("(%p, %p)\n", brush, rect);
1421
1422     if(!rect)
1423         return InvalidParameter;
1424
1425     ret = GdipGetLineRect(brush, &rectF);
1426
1427     if(ret == Ok){
1428         rect->X      = roundr(rectF.X);
1429         rect->Y      = roundr(rectF.Y);
1430         rect->Width  = roundr(rectF.Width);
1431         rect->Height = roundr(rectF.Height);
1432     }
1433
1434     return ret;
1435 }
1436
1437 GpStatus WINGDIPAPI GdipRotateLineTransform(GpLineGradient* brush,
1438     REAL angle, GpMatrixOrder order)
1439 {
1440     static int calls;
1441
1442     if(!brush)
1443         return InvalidParameter;
1444
1445     if(!(calls++))
1446         FIXME("(%p, %.2f, %d) stub\n", brush, angle, order);
1447
1448     return NotImplemented;
1449 }