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