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 GpStatus WINGDIPAPI GdipCloneBrush(GpBrush *brush, GpBrush **clone)
  38 {
  39     if(!brush || !clone)
  40         return InvalidParameter;
  41
  42     switch(brush->bt){
  43         case BrushTypeSolidColor:
  44             *clone = GdipAlloc(sizeof(GpSolidFill));
  45             if (!*clone) return OutOfMemory;
  46
  47             memcpy(*clone, brush, sizeof(GpSolidFill));
  48
  49             (*clone)->gdibrush = CreateBrushIndirect(&(*clone)->lb);
  50             break;
  51         case BrushTypePathGradient:{
  52             GpPathGradient *src, *dest;
  53             INT count;
  54
  55             *clone = GdipAlloc(sizeof(GpPathGradient));
  56             if (!*clone) return OutOfMemory;
  57
  58             src = (GpPathGradient*) brush,
  59             dest = (GpPathGradient*) *clone;
  60             count = src->pathdata.Count;
  61
  62             memcpy(dest, src, sizeof(GpPathGradient));
  63
  64             dest->pathdata.Count = count;
  65             dest->pathdata.Points = GdipAlloc(count * sizeof(PointF));
  66             dest->pathdata.Types = GdipAlloc(count);
  67
  68             if(!dest->pathdata.Points || !dest->pathdata.Types){
  69                 GdipFree(dest->pathdata.Points);
  70                 GdipFree(dest->pathdata.Types);
  71                 GdipFree(dest);
  72                 return OutOfMemory;
  73             }
  74
  75             memcpy(dest->pathdata.Points, src->pathdata.Points, count * sizeof(PointF));
  76             memcpy(dest->pathdata.Types, src->pathdata.Types, count);
  77
  78             break;
  79         }
  80         case BrushTypeLinearGradient:
  81             *clone = GdipAlloc(sizeof(GpLineGradient));
  82             if(!*clone)    return OutOfMemory;
  83
  84             memcpy(*clone, brush, sizeof(GpLineGradient));
  85
  86             (*clone)->gdibrush = CreateSolidBrush((*clone)->lb.lbColor);
  87             break;
  88         case BrushTypeTextureFill:
  89             *clone = GdipAlloc(sizeof(GpTexture));
  90             if(!*clone)    return OutOfMemory;
  91
  92             memcpy(*clone, brush, sizeof(GpTexture));
  93
  94             (*clone)->gdibrush = CreateBrushIndirect(&(*clone)->lb);
  95             break;
  96         default:
  97             ERR("not implemented for brush type %d\n", brush->bt);
  98             return NotImplemented;
  99     }
 100
 101     return Ok;
 102 }
 103
 104 GpStatus WINGDIPAPI GdipCreateLineBrush(GDIPCONST GpPointF* startpoint,
 105     GDIPCONST GpPointF* endpoint, ARGB startcolor, ARGB endcolor,
 106     GpWrapMode wrap, GpLineGradient **line)
 107 {
 108     COLORREF col = ARGB2COLORREF(startcolor);
 109
 110     if(!line || !startpoint || !endpoint || wrap == WrapModeClamp)
 111         return InvalidParameter;
 112
 113     *line = GdipAlloc(sizeof(GpLineGradient));
 114     if(!*line)  return OutOfMemory;
 115
 116     (*line)->brush.lb.lbStyle = BS_SOLID;
 117     (*line)->brush.lb.lbColor = col;
 118     (*line)->brush.lb.lbHatch = 0;
 119     (*line)->brush.gdibrush = CreateSolidBrush(col);
 120     (*line)->brush.bt = BrushTypeLinearGradient;
 121
 122     (*line)->startpoint.X = startpoint->X;
 123     (*line)->startpoint.Y = startpoint->Y;
 124     (*line)->endpoint.X = endpoint->X;
 125     (*line)->endpoint.Y = endpoint->Y;
 126     (*line)->startcolor = startcolor;
 127     (*line)->endcolor = endcolor;
 128     (*line)->wrap = wrap;
 129     (*line)->gamma = FALSE;
 130
 131     return Ok;
 132 }
 133
 134 GpStatus WINGDIPAPI GdipCreateLineBrushI(GDIPCONST GpPoint* startpoint,
 135     GDIPCONST GpPoint* endpoint, ARGB startcolor, ARGB endcolor,
 136     GpWrapMode wrap, GpLineGradient **line)
 137 {
 138     GpPointF stF;
 139     GpPointF endF;
 140
 141     if(!startpoint || !endpoint)
 142         return InvalidParameter;
 143
 144     stF.X  = (REAL)startpoint->X;
 145     stF.Y  = (REAL)startpoint->Y;
 146     endF.X = (REAL)endpoint->X;
 147     endF.X = (REAL)endpoint->Y;
 148
 149     return GdipCreateLineBrush(&stF, &endF, startcolor, endcolor, wrap, line);
 150 }
 151
 152 GpStatus WINGDIPAPI GdipCreateLineBrushFromRect(GDIPCONST GpRectF* rect,
 153     ARGB startcolor, ARGB endcolor, LinearGradientMode mode, GpWrapMode wrap,
 154     GpLineGradient **line)
 155 {
 156     GpPointF start, end;
 157
 158     if(!line || !rect)
 159         return InvalidParameter;
 160
 161     start.X = rect->X;
 162     start.Y = rect->Y;
 163     end.X = rect->X + rect->Width;
 164     end.Y = rect->Y + rect->Height;
 165
 166     return GdipCreateLineBrush(&start, &end, startcolor, endcolor, wrap, line);
 167 }
 168
 169 GpStatus WINGDIPAPI GdipCreateLineBrushFromRectI(GDIPCONST GpRect* rect,
 170     ARGB startcolor, ARGB endcolor, LinearGradientMode mode, GpWrapMode wrap,
 171     GpLineGradient **line)
 172 {
 173     GpRectF rectF;
 174
 175     rectF.X      = (REAL) rect->X;
 176     rectF.Y      = (REAL) rect->Y;
 177     rectF.Width  = (REAL) rect->Width;
 178     rectF.Height = (REAL) rect->Height;
 179
 180     return GdipCreateLineBrushFromRect(&rectF, startcolor, endcolor, mode, wrap, line);
 181 }
 182
 183 /* FIXME: angle value completely ignored. Don't know how to use it since native
 184           always set Brush rectangle to rect (independetly of this angle).
 185           Maybe it's used only on drawing.  */
 186 GpStatus WINGDIPAPI GdipCreateLineBrushFromRectWithAngle(GDIPCONST GpRectF* rect,
 187     ARGB startcolor, ARGB endcolor, REAL angle, BOOL isAngleScalable, GpWrapMode wrap,
 188     GpLineGradient **line)
 189 {
 190     return GdipCreateLineBrushFromRect(rect, startcolor, endcolor, LinearGradientModeForwardDiagonal,
 191                                        wrap, line);
 192 }
 193
 194 GpStatus WINGDIPAPI GdipCreateLineBrushFromRectWithAngleI(GDIPCONST GpRect* rect,
 195     ARGB startcolor, ARGB endcolor, REAL angle, BOOL isAngleScalable, GpWrapMode wrap,
 196     GpLineGradient **line)
 197 {
 198     return GdipCreateLineBrushFromRectI(rect, startcolor, endcolor, LinearGradientModeForwardDiagonal,
 199                                         wrap, line);
 200 }
 201
 202 GpStatus WINGDIPAPI GdipCreatePathGradient(GDIPCONST GpPointF* points,
 203     INT count, GpWrapMode wrap, GpPathGradient **grad)
 204 {
 205     COLORREF col = ARGB2COLORREF(0xffffffff);
 206
 207     if(!points || !grad)
 208         return InvalidParameter;
 209
 210     if(count <= 0)
 211         return OutOfMemory;
 212
 213     *grad = GdipAlloc(sizeof(GpPathGradient));
 214     if (!*grad) return OutOfMemory;
 215
 216     (*grad)->pathdata.Count = count;
 217     (*grad)->pathdata.Points = GdipAlloc(count * sizeof(PointF));
 218     (*grad)->pathdata.Types = GdipAlloc(count);
 219
 220     if(!(*grad)->pathdata.Points || !(*grad)->pathdata.Types){
 221         GdipFree((*grad)->pathdata.Points);
 222         GdipFree((*grad)->pathdata.Types);
 223         GdipFree(*grad);
 224         return OutOfMemory;
 225     }
 226
 227     memcpy((*grad)->pathdata.Points, points, count * sizeof(PointF));
 228     memset((*grad)->pathdata.Types, PathPointTypeLine, count);
 229
 230     (*grad)->brush.lb.lbStyle = BS_SOLID;
 231     (*grad)->brush.lb.lbColor = col;
 232     (*grad)->brush.lb.lbHatch = 0;
 233
 234     (*grad)->brush.gdibrush = CreateSolidBrush(col);
 235     (*grad)->brush.bt = BrushTypePathGradient;
 236     (*grad)->centercolor = 0xffffffff;
 237     (*grad)->wrap = wrap;
 238     (*grad)->gamma = FALSE;
 239     (*grad)->center.X = 0.0;
 240     (*grad)->center.Y = 0.0;
 241     (*grad)->focus.X = 0.0;
 242     (*grad)->focus.Y = 0.0;
 243
 244     return Ok;
 245 }
 246
 247 GpStatus WINGDIPAPI GdipCreatePathGradientI(GDIPCONST GpPoint* points,
 248     INT count, GpWrapMode wrap, GpPathGradient **grad)
 249 {
 250     GpPointF *pointsF;
 251     GpStatus ret;
 252     INT i;
 253
 254     if(!points || !grad)
 255         return InvalidParameter;
 256
 257     if(count <= 0)
 258         return OutOfMemory;
 259
 260     pointsF = GdipAlloc(sizeof(GpPointF) * count);
 261     if(!pointsF)
 262         return OutOfMemory;
 263
 264     for(i = 0; i < count; i++){
 265         pointsF[i].X = (REAL)points[i].X;
 266         pointsF[i].Y = (REAL)points[i].Y;
 267     }
 268
 269     ret = GdipCreatePathGradient(pointsF, count, wrap, grad);
 270     GdipFree(pointsF);
 271
 272     return ret;
 273 }
 274
 275 /* FIXME: path gradient brushes not truly supported (drawn as solid brushes) */
 276 GpStatus WINGDIPAPI GdipCreatePathGradientFromPath(GDIPCONST GpPath* path,
 277     GpPathGradient **grad)
 278 {
 279     COLORREF col = ARGB2COLORREF(0xffffffff);
 280
 281     if(!path || !grad)
 282         return InvalidParameter;
 283
 284     *grad = GdipAlloc(sizeof(GpPathGradient));
 285     if (!*grad) return OutOfMemory;
 286
 287     (*grad)->pathdata.Count = path->pathdata.Count;
 288     (*grad)->pathdata.Points = GdipAlloc(path->pathdata.Count * sizeof(PointF));
 289     (*grad)->pathdata.Types = GdipAlloc(path->pathdata.Count);
 290
 291     if(!(*grad)->pathdata.Points || !(*grad)->pathdata.Types){
 292         GdipFree((*grad)->pathdata.Points);
 293         GdipFree((*grad)->pathdata.Types);
 294         GdipFree(*grad);
 295         return OutOfMemory;
 296     }
 297
 298     memcpy((*grad)->pathdata.Points, path->pathdata.Points,
 299            path->pathdata.Count * sizeof(PointF));
 300     memcpy((*grad)->pathdata.Types, path->pathdata.Types, path->pathdata.Count);
 301
 302     (*grad)->brush.lb.lbStyle = BS_SOLID;
 303     (*grad)->brush.lb.lbColor = col;
 304     (*grad)->brush.lb.lbHatch = 0;
 305
 306     (*grad)->brush.gdibrush = CreateSolidBrush(col);
 307     (*grad)->brush.bt = BrushTypePathGradient;
 308     (*grad)->centercolor = 0xffffffff;
 309     (*grad)->wrap = WrapModeClamp;
 310     (*grad)->gamma = FALSE;
 311     /* FIXME: this should be set to the "centroid" of the path by default */
 312     (*grad)->center.X = 0.0;
 313     (*grad)->center.Y = 0.0;
 314     (*grad)->focus.X = 0.0;
 315     (*grad)->focus.Y = 0.0;
 316
 317     return Ok;
 318 }
 319
 320 GpStatus WINGDIPAPI GdipCreateSolidFill(ARGB color, GpSolidFill **sf)
 321 {
 322     COLORREF col = ARGB2COLORREF(color);
 323
 324     if(!sf)  return InvalidParameter;
 325
 326     *sf = GdipAlloc(sizeof(GpSolidFill));
 327     if (!*sf) return OutOfMemory;
 328
 329     (*sf)->brush.lb.lbStyle = BS_SOLID;
 330     (*sf)->brush.lb.lbColor = col;
 331     (*sf)->brush.lb.lbHatch = 0;
 332
 333     (*sf)->brush.gdibrush = CreateSolidBrush(col);
 334     (*sf)->brush.bt = BrushTypeSolidColor;
 335     (*sf)->color = color;
 336
 337     return Ok;
 338 }
 339
 340 /* FIXME: imageattr ignored */
 341 GpStatus WINGDIPAPI GdipCreateTextureIA(GpImage *image,
 342     GDIPCONST GpImageAttributes *imageattr, REAL x, REAL y, REAL width,
 343     REAL height, GpTexture **texture)
 344 {
 345     HDC hdc;
 346     OLE_HANDLE hbm;
 347     HBITMAP old = NULL;
 348     BITMAPINFO bmi;
 349     BITMAPINFOHEADER *bmih;
 350     INT n_x, n_y, n_width, n_height, abs_height, stride, image_stride, i, bytespp;
 351     BOOL bm_is_selected;
 352     BYTE *dibits, *buff, *textbits;
 353
 354     if(!image || !texture || x < 0.0 || y < 0.0 || width < 0.0 || height < 0.0)
 355         return InvalidParameter;
 356
 357     if(image->type != ImageTypeBitmap){
 358         FIXME("not implemented for image type %d\n", image->type);
 359         return NotImplemented;
 360     }
 361
 362     n_x = roundr(x);
 363     n_y = roundr(y);
 364     n_width = roundr(width);
 365     n_height = roundr(height);
 366
 367     if(n_x + n_width > ((GpBitmap*)image)->width ||
 368        n_y + n_height > ((GpBitmap*)image)->height)
 369         return InvalidParameter;
 370
 371     IPicture_get_Handle(image->picture, &hbm);
 372     if(!hbm)   return GenericError;
 373     IPicture_get_CurDC(image->picture, &hdc);
 374     bm_is_selected = (hdc != 0);
 375
 376     bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
 377     bmi.bmiHeader.biBitCount = 0;
 378
 379     if(!bm_is_selected){
 380         hdc = CreateCompatibleDC(0);
 381         old = SelectObject(hdc, (HBITMAP)hbm);
 382     }
 383
 384     /* fill out bmi */
 385     GetDIBits(hdc, (HBITMAP)hbm, 0, 0, NULL, &bmi, DIB_RGB_COLORS);
 386
 387     bytespp = bmi.bmiHeader.biBitCount / 8;
 388     abs_height = abs(bmi.bmiHeader.biHeight);
 389
 390     if(n_x > bmi.bmiHeader.biWidth || n_x + n_width > bmi.bmiHeader.biWidth ||
 391        n_y > abs_height || n_y + n_height > abs_height)
 392         return InvalidParameter;
 393
 394     dibits = GdipAlloc(bmi.bmiHeader.biSizeImage);
 395
 396     if(dibits)  /* this is not a good place to error out */
 397         GetDIBits(hdc, (HBITMAP)hbm, 0, abs_height, dibits, &bmi, DIB_RGB_COLORS);
 398
 399     if(!bm_is_selected){
 400         SelectObject(hdc, old);
 401         DeleteDC(hdc);
 402     }
 403
 404     if(!dibits)
 405         return OutOfMemory;
 406
 407     image_stride = (bmi.bmiHeader.biWidth * bytespp + 3) & ~3;
 408     stride = (n_width * bytespp + 3) & ~3;
 409     buff = GdipAlloc(sizeof(BITMAPINFOHEADER) + stride * n_height);
 410     if(!buff){
 411         GdipFree(dibits);
 412         return OutOfMemory;
 413     }
 414
 415     bmih = (BITMAPINFOHEADER*)buff;
 416     textbits = (BYTE*) (bmih + 1);
 417     bmih->biSize = sizeof(BITMAPINFOHEADER);
 418     bmih->biWidth = n_width;
 419     bmih->biHeight = n_height;
 420     bmih->biCompression = BI_RGB;
 421     bmih->biSizeImage = stride * n_height;
 422     bmih->biBitCount = bmi.bmiHeader.biBitCount;
 423     bmih->biClrUsed = 0;
 424     bmih->biPlanes = 1;
 425
 426     /* image is flipped */
 427     if(bmi.bmiHeader.biHeight > 0){
 428         dibits += bmi.bmiHeader.biSizeImage;
 429         image_stride *= -1;
 430         textbits += stride * (n_height - 1);
 431         stride *= -1;
 432     }
 433
 434     for(i = 0; i < n_height; i++)
 435         memcpy(&textbits[i * stride],
 436                &dibits[n_x * bytespp + (n_y + i) * image_stride],
 437                abs(stride));
 438
 439     *texture = GdipAlloc(sizeof(GpTexture));
 440     if (!*texture) return OutOfMemory;
 441
 442     (*texture)->brush.lb.lbStyle = BS_DIBPATTERNPT;
 443     (*texture)->brush.lb.lbColor = DIB_RGB_COLORS;
 444     (*texture)->brush.lb.lbHatch = (ULONG_PTR)buff;
 445
 446     (*texture)->brush.gdibrush = CreateBrushIndirect(&(*texture)->brush.lb);
 447     (*texture)->brush.bt = BrushTypeTextureFill;
 448
 449     GdipFree(dibits);
 450     GdipFree(buff);
 451
 452     return Ok;
 453 }
 454
 455 GpStatus WINGDIPAPI GdipCreateTextureIAI(GpImage *image, GDIPCONST GpImageAttributes *imageattr,
 456     INT x, INT y, INT width, INT height, GpTexture **texture)
 457 {
 458     return GdipCreateTextureIA(image,imageattr,(REAL)x,(REAL)y,(REAL)width,(REAL)height,texture);
 459 }
 460
 461 GpStatus WINGDIPAPI GdipGetBrushType(GpBrush *brush, GpBrushType *type)
 462 {
 463     if(!brush || !type)  return InvalidParameter;
 464
 465     *type = brush->bt;
 466
 467     return Ok;
 468 }
 469
 470 GpStatus WINGDIPAPI GdipDeleteBrush(GpBrush *brush)
 471 {
 472     if(!brush)  return InvalidParameter;
 473
 474     switch(brush->bt)
 475     {
 476         case BrushTypePathGradient:
 477             GdipFree(((GpPathGradient*) brush)->pathdata.Points);
 478             GdipFree(((GpPathGradient*) brush)->pathdata.Types);
 479             break;
 480         case BrushTypeSolidColor:
 481         case BrushTypeLinearGradient:
 482         case BrushTypeTextureFill:
 483         default:
 484             break;
 485     }
 486
 487     DeleteObject(brush->gdibrush);
 488     GdipFree(brush);
 489
 490     return Ok;
 491 }
 492
 493 GpStatus WINGDIPAPI GdipGetLineGammaCorrection(GpLineGradient *line,
 494     BOOL *usinggamma)
 495 {
 496     if(!line)
 497         return InvalidParameter;
 498
 499     *usinggamma = line->gamma;
 500
 501     return Ok;
 502 }
 503
 504 GpStatus WINGDIPAPI GdipGetLineWrapMode(GpLineGradient *brush, GpWrapMode *wrapmode)
 505 {
 506     if(!brush || !wrapmode)
 507         return InvalidParameter;
 508
 509     *wrapmode = brush->wrap;
 510
 511     return Ok;
 512 }
 513
 514 GpStatus WINGDIPAPI GdipGetPathGradientCenterPoint(GpPathGradient *grad,
 515     GpPointF *point)
 516 {
 517     if(!grad || !point)
 518         return InvalidParameter;
 519
 520     point->X = grad->center.X;
 521     point->Y = grad->center.Y;
 522
 523     return Ok;
 524 }
 525
 526 GpStatus WINGDIPAPI GdipGetPathGradientCenterPointI(GpPathGradient *grad,
 527     GpPoint *point)
 528 {
 529     GpStatus ret;
 530     GpPointF ptf;
 531
 532     if(!point)
 533         return InvalidParameter;
 534
 535     ret = GdipGetPathGradientCenterPoint(grad,&ptf);
 536
 537     if(ret == Ok){
 538         point->X = roundr(ptf.X);
 539         point->Y = roundr(ptf.Y);
 540     }
 541
 542     return ret;
 543 }
 544
 545 GpStatus WINGDIPAPI GdipGetPathGradientFocusScales(GpPathGradient *grad,
 546     REAL *x, REAL *y)
 547 {
 548     if(!grad || !x || !y)
 549         return InvalidParameter;
 550
 551     *x = grad->focus.X;
 552     *y = grad->focus.Y;
 553
 554     return Ok;
 555 }
 556
 557 GpStatus WINGDIPAPI GdipGetPathGradientGammaCorrection(GpPathGradient *grad,
 558     BOOL *gamma)
 559 {
 560     if(!grad || !gamma)
 561         return InvalidParameter;
 562
 563     *gamma = grad->gamma;
 564
 565     return Ok;
 566 }
 567
 568 GpStatus WINGDIPAPI GdipGetPathGradientPointCount(GpPathGradient *grad,
 569     INT *count)
 570 {
 571     if(!grad || !count)
 572         return InvalidParameter;
 573
 574     *count = grad->pathdata.Count;
 575
 576     return Ok;
 577 }
 578
 579 GpStatus WINGDIPAPI GdipGetPathGradientSurroundColorsWithCount(GpPathGradient
 580     *grad, ARGB *argb, INT *count)
 581 {
 582     static int calls;
 583
 584     if(!grad || !argb || !count || (*count < grad->pathdata.Count))
 585         return InvalidParameter;
 586
 587     if(!(calls++))
 588         FIXME("not implemented\n");
 589
 590     return NotImplemented;
 591 }
 592
 593 GpStatus WINGDIPAPI GdipGetPathGradientWrapMode(GpPathGradient *brush,
 594     GpWrapMode *wrapmode)
 595 {
 596     if(!brush || !wrapmode)
 597         return InvalidParameter;
 598
 599     *wrapmode = brush->wrap;
 600
 601     return Ok;
 602 }
 603
 604 GpStatus WINGDIPAPI GdipGetSolidFillColor(GpSolidFill *sf, ARGB *argb)
 605 {
 606     if(!sf || !argb)
 607         return InvalidParameter;
 608
 609     *argb = sf->color;
 610
 611     return Ok;
 612 }
 613
 614 GpStatus WINGDIPAPI GdipSetLineBlend(GpLineGradient *brush,
 615     GDIPCONST REAL *blend, GDIPCONST REAL* positions, INT count)
 616 {
 617     static int calls;
 618
 619     if(!brush || !blend || !positions || count <= 0)
 620         return InvalidParameter;
 621
 622     if(!(calls++))
 623         FIXME("not implemented\n");
 624
 625     return Ok;
 626 }
 627
 628 GpStatus WINGDIPAPI GdipSetLineGammaCorrection(GpLineGradient *line,
 629     BOOL usegamma)
 630 {
 631     if(!line)
 632         return InvalidParameter;
 633
 634     line->gamma = usegamma;
 635
 636     return Ok;
 637 }
 638
 639 GpStatus WINGDIPAPI GdipSetLineSigmaBlend(GpLineGradient *line, REAL focus,
 640     REAL scale)
 641 {
 642     static int calls;
 643
 644     if(!line || focus < 0.0 || focus > 1.0 || scale < 0.0 || scale > 1.0)
 645         return InvalidParameter;
 646
 647     if(!(calls++))
 648         FIXME("not implemented\n");
 649
 650     return NotImplemented;
 651 }
 652
 653 GpStatus WINGDIPAPI GdipSetLineWrapMode(GpLineGradient *line,
 654     GpWrapMode wrap)
 655 {
 656     if(!line || wrap == WrapModeClamp)
 657         return InvalidParameter;
 658
 659     line->wrap = wrap;
 660
 661     return Ok;
 662 }
 663
 664 GpStatus WINGDIPAPI GdipSetPathGradientCenterColor(GpPathGradient *grad,
 665     ARGB argb)
 666 {
 667     if(!grad)
 668         return InvalidParameter;
 669
 670     grad->centercolor = argb;
 671     grad->brush.lb.lbColor = ARGB2COLORREF(argb);
 672
 673     DeleteObject(grad->brush.gdibrush);
 674     grad->brush.gdibrush = CreateSolidBrush(grad->brush.lb.lbColor);
 675
 676     return Ok;
 677 }
 678
 679 GpStatus WINGDIPAPI GdipSetPathGradientCenterPoint(GpPathGradient *grad,
 680     GpPointF *point)
 681 {
 682     if(!grad || !point)
 683         return InvalidParameter;
 684
 685     grad->center.X = point->X;
 686     grad->center.Y = point->Y;
 687
 688     return Ok;
 689 }
 690
 691 GpStatus WINGDIPAPI GdipSetPathGradientCenterPointI(GpPathGradient *grad,
 692     GpPoint *point)
 693 {
 694     GpPointF ptf;
 695
 696     if(!point)
 697         return InvalidParameter;
 698
 699     ptf.X = (REAL)point->X;
 700     ptf.Y = (REAL)point->Y;
 701
 702     return GdipSetPathGradientCenterPoint(grad,&ptf);
 703 }
 704
 705 GpStatus WINGDIPAPI GdipSetPathGradientFocusScales(GpPathGradient *grad,
 706     REAL x, REAL y)
 707 {
 708     if(!grad)
 709         return InvalidParameter;
 710
 711     grad->focus.X = x;
 712     grad->focus.Y = y;
 713
 714     return Ok;
 715 }
 716
 717 GpStatus WINGDIPAPI GdipSetPathGradientGammaCorrection(GpPathGradient *grad,
 718     BOOL gamma)
 719 {
 720     if(!grad)
 721         return InvalidParameter;
 722
 723     grad->gamma = gamma;
 724
 725     return Ok;
 726 }
 727
 728 GpStatus WINGDIPAPI GdipSetPathGradientSigmaBlend(GpPathGradient *grad,
 729     REAL focus, REAL scale)
 730 {
 731     static int calls;
 732
 733     if(!grad || focus < 0.0 || focus > 1.0 || scale < 0.0 || scale > 1.0)
 734         return InvalidParameter;
 735
 736     if(!(calls++))
 737         FIXME("not implemented\n");
 738
 739     return NotImplemented;
 740 }
 741
 742 GpStatus WINGDIPAPI GdipSetPathGradientSurroundColorsWithCount(GpPathGradient
 743     *grad, ARGB *argb, INT *count)
 744 {
 745     static int calls;
 746
 747     if(!grad || !argb || !count || (*count <= 0) ||
 748         (*count > grad->pathdata.Count))
 749         return InvalidParameter;
 750
 751     if(!(calls++))
 752         FIXME("not implemented\n");
 753
 754     return NotImplemented;
 755 }
 756
 757 GpStatus WINGDIPAPI GdipSetPathGradientWrapMode(GpPathGradient *grad,
 758     GpWrapMode wrap)
 759 {
 760     if(!grad)
 761         return InvalidParameter;
 762
 763     grad->wrap = wrap;
 764
 765     return Ok;
 766 }
 767
 768 GpStatus WINGDIPAPI GdipSetSolidFillColor(GpSolidFill *sf, ARGB argb)
 769 {
 770     if(!sf)
 771         return InvalidParameter;
 772
 773     sf->color = argb;
 774     sf->brush.lb.lbColor = ARGB2COLORREF(argb);
 775
 776     DeleteObject(sf->brush.gdibrush);
 777     sf->brush.gdibrush = CreateSolidBrush(sf->brush.lb.lbColor);
 778
 779     return Ok;
 780 }
 781
 782 GpStatus WINGDIPAPI GdipSetTextureTransform(GpTexture *texture,
 783     GDIPCONST GpMatrix *matrix)
 784 {
 785     static int calls;
 786
 787     if(!texture || !matrix)
 788         return InvalidParameter;
 789
 790     if(!(calls++))
 791         FIXME("not implemented\n");
 792
 793     return Ok;
 794 }
 795
 796 GpStatus WINGDIPAPI GdipSetLineColors(GpLineGradient *brush, ARGB color1,
 797     ARGB color2)
 798 {
 799     if(!brush)
 800         return InvalidParameter;
 801
 802     brush->startcolor = color1;
 803     brush->endcolor   = color2;
 804
 805     return Ok;
 806 }
 807
 808 GpStatus WINGDIPAPI GdipGetLineColors(GpLineGradient *brush, ARGB *colors)
 809 {
 810     if(!brush || !colors)
 811         return InvalidParameter;
 812
 813     colors[0] = brush->startcolor;
 814     colors[1] = brush->endcolor;
 815
 816     return Ok;
 817 }
 818
 819 GpStatus WINGDIPAPI GdipSetLineLinearBlend(GpLineGradient *brush, REAL focus,
 820     REAL scale)
 821 {
 822     static int calls;
 823
 824     if(!(calls++))
 825         FIXME("not implemented\n");
 826
 827     return NotImplemented;
 828 }
 829
 830 GpStatus WINGDIPAPI GdipSetLinePresetBlend(GpLineGradient *brush,
 831     GDIPCONST ARGB *blend, GDIPCONST REAL* positions, INT count)
 832 {
 833     static int calls;
 834
 835     if(!(calls++))
 836         FIXME("not implemented\n");
 837
 838     return NotImplemented;
 839 }
 840
 841 GpStatus WINGDIPAPI GdipSetLineTransform(GpLineGradient *brush,
 842     GDIPCONST GpMatrix *matrix)
 843 {
 844     static int calls;
 845
 846     if(!(calls++))
 847         FIXME("not implemented\n");
 848
 849     return NotImplemented;
 850 }
 851
 852 GpStatus WINGDIPAPI GdipGetLineRect(GpLineGradient *brush, GpRectF *rect)
 853 {
 854     if(!brush || !rect)
 855         return InvalidParameter;
 856
 857     rect->X = (brush->startpoint.X < brush->endpoint.X ? brush->startpoint.X: brush->endpoint.X);
 858     rect->Y = (brush->startpoint.Y < brush->endpoint.Y ? brush->startpoint.Y: brush->endpoint.Y);
 859
 860     rect->Width  = fabs(brush->startpoint.X - brush->endpoint.X);
 861     rect->Height = fabs(brush->startpoint.Y - brush->endpoint.Y);
 862
 863     return Ok;
 864 }
 865
 866 GpStatus WINGDIPAPI GdipGetLineRectI(GpLineGradient *brush, GpRect *rect)
 867 {
 868     GpRectF  rectF;
 869     GpStatus ret;
 870
 871     if(!rect)
 872         return InvalidParameter;
 873
 874     ret = GdipGetLineRect(brush, &rectF);
 875
 876     if(ret == Ok){
 877         rect->X      = roundr(rectF.X);
 878         rect->Y      = roundr(rectF.Y);
 879         rect->Width  = roundr(rectF.Width);
 880         rect->Height = roundr(rectF.Height);
 881     }
 882
 883     return ret;
 884 }