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 GpStatus WINGDIPAPI GdipCloneBrush(GpBrush *brush, GpBrush **clone)
  38 {
  39     TRACE("(%p, %p)\n", brush, clone);
  40
  41     if(!brush || !clone)
  42         return InvalidParameter;
  43
  44     switch(brush->bt){
  45         case BrushTypeSolidColor:
  46             *clone = GdipAlloc(sizeof(GpSolidFill));
  47             if (!*clone) return OutOfMemory;
  48
  49             memcpy(*clone, brush, sizeof(GpSolidFill));
  50
  51             (*clone)->gdibrush = CreateBrushIndirect(&(*clone)->lb);
  52             break;
  53         case BrushTypePathGradient:{
  54             GpPathGradient *src, *dest;
  55             INT count;
  56
  57             *clone = GdipAlloc(sizeof(GpPathGradient));
  58             if (!*clone) return OutOfMemory;
  59
  60             src = (GpPathGradient*) brush,
  61             dest = (GpPathGradient*) *clone;
  62             count = src->pathdata.Count;
  63
  64             memcpy(dest, src, sizeof(GpPathGradient));
  65
  66             dest->pathdata.Count = count;
  67             dest->pathdata.Points = GdipAlloc(count * sizeof(PointF));
  68             dest->pathdata.Types = GdipAlloc(count);
  69
  70             if(!dest->pathdata.Points || !dest->pathdata.Types){
  71                 GdipFree(dest->pathdata.Points);
  72                 GdipFree(dest->pathdata.Types);
  73                 GdipFree(dest);
  74                 return OutOfMemory;
  75             }
  76
  77             memcpy(dest->pathdata.Points, src->pathdata.Points, count * sizeof(PointF));
  78             memcpy(dest->pathdata.Types, src->pathdata.Types, count);
  79
  80             /* blending */
  81             count = src->blendcount;
  82             dest->blendcount = count;
  83             dest->blendfac = GdipAlloc(count * sizeof(REAL));
  84             dest->blendpos = GdipAlloc(count * sizeof(REAL));
  85
  86             if(!dest->blendfac || !dest->blendpos){
  87                 GdipFree(dest->pathdata.Points);
  88                 GdipFree(dest->pathdata.Types);
  89                 GdipFree(dest->blendfac);
  90                 GdipFree(dest->blendpos);
  91                 GdipFree(dest);
  92                 return OutOfMemory;
  93             }
  94
  95             memcpy(dest->blendfac, src->blendfac, count * sizeof(REAL));
  96             memcpy(dest->blendpos, src->blendpos, count * sizeof(REAL));
  97
  98             break;
  99         }
 100         case BrushTypeLinearGradient:
 101             *clone = GdipAlloc(sizeof(GpLineGradient));
 102             if(!*clone)    return OutOfMemory;
 103
 104             memcpy(*clone, brush, sizeof(GpLineGradient));
 105
 106             (*clone)->gdibrush = CreateSolidBrush((*clone)->lb.lbColor);
 107             break;
 108         case BrushTypeTextureFill:
 109             *clone = GdipAlloc(sizeof(GpTexture));
 110             if(!*clone)    return OutOfMemory;
 111
 112             memcpy(*clone, brush, sizeof(GpTexture));
 113
 114             (*clone)->gdibrush = CreateBrushIndirect(&(*clone)->lb);
 115             break;
 116         default:
 117             ERR("not implemented for brush type %d\n", brush->bt);
 118             return NotImplemented;
 119     }
 120
 121     return Ok;
 122 }
 123
 124 GpStatus WINGDIPAPI GdipCreateLineBrush(GDIPCONST GpPointF* startpoint,
 125     GDIPCONST GpPointF* endpoint, ARGB startcolor, ARGB endcolor,
 126     GpWrapMode wrap, GpLineGradient **line)
 127 {
 128     COLORREF col = ARGB2COLORREF(startcolor);
 129
 130     TRACE("(%p, %p, %x, %x, %d, %p)\n", startpoint, endpoint,
 131           startcolor, endcolor, wrap, line);
 132
 133     if(!line || !startpoint || !endpoint || wrap == WrapModeClamp)
 134         return InvalidParameter;
 135
 136     *line = GdipAlloc(sizeof(GpLineGradient));
 137     if(!*line)  return OutOfMemory;
 138
 139     (*line)->brush.lb.lbStyle = BS_SOLID;
 140     (*line)->brush.lb.lbColor = col;
 141     (*line)->brush.lb.lbHatch = 0;
 142     (*line)->brush.gdibrush = CreateSolidBrush(col);
 143     (*line)->brush.bt = BrushTypeLinearGradient;
 144
 145     (*line)->startpoint.X = startpoint->X;
 146     (*line)->startpoint.Y = startpoint->Y;
 147     (*line)->endpoint.X = endpoint->X;
 148     (*line)->endpoint.Y = endpoint->Y;
 149     (*line)->startcolor = startcolor;
 150     (*line)->endcolor = endcolor;
 151     (*line)->wrap = wrap;
 152     (*line)->gamma = FALSE;
 153
 154     return Ok;
 155 }
 156
 157 GpStatus WINGDIPAPI GdipCreateLineBrushI(GDIPCONST GpPoint* startpoint,
 158     GDIPCONST GpPoint* endpoint, ARGB startcolor, ARGB endcolor,
 159     GpWrapMode wrap, GpLineGradient **line)
 160 {
 161     GpPointF stF;
 162     GpPointF endF;
 163
 164     TRACE("(%p, %p, %x, %x, %d, %p)\n", startpoint, endpoint,
 165           startcolor, endcolor, wrap, line);
 166
 167     if(!startpoint || !endpoint)
 168         return InvalidParameter;
 169
 170     stF.X  = (REAL)startpoint->X;
 171     stF.Y  = (REAL)startpoint->Y;
 172     endF.X = (REAL)endpoint->X;
 173     endF.X = (REAL)endpoint->Y;
 174
 175     return GdipCreateLineBrush(&stF, &endF, startcolor, endcolor, wrap, line);
 176 }
 177
 178 GpStatus WINGDIPAPI GdipCreateLineBrushFromRect(GDIPCONST GpRectF* rect,
 179     ARGB startcolor, ARGB endcolor, LinearGradientMode mode, GpWrapMode wrap,
 180     GpLineGradient **line)
 181 {
 182     GpPointF start, end;
 183
 184     TRACE("(%p, %x, %x, %d, %d, %p)\n", rect, startcolor, endcolor, mode,
 185           wrap, line);
 186
 187     if(!line || !rect)
 188         return InvalidParameter;
 189
 190     start.X = rect->X;
 191     start.Y = rect->Y;
 192     end.X = rect->X + rect->Width;
 193     end.Y = rect->Y + rect->Height;
 194
 195     return GdipCreateLineBrush(&start, &end, startcolor, endcolor, wrap, line);
 196 }
 197
 198 GpStatus WINGDIPAPI GdipCreateLineBrushFromRectI(GDIPCONST GpRect* rect,
 199     ARGB startcolor, ARGB endcolor, LinearGradientMode mode, GpWrapMode wrap,
 200     GpLineGradient **line)
 201 {
 202     GpRectF rectF;
 203
 204     TRACE("(%p, %x, %x, %d, %d, %p)\n", rect, startcolor, endcolor, mode,
 205           wrap, line);
 206
 207     rectF.X      = (REAL) rect->X;
 208     rectF.Y      = (REAL) rect->Y;
 209     rectF.Width  = (REAL) rect->Width;
 210     rectF.Height = (REAL) rect->Height;
 211
 212     return GdipCreateLineBrushFromRect(&rectF, startcolor, endcolor, mode, wrap, line);
 213 }
 214
 215 /* FIXME: angle value completely ignored. Don't know how to use it since native
 216           always set Brush rectangle to rect (independetly of this angle).
 217           Maybe it's used only on drawing.  */
 218 GpStatus WINGDIPAPI GdipCreateLineBrushFromRectWithAngle(GDIPCONST GpRectF* rect,
 219     ARGB startcolor, ARGB endcolor, REAL angle, BOOL isAngleScalable, GpWrapMode wrap,
 220     GpLineGradient **line)
 221 {
 222     TRACE("(%p, %x, %x, %.2f, %d, %d, %p)\n", rect, startcolor, endcolor, angle, isAngleScalable,
 223           wrap, line);
 224
 225     return GdipCreateLineBrushFromRect(rect, startcolor, endcolor, LinearGradientModeForwardDiagonal,
 226                                        wrap, line);
 227 }
 228
 229 GpStatus WINGDIPAPI GdipCreateLineBrushFromRectWithAngleI(GDIPCONST GpRect* rect,
 230     ARGB startcolor, ARGB endcolor, REAL angle, BOOL isAngleScalable, GpWrapMode wrap,
 231     GpLineGradient **line)
 232 {
 233     TRACE("(%p, %x, %x, %.2f, %d, %d, %p)\n", rect, startcolor, endcolor, angle, isAngleScalable,
 234           wrap, line);
 235
 236     return GdipCreateLineBrushFromRectI(rect, startcolor, endcolor, LinearGradientModeForwardDiagonal,
 237                                         wrap, line);
 238 }
 239
 240 GpStatus WINGDIPAPI GdipCreatePathGradient(GDIPCONST GpPointF* points,
 241     INT count, GpWrapMode wrap, GpPathGradient **grad)
 242 {
 243     COLORREF col = ARGB2COLORREF(0xffffffff);
 244
 245     TRACE("(%p, %d, %d, %p)\n", points, count, wrap, grad);
 246
 247     if(!points || !grad)
 248         return InvalidParameter;
 249
 250     if(count <= 0)
 251         return OutOfMemory;
 252
 253     *grad = GdipAlloc(sizeof(GpPathGradient));
 254     if (!*grad) return OutOfMemory;
 255
 256     (*grad)->blendfac = GdipAlloc(sizeof(REAL));
 257     if(!(*grad)->blendfac){
 258         GdipFree(*grad);
 259         return OutOfMemory;
 260     }
 261     (*grad)->blendfac[0] = 1.0;
 262     (*grad)->blendpos    = NULL;
 263     (*grad)->blendcount  = 1;
 264
 265     (*grad)->pathdata.Count = count;
 266     (*grad)->pathdata.Points = GdipAlloc(count * sizeof(PointF));
 267     (*grad)->pathdata.Types = GdipAlloc(count);
 268
 269     if(!(*grad)->pathdata.Points || !(*grad)->pathdata.Types){
 270         GdipFree((*grad)->pathdata.Points);
 271         GdipFree((*grad)->pathdata.Types);
 272         GdipFree(*grad);
 273         return OutOfMemory;
 274     }
 275
 276     memcpy((*grad)->pathdata.Points, points, count * sizeof(PointF));
 277     memset((*grad)->pathdata.Types, PathPointTypeLine, count);
 278
 279     (*grad)->brush.lb.lbStyle = BS_SOLID;
 280     (*grad)->brush.lb.lbColor = col;
 281     (*grad)->brush.lb.lbHatch = 0;
 282
 283     (*grad)->brush.gdibrush = CreateSolidBrush(col);
 284     (*grad)->brush.bt = BrushTypePathGradient;
 285     (*grad)->centercolor = 0xffffffff;
 286     (*grad)->wrap = wrap;
 287     (*grad)->gamma = FALSE;
 288     (*grad)->center.X = 0.0;
 289     (*grad)->center.Y = 0.0;
 290     (*grad)->focus.X = 0.0;
 291     (*grad)->focus.Y = 0.0;
 292
 293     return Ok;
 294 }
 295
 296 GpStatus WINGDIPAPI GdipCreatePathGradientI(GDIPCONST GpPoint* points,
 297     INT count, GpWrapMode wrap, GpPathGradient **grad)
 298 {
 299     GpPointF *pointsF;
 300     GpStatus ret;
 301     INT i;
 302
 303     TRACE("(%p, %d, %d, %p)\n", points, count, wrap, grad);
 304
 305     if(!points || !grad)
 306         return InvalidParameter;
 307
 308     if(count <= 0)
 309         return OutOfMemory;
 310
 311     pointsF = GdipAlloc(sizeof(GpPointF) * count);
 312     if(!pointsF)
 313         return OutOfMemory;
 314
 315     for(i = 0; i < count; i++){
 316         pointsF[i].X = (REAL)points[i].X;
 317         pointsF[i].Y = (REAL)points[i].Y;
 318     }
 319
 320     ret = GdipCreatePathGradient(pointsF, count, wrap, grad);
 321     GdipFree(pointsF);
 322
 323     return ret;
 324 }
 325
 326 /* FIXME: path gradient brushes not truly supported (drawn as solid brushes) */
 327 GpStatus WINGDIPAPI GdipCreatePathGradientFromPath(GDIPCONST GpPath* path,
 328     GpPathGradient **grad)
 329 {
 330     COLORREF col = ARGB2COLORREF(0xffffffff);
 331
 332     TRACE("(%p, %p)\n", path, grad);
 333
 334     if(!path || !grad)
 335         return InvalidParameter;
 336
 337     *grad = GdipAlloc(sizeof(GpPathGradient));
 338     if (!*grad) return OutOfMemory;
 339
 340     (*grad)->blendfac = GdipAlloc(sizeof(REAL));
 341     if(!(*grad)->blendfac){
 342         GdipFree(*grad);
 343         return OutOfMemory;
 344     }
 345     (*grad)->blendfac[0] = 1.0;
 346     (*grad)->blendpos    = NULL;
 347     (*grad)->blendcount  = 1;
 348
 349     (*grad)->pathdata.Count = path->pathdata.Count;
 350     (*grad)->pathdata.Points = GdipAlloc(path->pathdata.Count * sizeof(PointF));
 351     (*grad)->pathdata.Types = GdipAlloc(path->pathdata.Count);
 352
 353     if(!(*grad)->pathdata.Points || !(*grad)->pathdata.Types){
 354         GdipFree((*grad)->pathdata.Points);
 355         GdipFree((*grad)->pathdata.Types);
 356         GdipFree(*grad);
 357         return OutOfMemory;
 358     }
 359
 360     memcpy((*grad)->pathdata.Points, path->pathdata.Points,
 361            path->pathdata.Count * sizeof(PointF));
 362     memcpy((*grad)->pathdata.Types, path->pathdata.Types, path->pathdata.Count);
 363
 364     (*grad)->brush.lb.lbStyle = BS_SOLID;
 365     (*grad)->brush.lb.lbColor = col;
 366     (*grad)->brush.lb.lbHatch = 0;
 367
 368     (*grad)->brush.gdibrush = CreateSolidBrush(col);
 369     (*grad)->brush.bt = BrushTypePathGradient;
 370     (*grad)->centercolor = 0xffffffff;
 371     (*grad)->wrap = WrapModeClamp;
 372     (*grad)->gamma = FALSE;
 373     /* FIXME: this should be set to the "centroid" of the path by default */
 374     (*grad)->center.X = 0.0;
 375     (*grad)->center.Y = 0.0;
 376     (*grad)->focus.X = 0.0;
 377     (*grad)->focus.Y = 0.0;
 378
 379     return Ok;
 380 }
 381
 382 GpStatus WINGDIPAPI GdipCreateSolidFill(ARGB color, GpSolidFill **sf)
 383 {
 384     COLORREF col = ARGB2COLORREF(color);
 385
 386     TRACE("(%x, %p)\n", color, sf);
 387
 388     if(!sf)  return InvalidParameter;
 389
 390     *sf = GdipAlloc(sizeof(GpSolidFill));
 391     if (!*sf) return OutOfMemory;
 392
 393     (*sf)->brush.lb.lbStyle = BS_SOLID;
 394     (*sf)->brush.lb.lbColor = col;
 395     (*sf)->brush.lb.lbHatch = 0;
 396
 397     (*sf)->brush.gdibrush = CreateSolidBrush(col);
 398     (*sf)->brush.bt = BrushTypeSolidColor;
 399     (*sf)->color = color;
 400
 401     return Ok;
 402 }
 403
 404 /*******************************************************************************
 405  * GdipCreateTexture [GDIPLUS.@]
 406  *
 407  * PARAMS
 408  *  image       [I] image to use
 409  *  wrapmode    [I] optional
 410  *  texture     [O] pointer to the resulting texturebrush
 411  *
 412  * RETURNS
 413  *  SUCCESS: Ok
 414  *  FAILURE: element of GpStatus
 415  */
 416 GpStatus WINGDIPAPI GdipCreateTexture(GpImage *image, GpWrapMode wrapmode,
 417         GpTexture **texture)
 418 {
 419     UINT width, height;
 420     GpImageAttributes attributes;
 421     GpStatus stat;
 422
 423     TRACE("%p, %d %p\n", image, wrapmode, texture);
 424
 425     if (!(image && texture))
 426         return InvalidParameter;
 427
 428     stat = GdipGetImageWidth(image, &width);
 429     if (stat != Ok) return stat;
 430     stat = GdipGetImageHeight(image, &height);
 431     if (stat != Ok) return stat;
 432     attributes.wrap = wrapmode;
 433
 434     return GdipCreateTextureIA(image, &attributes, 0, 0, width, height,
 435             texture);
 436 }
 437
 438 GpStatus WINGDIPAPI GdipCreateTexture2(GpImage *image, GpWrapMode wrapmode,
 439         REAL x, REAL y, REAL width, REAL height, GpTexture **texture)
 440 {
 441     GpImageAttributes attributes;
 442
 443     TRACE("%p %d %f %f %f %f %p\n", image, wrapmode,
 444             x, y, width, height, texture);
 445
 446     attributes.wrap = wrapmode;
 447     return GdipCreateTextureIA(image, &attributes, x, y, width, height,
 448             texture);
 449 }
 450
 451 /* FIXME: imageattr ignored */
 452 GpStatus WINGDIPAPI GdipCreateTextureIA(GpImage *image,
 453     GDIPCONST GpImageAttributes *imageattr, REAL x, REAL y, REAL width,
 454     REAL height, GpTexture **texture)
 455 {
 456     HDC hdc;
 457     OLE_HANDLE hbm;
 458     HBITMAP old = NULL;
 459     BITMAPINFO bmi;
 460     BITMAPINFOHEADER *bmih;
 461     INT n_x, n_y, n_width, n_height, abs_height, stride, image_stride, i, bytespp;
 462     BOOL bm_is_selected;
 463     BYTE *dibits, *buff, *textbits;
 464
 465     TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f, %p)\n", image, imageattr, x, y, width, height,
 466            texture);
 467
 468     if(!image || !texture || x < 0.0 || y < 0.0 || width < 0.0 || height < 0.0)
 469         return InvalidParameter;
 470
 471     if(image->type != ImageTypeBitmap){
 472         FIXME("not implemented for image type %d\n", image->type);
 473         return NotImplemented;
 474     }
 475
 476     n_x = roundr(x);
 477     n_y = roundr(y);
 478     n_width = roundr(width);
 479     n_height = roundr(height);
 480
 481     if(n_x + n_width > ((GpBitmap*)image)->width ||
 482        n_y + n_height > ((GpBitmap*)image)->height)
 483         return InvalidParameter;
 484
 485     IPicture_get_Handle(image->picture, &hbm);
 486     if(!hbm)   return GenericError;
 487     IPicture_get_CurDC(image->picture, &hdc);
 488     bm_is_selected = (hdc != 0);
 489
 490     bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
 491     bmi.bmiHeader.biBitCount = 0;
 492
 493     if(!bm_is_selected){
 494         hdc = CreateCompatibleDC(0);
 495         old = SelectObject(hdc, (HBITMAP)hbm);
 496     }
 497
 498     /* fill out bmi */
 499     GetDIBits(hdc, (HBITMAP)hbm, 0, 0, NULL, &bmi, DIB_RGB_COLORS);
 500
 501     bytespp = bmi.bmiHeader.biBitCount / 8;
 502     abs_height = abs(bmi.bmiHeader.biHeight);
 503
 504     if(n_x > bmi.bmiHeader.biWidth || n_x + n_width > bmi.bmiHeader.biWidth ||
 505        n_y > abs_height || n_y + n_height > abs_height)
 506         return InvalidParameter;
 507
 508     dibits = GdipAlloc(bmi.bmiHeader.biSizeImage);
 509
 510     if(dibits)  /* this is not a good place to error out */
 511         GetDIBits(hdc, (HBITMAP)hbm, 0, abs_height, dibits, &bmi, DIB_RGB_COLORS);
 512
 513     if(!bm_is_selected){
 514         SelectObject(hdc, old);
 515         DeleteDC(hdc);
 516     }
 517
 518     if(!dibits)
 519         return OutOfMemory;
 520
 521     image_stride = (bmi.bmiHeader.biWidth * bytespp + 3) & ~3;
 522     stride = (n_width * bytespp + 3) & ~3;
 523     buff = GdipAlloc(sizeof(BITMAPINFOHEADER) + stride * n_height);
 524     if(!buff){
 525         GdipFree(dibits);
 526         return OutOfMemory;
 527     }
 528
 529     bmih = (BITMAPINFOHEADER*)buff;
 530     textbits = (BYTE*) (bmih + 1);
 531     bmih->biSize = sizeof(BITMAPINFOHEADER);
 532     bmih->biWidth = n_width;
 533     bmih->biHeight = n_height;
 534     bmih->biCompression = BI_RGB;
 535     bmih->biSizeImage = stride * n_height;
 536     bmih->biBitCount = bmi.bmiHeader.biBitCount;
 537     bmih->biClrUsed = 0;
 538     bmih->biPlanes = 1;
 539
 540     /* image is flipped */
 541     if(bmi.bmiHeader.biHeight > 0){
 542         dibits += bmi.bmiHeader.biSizeImage;
 543         image_stride *= -1;
 544         textbits += stride * (n_height - 1);
 545         stride *= -1;
 546     }
 547
 548     for(i = 0; i < n_height; i++)
 549         memcpy(&textbits[i * stride],
 550                &dibits[n_x * bytespp + (n_y + i) * image_stride],
 551                abs(stride));
 552
 553     *texture = GdipAlloc(sizeof(GpTexture));
 554     if (!*texture) return OutOfMemory;
 555
 556     (*texture)->brush.lb.lbStyle = BS_DIBPATTERNPT;
 557     (*texture)->brush.lb.lbColor = DIB_RGB_COLORS;
 558     (*texture)->brush.lb.lbHatch = (ULONG_PTR)buff;
 559
 560     (*texture)->brush.gdibrush = CreateBrushIndirect(&(*texture)->brush.lb);
 561     (*texture)->brush.bt = BrushTypeTextureFill;
 562
 563     GdipFree(dibits);
 564     GdipFree(buff);
 565
 566     return Ok;
 567 }
 568
 569 GpStatus WINGDIPAPI GdipCreateTextureIAI(GpImage *image, GDIPCONST GpImageAttributes *imageattr,
 570     INT x, INT y, INT width, INT height, GpTexture **texture)
 571 {
 572     TRACE("(%p, %p, %d, %d, %d, %d, %p)\n", image, imageattr, x, y, width, height,
 573            texture);
 574
 575     return GdipCreateTextureIA(image,imageattr,(REAL)x,(REAL)y,(REAL)width,(REAL)height,texture);
 576 }
 577
 578 GpStatus WINGDIPAPI GdipCreateTexture2I(GpImage *image, GpWrapMode wrapmode,
 579         INT x, INT y, INT width, INT height, GpTexture **texture)
 580 {
 581     GpImageAttributes imageattr;
 582
 583     TRACE("%p %d %d %d %d %d %p\n", image, wrapmode, x, y, width, height,
 584             texture);
 585
 586     imageattr.wrap = wrapmode;
 587
 588     return GdipCreateTextureIA(image, &imageattr, x, y, width, height, texture);
 589 }
 590
 591 GpStatus WINGDIPAPI GdipGetBrushType(GpBrush *brush, GpBrushType *type)
 592 {
 593     TRACE("(%p, %p)\n", brush, type);
 594
 595     if(!brush || !type)  return InvalidParameter;
 596
 597     *type = brush->bt;
 598
 599     return Ok;
 600 }
 601
 602 GpStatus WINGDIPAPI GdipDeleteBrush(GpBrush *brush)
 603 {
 604     TRACE("(%p)\n", brush);
 605
 606     if(!brush)  return InvalidParameter;
 607
 608     switch(brush->bt)
 609     {
 610         case BrushTypePathGradient:
 611             GdipFree(((GpPathGradient*) brush)->pathdata.Points);
 612             GdipFree(((GpPathGradient*) brush)->pathdata.Types);
 613             GdipFree(((GpPathGradient*) brush)->blendfac);
 614             GdipFree(((GpPathGradient*) brush)->blendpos);
 615             break;
 616         case BrushTypeSolidColor:
 617         case BrushTypeLinearGradient:
 618         case BrushTypeTextureFill:
 619         default:
 620             break;
 621     }
 622
 623     DeleteObject(brush->gdibrush);
 624     GdipFree(brush);
 625
 626     return Ok;
 627 }
 628
 629 GpStatus WINGDIPAPI GdipGetLineGammaCorrection(GpLineGradient *line,
 630     BOOL *usinggamma)
 631 {
 632     TRACE("(%p, %p)\n", line, usinggamma);
 633
 634     if(!line || !usinggamma)
 635         return InvalidParameter;
 636
 637     *usinggamma = line->gamma;
 638
 639     return Ok;
 640 }
 641
 642 GpStatus WINGDIPAPI GdipGetLineWrapMode(GpLineGradient *brush, GpWrapMode *wrapmode)
 643 {
 644     TRACE("(%p, %p)\n", brush, wrapmode);
 645
 646     if(!brush || !wrapmode)
 647         return InvalidParameter;
 648
 649     *wrapmode = brush->wrap;
 650
 651     return Ok;
 652 }
 653
 654 GpStatus WINGDIPAPI GdipGetPathGradientBlend(GpPathGradient *brush, REAL *blend,
 655     REAL *positions, INT count)
 656 {
 657     TRACE("(%p, %p, %p, %d)\n", brush, blend, positions, count);
 658
 659     if(!brush || !blend || !positions || count <= 0)
 660         return InvalidParameter;
 661
 662     if(count < brush->blendcount)
 663         return InsufficientBuffer;
 664
 665     memcpy(blend, brush->blendfac, count*sizeof(REAL));
 666     if(brush->blendcount > 1){
 667         memcpy(positions, brush->blendpos, count*sizeof(REAL));
 668     }
 669
 670     return Ok;
 671 }
 672
 673 GpStatus WINGDIPAPI GdipGetPathGradientBlendCount(GpPathGradient *brush, INT *count)
 674 {
 675     TRACE("(%p, %p)\n", brush, count);
 676
 677     if(!brush || !count)
 678         return InvalidParameter;
 679
 680     *count = brush->blendcount;
 681
 682     return Ok;
 683 }
 684
 685 GpStatus WINGDIPAPI GdipGetPathGradientCenterPoint(GpPathGradient *grad,
 686     GpPointF *point)
 687 {
 688     TRACE("(%p, %p)\n", grad, point);
 689
 690     if(!grad || !point)
 691         return InvalidParameter;
 692
 693     point->X = grad->center.X;
 694     point->Y = grad->center.Y;
 695
 696     return Ok;
 697 }
 698
 699 GpStatus WINGDIPAPI GdipGetPathGradientCenterPointI(GpPathGradient *grad,
 700     GpPoint *point)
 701 {
 702     GpStatus ret;
 703     GpPointF ptf;
 704
 705     TRACE("(%p, %p)\n", grad, point);
 706
 707     if(!point)
 708         return InvalidParameter;
 709
 710     ret = GdipGetPathGradientCenterPoint(grad,&ptf);
 711
 712     if(ret == Ok){
 713         point->X = roundr(ptf.X);
 714         point->Y = roundr(ptf.Y);
 715     }
 716
 717     return ret;
 718 }
 719
 720 GpStatus WINGDIPAPI GdipGetPathGradientFocusScales(GpPathGradient *grad,
 721     REAL *x, REAL *y)
 722 {
 723     TRACE("(%p, %p, %p)\n", grad, x, y);
 724
 725     if(!grad || !x || !y)
 726         return InvalidParameter;
 727
 728     *x = grad->focus.X;
 729     *y = grad->focus.Y;
 730
 731     return Ok;
 732 }
 733
 734 GpStatus WINGDIPAPI GdipGetPathGradientGammaCorrection(GpPathGradient *grad,
 735     BOOL *gamma)
 736 {
 737     TRACE("(%p, %p)\n", grad, gamma);
 738
 739     if(!grad || !gamma)
 740         return InvalidParameter;
 741
 742     *gamma = grad->gamma;
 743
 744     return Ok;
 745 }
 746
 747 GpStatus WINGDIPAPI GdipGetPathGradientPointCount(GpPathGradient *grad,
 748     INT *count)
 749 {
 750     TRACE("(%p, %p)\n", grad, count);
 751
 752     if(!grad || !count)
 753         return InvalidParameter;
 754
 755     *count = grad->pathdata.Count;
 756
 757     return Ok;
 758 }
 759
 760 GpStatus WINGDIPAPI GdipGetPathGradientRect(GpPathGradient *brush, GpRectF *rect)
 761 {
 762     GpRectF r;
 763     GpPath* path;
 764     GpStatus stat;
 765
 766     TRACE("(%p, %p)\n", brush, rect);
 767
 768     if(!brush || !rect)
 769         return InvalidParameter;
 770
 771     stat = GdipCreatePath2(brush->pathdata.Points, brush->pathdata.Types,
 772                            brush->pathdata.Count, FillModeAlternate, &path);
 773     if(stat != Ok)  return stat;
 774
 775     stat = GdipGetPathWorldBounds(path, &r, NULL, NULL);
 776     if(stat != Ok){
 777         GdipDeletePath(path);
 778         return stat;
 779     }
 780
 781     memcpy(rect, &r, sizeof(GpRectF));
 782
 783     GdipDeletePath(path);
 784
 785     return Ok;
 786 }
 787
 788 GpStatus WINGDIPAPI GdipGetPathGradientRectI(GpPathGradient *brush, GpRect *rect)
 789 {
 790     GpRectF rectf;
 791     GpStatus stat;
 792
 793     TRACE("(%p, %p)\n", brush, rect);
 794
 795     if(!brush || !rect)
 796         return InvalidParameter;
 797
 798     stat = GdipGetPathGradientRect(brush, &rectf);
 799     if(stat != Ok)  return stat;
 800
 801     rect->X = roundr(rectf.X);
 802     rect->Y = roundr(rectf.Y);
 803     rect->Width  = roundr(rectf.Width);
 804     rect->Height = roundr(rectf.Height);
 805
 806     return Ok;
 807 }
 808
 809 GpStatus WINGDIPAPI GdipGetPathGradientSurroundColorsWithCount(GpPathGradient
 810     *grad, ARGB *argb, INT *count)
 811 {
 812     static int calls;
 813
 814     if(!grad || !argb || !count || (*count < grad->pathdata.Count))
 815         return InvalidParameter;
 816
 817     if(!(calls++))
 818         FIXME("not implemented\n");
 819
 820     return NotImplemented;
 821 }
 822
 823 GpStatus WINGDIPAPI GdipGetPathGradientWrapMode(GpPathGradient *brush,
 824     GpWrapMode *wrapmode)
 825 {
 826     TRACE("(%p, %p)\n", brush, wrapmode);
 827
 828     if(!brush || !wrapmode)
 829         return InvalidParameter;
 830
 831     *wrapmode = brush->wrap;
 832
 833     return Ok;
 834 }
 835
 836 GpStatus WINGDIPAPI GdipGetSolidFillColor(GpSolidFill *sf, ARGB *argb)
 837 {
 838     TRACE("(%p, %p)\n", sf, argb);
 839
 840     if(!sf || !argb)
 841         return InvalidParameter;
 842
 843     *argb = sf->color;
 844
 845     return Ok;
 846 }
 847
 848 GpStatus WINGDIPAPI GdipSetLineBlend(GpLineGradient *brush,
 849     GDIPCONST REAL *blend, GDIPCONST REAL* positions, INT count)
 850 {
 851     static int calls;
 852
 853     if(!brush || !blend || !positions || count <= 0)
 854         return InvalidParameter;
 855
 856     if(!(calls++))
 857         FIXME("not implemented\n");
 858
 859     return Ok;
 860 }
 861
 862 GpStatus WINGDIPAPI GdipSetLineGammaCorrection(GpLineGradient *line,
 863     BOOL usegamma)
 864 {
 865     TRACE("(%p, %d)\n", line, usegamma);
 866
 867     if(!line)
 868         return InvalidParameter;
 869
 870     line->gamma = usegamma;
 871
 872     return Ok;
 873 }
 874
 875 GpStatus WINGDIPAPI GdipSetLineSigmaBlend(GpLineGradient *line, REAL focus,
 876     REAL scale)
 877 {
 878     static int calls;
 879
 880     if(!line || focus < 0.0 || focus > 1.0 || scale < 0.0 || scale > 1.0)
 881         return InvalidParameter;
 882
 883     if(!(calls++))
 884         FIXME("not implemented\n");
 885
 886     return NotImplemented;
 887 }
 888
 889 GpStatus WINGDIPAPI GdipSetLineWrapMode(GpLineGradient *line,
 890     GpWrapMode wrap)
 891 {
 892     TRACE("(%p, %d)\n", line, wrap);
 893
 894     if(!line || wrap == WrapModeClamp)
 895         return InvalidParameter;
 896
 897     line->wrap = wrap;
 898
 899     return Ok;
 900 }
 901
 902 GpStatus WINGDIPAPI GdipSetPathGradientCenterColor(GpPathGradient *grad,
 903     ARGB argb)
 904 {
 905     TRACE("(%p, %x)\n", grad, argb);
 906
 907     if(!grad)
 908         return InvalidParameter;
 909
 910     grad->centercolor = argb;
 911     grad->brush.lb.lbColor = ARGB2COLORREF(argb);
 912
 913     DeleteObject(grad->brush.gdibrush);
 914     grad->brush.gdibrush = CreateSolidBrush(grad->brush.lb.lbColor);
 915
 916     return Ok;
 917 }
 918
 919 GpStatus WINGDIPAPI GdipSetPathGradientCenterPoint(GpPathGradient *grad,
 920     GpPointF *point)
 921 {
 922     TRACE("(%p, %p)\n", grad, point);
 923
 924     if(!grad || !point)
 925         return InvalidParameter;
 926
 927     grad->center.X = point->X;
 928     grad->center.Y = point->Y;
 929
 930     return Ok;
 931 }
 932
 933 GpStatus WINGDIPAPI GdipSetPathGradientCenterPointI(GpPathGradient *grad,
 934     GpPoint *point)
 935 {
 936     GpPointF ptf;
 937
 938     TRACE("(%p, %p)\n", grad, point);
 939
 940     if(!point)
 941         return InvalidParameter;
 942
 943     ptf.X = (REAL)point->X;
 944     ptf.Y = (REAL)point->Y;
 945
 946     return GdipSetPathGradientCenterPoint(grad,&ptf);
 947 }
 948
 949 GpStatus WINGDIPAPI GdipSetPathGradientFocusScales(GpPathGradient *grad,
 950     REAL x, REAL y)
 951 {
 952     TRACE("(%p, %.2f, %.2f)\n", grad, x, y);
 953
 954     if(!grad)
 955         return InvalidParameter;
 956
 957     grad->focus.X = x;
 958     grad->focus.Y = y;
 959
 960     return Ok;
 961 }
 962
 963 GpStatus WINGDIPAPI GdipSetPathGradientGammaCorrection(GpPathGradient *grad,
 964     BOOL gamma)
 965 {
 966     TRACE("(%p, %d)\n", grad, gamma);
 967
 968     if(!grad)
 969         return InvalidParameter;
 970
 971     grad->gamma = gamma;
 972
 973     return Ok;
 974 }
 975
 976 GpStatus WINGDIPAPI GdipSetPathGradientSigmaBlend(GpPathGradient *grad,
 977     REAL focus, REAL scale)
 978 {
 979     static int calls;
 980
 981     if(!grad || focus < 0.0 || focus > 1.0 || scale < 0.0 || scale > 1.0)
 982         return InvalidParameter;
 983
 984     if(!(calls++))
 985         FIXME("not implemented\n");
 986
 987     return NotImplemented;
 988 }
 989
 990 GpStatus WINGDIPAPI GdipSetPathGradientSurroundColorsWithCount(GpPathGradient
 991     *grad, ARGB *argb, INT *count)
 992 {
 993     static int calls;
 994
 995     if(!grad || !argb || !count || (*count <= 0) ||
 996         (*count > grad->pathdata.Count))
 997         return InvalidParameter;
 998
 999     if(!(calls++))
1000         FIXME("not implemented\n");
1001
1002     return NotImplemented;
1003 }
1004
1005 GpStatus WINGDIPAPI GdipSetPathGradientWrapMode(GpPathGradient *grad,
1006     GpWrapMode wrap)
1007 {
1008     TRACE("(%p, %d)\n", grad, wrap);
1009
1010     if(!grad)
1011         return InvalidParameter;
1012
1013     grad->wrap = wrap;
1014
1015     return Ok;
1016 }
1017
1018 GpStatus WINGDIPAPI GdipSetSolidFillColor(GpSolidFill *sf, ARGB argb)
1019 {
1020     TRACE("(%p, %x)\n", sf, argb);
1021
1022     if(!sf)
1023         return InvalidParameter;
1024
1025     sf->color = argb;
1026     sf->brush.lb.lbColor = ARGB2COLORREF(argb);
1027
1028     DeleteObject(sf->brush.gdibrush);
1029     sf->brush.gdibrush = CreateSolidBrush(sf->brush.lb.lbColor);
1030
1031     return Ok;
1032 }
1033
1034 GpStatus WINGDIPAPI GdipSetTextureTransform(GpTexture *texture,
1035     GDIPCONST GpMatrix *matrix)
1036 {
1037     static int calls;
1038
1039     if(!texture || !matrix)
1040         return InvalidParameter;
1041
1042     if(!(calls++))
1043         FIXME("not implemented\n");
1044
1045     return Ok;
1046 }
1047
1048 GpStatus WINGDIPAPI GdipSetLineColors(GpLineGradient *brush, ARGB color1,
1049     ARGB color2)
1050 {
1051     TRACE("(%p, %x, %x)\n", brush, color1, color2);
1052
1053     if(!brush)
1054         return InvalidParameter;
1055
1056     brush->startcolor = color1;
1057     brush->endcolor   = color2;
1058
1059     return Ok;
1060 }
1061
1062 GpStatus WINGDIPAPI GdipGetLineColors(GpLineGradient *brush, ARGB *colors)
1063 {
1064     TRACE("(%p, %p)\n", brush, colors);
1065
1066     if(!brush || !colors)
1067         return InvalidParameter;
1068
1069     colors[0] = brush->startcolor;
1070     colors[1] = brush->endcolor;
1071
1072     return Ok;
1073 }
1074
1075 GpStatus WINGDIPAPI GdipSetLineLinearBlend(GpLineGradient *brush, REAL focus,
1076     REAL scale)
1077 {
1078     static int calls;
1079
1080     if(!(calls++))
1081         FIXME("not implemented\n");
1082
1083     return NotImplemented;
1084 }
1085
1086 GpStatus WINGDIPAPI GdipSetLinePresetBlend(GpLineGradient *brush,
1087     GDIPCONST ARGB *blend, GDIPCONST REAL* positions, INT count)
1088 {
1089     static int calls;
1090
1091     if(!(calls++))
1092         FIXME("not implemented\n");
1093
1094     return NotImplemented;
1095 }
1096
1097 GpStatus WINGDIPAPI GdipSetLineTransform(GpLineGradient *brush,
1098     GDIPCONST GpMatrix *matrix)
1099 {
1100     static int calls;
1101
1102     if(!(calls++))
1103         FIXME("not implemented\n");
1104
1105     return NotImplemented;
1106 }
1107
1108 GpStatus WINGDIPAPI GdipTranslateLineTransform(GpLineGradient* brush,
1109         REAL dx, REAL dy, GpMatrixOrder order)
1110 {
1111     FIXME("stub: %p %f %f %d\n", brush, dx, dy, order);
1112
1113     return NotImplemented;
1114 }
1115
1116 GpStatus WINGDIPAPI GdipGetLineRect(GpLineGradient *brush, GpRectF *rect)
1117 {
1118     TRACE("(%p, %p)\n", brush, rect);
1119
1120     if(!brush || !rect)
1121         return InvalidParameter;
1122
1123     rect->X = (brush->startpoint.X < brush->endpoint.X ? brush->startpoint.X: brush->endpoint.X);
1124     rect->Y = (brush->startpoint.Y < brush->endpoint.Y ? brush->startpoint.Y: brush->endpoint.Y);
1125
1126     rect->Width  = fabs(brush->startpoint.X - brush->endpoint.X);
1127     rect->Height = fabs(brush->startpoint.Y - brush->endpoint.Y);
1128
1129     return Ok;
1130 }
1131
1132 GpStatus WINGDIPAPI GdipGetLineRectI(GpLineGradient *brush, GpRect *rect)
1133 {
1134     GpRectF  rectF;
1135     GpStatus ret;
1136
1137     TRACE("(%p, %p)\n", brush, rect);
1138
1139     if(!rect)
1140         return InvalidParameter;
1141
1142     ret = GdipGetLineRect(brush, &rectF);
1143
1144     if(ret == Ok){
1145         rect->X      = roundr(rectF.X);
1146         rect->Y      = roundr(rectF.Y);
1147         rect->Width  = roundr(rectF.Width);
1148         rect->Height = roundr(rectF.Height);
1149     }
1150
1151     return ret;
1152 }