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     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 GdipCreateLineBrushFromRectI(GDIPCONST GpRect* rect,
 135     ARGB startcolor, ARGB endcolor, LinearGradientMode mode, GpWrapMode wrap,
 136     GpLineGradient **line)
 137 {
 138     GpPointF start, end;
 139
 140     if(!line || !rect)
 141         return InvalidParameter;
 142
 143     start.X = (REAL) rect->X;
 144     start.Y = (REAL) rect->Y;
 145     end.X = (REAL) (rect->X + rect->Width);
 146     end.Y = (REAL) (rect->Y + rect->Height);
 147
 148     return GdipCreateLineBrush(&start, &end, startcolor, endcolor, wrap, line);
 149 }
 150
 151 GpStatus WINGDIPAPI GdipCreatePathGradient(GDIPCONST GpPointF* points,
 152     INT count, GpWrapMode wrap, GpPathGradient **grad)
 153 {
 154     COLORREF col = ARGB2COLORREF(0xffffffff);
 155
 156     if(!points || !grad)
 157         return InvalidParameter;
 158
 159     if(count <= 0)
 160         return OutOfMemory;
 161
 162     *grad = GdipAlloc(sizeof(GpPathGradient));
 163     if (!*grad) return OutOfMemory;
 164
 165     (*grad)->pathdata.Count = count;
 166     (*grad)->pathdata.Points = GdipAlloc(count * sizeof(PointF));
 167     (*grad)->pathdata.Types = GdipAlloc(count);
 168
 169     if(!(*grad)->pathdata.Points || !(*grad)->pathdata.Types){
 170         GdipFree((*grad)->pathdata.Points);
 171         GdipFree((*grad)->pathdata.Types);
 172         GdipFree(*grad);
 173         return OutOfMemory;
 174     }
 175
 176     memcpy((*grad)->pathdata.Points, points, count * sizeof(PointF));
 177     memset((*grad)->pathdata.Types, PathPointTypeLine, count);
 178
 179     (*grad)->brush.lb.lbStyle = BS_SOLID;
 180     (*grad)->brush.lb.lbColor = col;
 181     (*grad)->brush.lb.lbHatch = 0;
 182
 183     (*grad)->brush.gdibrush = CreateSolidBrush(col);
 184     (*grad)->brush.bt = BrushTypePathGradient;
 185     (*grad)->centercolor = 0xffffffff;
 186     (*grad)->wrap = wrap;
 187     (*grad)->gamma = FALSE;
 188     (*grad)->center.X = 0.0;
 189     (*grad)->center.Y = 0.0;
 190     (*grad)->focus.X = 0.0;
 191     (*grad)->focus.Y = 0.0;
 192
 193     return Ok;
 194 }
 195
 196 /* FIXME: path gradient brushes not truly supported (drawn as solid brushes) */
 197 GpStatus WINGDIPAPI GdipCreatePathGradientFromPath(GDIPCONST GpPath* path,
 198     GpPathGradient **grad)
 199 {
 200     COLORREF col = ARGB2COLORREF(0xffffffff);
 201
 202     if(!path || !grad)
 203         return InvalidParameter;
 204
 205     *grad = GdipAlloc(sizeof(GpPathGradient));
 206     if (!*grad) return OutOfMemory;
 207
 208     (*grad)->pathdata.Count = path->pathdata.Count;
 209     (*grad)->pathdata.Points = GdipAlloc(path->pathdata.Count * sizeof(PointF));
 210     (*grad)->pathdata.Types = GdipAlloc(path->pathdata.Count);
 211
 212     if(!(*grad)->pathdata.Points || !(*grad)->pathdata.Types){
 213         GdipFree((*grad)->pathdata.Points);
 214         GdipFree((*grad)->pathdata.Types);
 215         GdipFree(*grad);
 216         return OutOfMemory;
 217     }
 218
 219     memcpy((*grad)->pathdata.Points, path->pathdata.Points,
 220            path->pathdata.Count * sizeof(PointF));
 221     memcpy((*grad)->pathdata.Types, path->pathdata.Types, path->pathdata.Count);
 222
 223     (*grad)->brush.lb.lbStyle = BS_SOLID;
 224     (*grad)->brush.lb.lbColor = col;
 225     (*grad)->brush.lb.lbHatch = 0;
 226
 227     (*grad)->brush.gdibrush = CreateSolidBrush(col);
 228     (*grad)->brush.bt = BrushTypePathGradient;
 229     (*grad)->centercolor = 0xffffffff;
 230     (*grad)->wrap = WrapModeClamp;
 231     (*grad)->gamma = FALSE;
 232     /* FIXME: this should be set to the "centroid" of the path by default */
 233     (*grad)->center.X = 0.0;
 234     (*grad)->center.Y = 0.0;
 235     (*grad)->focus.X = 0.0;
 236     (*grad)->focus.Y = 0.0;
 237
 238     return Ok;
 239 }
 240
 241 GpStatus WINGDIPAPI GdipCreateSolidFill(ARGB color, GpSolidFill **sf)
 242 {
 243     COLORREF col = ARGB2COLORREF(color);
 244
 245     if(!sf)  return InvalidParameter;
 246
 247     *sf = GdipAlloc(sizeof(GpSolidFill));
 248     if (!*sf) return OutOfMemory;
 249
 250     (*sf)->brush.lb.lbStyle = BS_SOLID;
 251     (*sf)->brush.lb.lbColor = col;
 252     (*sf)->brush.lb.lbHatch = 0;
 253
 254     (*sf)->brush.gdibrush = CreateSolidBrush(col);
 255     (*sf)->brush.bt = BrushTypeSolidColor;
 256     (*sf)->color = color;
 257
 258     return Ok;
 259 }
 260
 261 /* FIXME: imageattr ignored */
 262 GpStatus WINGDIPAPI GdipCreateTextureIA(GpImage *image,
 263     GDIPCONST GpImageAttributes *imageattr, REAL x, REAL y, REAL width,
 264     REAL height, GpTexture **texture)
 265 {
 266     HDC hdc;
 267     OLE_HANDLE hbm;
 268     HBITMAP old = NULL;
 269     BITMAPINFO bmi;
 270     BITMAPINFOHEADER *bmih;
 271     INT n_x, n_y, n_width, n_height, abs_height, stride, image_stride, i, bytespp;
 272     BOOL bm_is_selected;
 273     BYTE *dibits, *buff, *textbits;
 274
 275     if(!image || !texture || x < 0.0 || y < 0.0 || width < 0.0 || height < 0.0)
 276         return InvalidParameter;
 277
 278     if(image->type != ImageTypeBitmap){
 279         FIXME("not implemented for image type %d\n", image->type);
 280         return NotImplemented;
 281     }
 282
 283     n_x = roundr(x);
 284     n_y = roundr(y);
 285     n_width = roundr(width);
 286     n_height = roundr(height);
 287
 288     if(n_x + n_width > ((GpBitmap*)image)->width ||
 289        n_y + n_height > ((GpBitmap*)image)->height)
 290         return InvalidParameter;
 291
 292     IPicture_get_Handle(image->picture, &hbm);
 293     if(!hbm)   return GenericError;
 294     IPicture_get_CurDC(image->picture, &hdc);
 295     bm_is_selected = (hdc != 0);
 296
 297     bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
 298     bmi.bmiHeader.biBitCount = 0;
 299
 300     if(!bm_is_selected){
 301         hdc = CreateCompatibleDC(0);
 302         old = SelectObject(hdc, (HBITMAP)hbm);
 303     }
 304
 305     /* fill out bmi */
 306     GetDIBits(hdc, (HBITMAP)hbm, 0, 0, NULL, &bmi, DIB_RGB_COLORS);
 307
 308     bytespp = bmi.bmiHeader.biBitCount / 8;
 309     abs_height = abs(bmi.bmiHeader.biHeight);
 310
 311     if(n_x > bmi.bmiHeader.biWidth || n_x + n_width > bmi.bmiHeader.biWidth ||
 312        n_y > abs_height || n_y + n_height > abs_height)
 313         return InvalidParameter;
 314
 315     dibits = GdipAlloc(bmi.bmiHeader.biSizeImage);
 316
 317     if(dibits)  /* this is not a good place to error out */
 318         GetDIBits(hdc, (HBITMAP)hbm, 0, abs_height, dibits, &bmi, DIB_RGB_COLORS);
 319
 320     if(!bm_is_selected){
 321         SelectObject(hdc, old);
 322         DeleteDC(hdc);
 323     }
 324
 325     if(!dibits)
 326         return OutOfMemory;
 327
 328     image_stride = (bmi.bmiHeader.biWidth * bytespp + 3) & ~3;
 329     stride = (n_width * bytespp + 3) & ~3;
 330     buff = GdipAlloc(sizeof(BITMAPINFOHEADER) + stride * n_height);
 331     if(!buff){
 332         GdipFree(dibits);
 333         return OutOfMemory;
 334     }
 335
 336     bmih = (BITMAPINFOHEADER*)buff;
 337     textbits = (BYTE*) (bmih + 1);
 338     bmih->biSize = sizeof(BITMAPINFOHEADER);
 339     bmih->biWidth = n_width;
 340     bmih->biHeight = n_height;
 341     bmih->biCompression = BI_RGB;
 342     bmih->biSizeImage = stride * n_height;
 343     bmih->biBitCount = bmi.bmiHeader.biBitCount;
 344     bmih->biClrUsed = 0;
 345     bmih->biPlanes = 1;
 346
 347     /* image is flipped */
 348     if(bmi.bmiHeader.biHeight > 0){
 349         dibits += bmi.bmiHeader.biSizeImage;
 350         image_stride *= -1;
 351         textbits += stride * (n_height - 1);
 352         stride *= -1;
 353     }
 354
 355     for(i = 0; i < n_height; i++)
 356         memcpy(&textbits[i * stride],
 357                &dibits[n_x * bytespp + (n_y + i) * image_stride],
 358                abs(stride));
 359
 360     *texture = GdipAlloc(sizeof(GpTexture));
 361     if (!*texture) return OutOfMemory;
 362
 363     (*texture)->brush.lb.lbStyle = BS_DIBPATTERNPT;
 364     (*texture)->brush.lb.lbColor = DIB_RGB_COLORS;
 365     (*texture)->brush.lb.lbHatch = (ULONG_PTR)buff;
 366
 367     (*texture)->brush.gdibrush = CreateBrushIndirect(&(*texture)->brush.lb);
 368     (*texture)->brush.bt = BrushTypeTextureFill;
 369
 370     GdipFree(dibits);
 371     GdipFree(buff);
 372
 373     return Ok;
 374 }
 375
 376 GpStatus WINGDIPAPI GdipGetBrushType(GpBrush *brush, GpBrushType *type)
 377 {
 378     if(!brush || !type)  return InvalidParameter;
 379
 380     *type = brush->bt;
 381
 382     return Ok;
 383 }
 384
 385 GpStatus WINGDIPAPI GdipDeleteBrush(GpBrush *brush)
 386 {
 387     if(!brush)  return InvalidParameter;
 388
 389     switch(brush->bt)
 390     {
 391         case BrushTypePathGradient:
 392             GdipFree(((GpPathGradient*) brush)->pathdata.Points);
 393             GdipFree(((GpPathGradient*) brush)->pathdata.Types);
 394             break;
 395         case BrushTypeSolidColor:
 396         case BrushTypeLinearGradient:
 397         case BrushTypeTextureFill:
 398         default:
 399             break;
 400     }
 401
 402     DeleteObject(brush->gdibrush);
 403     GdipFree(brush);
 404
 405     return Ok;
 406 }
 407
 408 GpStatus WINGDIPAPI GdipGetLineGammaCorrection(GpLineGradient *line,
 409     BOOL *usinggamma)
 410 {
 411     if(!line)
 412         return InvalidParameter;
 413
 414     *usinggamma = line->gamma;
 415
 416     return Ok;
 417 }
 418
 419 GpStatus WINGDIPAPI GdipGetPathGradientCenterPoint(GpPathGradient *grad,
 420     GpPointF *point)
 421 {
 422     if(!grad || !point)
 423         return InvalidParameter;
 424
 425     point->X = grad->center.X;
 426     point->Y = grad->center.Y;
 427
 428     return Ok;
 429 }
 430
 431 GpStatus WINGDIPAPI GdipGetPathGradientFocusScales(GpPathGradient *grad,
 432     REAL *x, REAL *y)
 433 {
 434     if(!grad || !x || !y)
 435         return InvalidParameter;
 436
 437     *x = grad->focus.X;
 438     *y = grad->focus.Y;
 439
 440     return Ok;
 441 }
 442
 443 GpStatus WINGDIPAPI GdipGetPathGradientGammaCorrection(GpPathGradient *grad,
 444     BOOL *gamma)
 445 {
 446     if(!grad || !gamma)
 447         return InvalidParameter;
 448
 449     *gamma = grad->gamma;
 450
 451     return Ok;
 452 }
 453
 454 GpStatus WINGDIPAPI GdipGetPathGradientPointCount(GpPathGradient *grad,
 455     INT *count)
 456 {
 457     if(!grad || !count)
 458         return InvalidParameter;
 459
 460     *count = grad->pathdata.Count;
 461
 462     return Ok;
 463 }
 464
 465 GpStatus WINGDIPAPI GdipGetPathGradientSurroundColorsWithCount(GpPathGradient
 466     *grad, ARGB *argb, INT *count)
 467 {
 468     static int calls;
 469
 470     if(!grad || !argb || !count || (*count < grad->pathdata.Count))
 471         return InvalidParameter;
 472
 473     if(!(calls++))
 474         FIXME("not implemented\n");
 475
 476     return NotImplemented;
 477 }
 478
 479 GpStatus WINGDIPAPI GdipGetSolidFillColor(GpSolidFill *sf, ARGB *argb)
 480 {
 481     if(!sf || !argb)
 482         return InvalidParameter;
 483
 484     *argb = sf->color;
 485
 486     return Ok;
 487 }
 488
 489 GpStatus WINGDIPAPI GdipSetLineBlend(GpLineGradient *brush,
 490     GDIPCONST REAL *blend, GDIPCONST REAL* positions, INT count)
 491 {
 492     static int calls;
 493
 494     if(!brush || !blend || !positions || count <= 0)
 495         return InvalidParameter;
 496
 497     if(!(calls++))
 498         FIXME("not implemented\n");
 499
 500     return Ok;
 501 }
 502
 503 GpStatus WINGDIPAPI GdipSetLineGammaCorrection(GpLineGradient *line,
 504     BOOL usegamma)
 505 {
 506     if(!line)
 507         return InvalidParameter;
 508
 509     line->gamma = usegamma;
 510
 511     return Ok;
 512 }
 513
 514 GpStatus WINGDIPAPI GdipSetLineSigmaBlend(GpLineGradient *line, REAL focus,
 515     REAL scale)
 516 {
 517     static int calls;
 518
 519     if(!line || focus < 0.0 || focus > 1.0 || scale < 0.0 || scale > 1.0)
 520         return InvalidParameter;
 521
 522     if(!(calls++))
 523         FIXME("not implemented\n");
 524
 525     return NotImplemented;
 526 }
 527
 528 GpStatus WINGDIPAPI GdipSetLineWrapMode(GpLineGradient *line,
 529     GpWrapMode wrap)
 530 {
 531     if(!line || wrap == WrapModeClamp)
 532         return InvalidParameter;
 533
 534     line->wrap = wrap;
 535
 536     return Ok;
 537 }
 538
 539 GpStatus WINGDIPAPI GdipSetPathGradientCenterColor(GpPathGradient *grad,
 540     ARGB argb)
 541 {
 542     if(!grad)
 543         return InvalidParameter;
 544
 545     grad->centercolor = argb;
 546     grad->brush.lb.lbColor = ARGB2COLORREF(argb);
 547
 548     DeleteObject(grad->brush.gdibrush);
 549     grad->brush.gdibrush = CreateSolidBrush(grad->brush.lb.lbColor);
 550
 551     return Ok;
 552 }
 553
 554 GpStatus WINGDIPAPI GdipSetPathGradientCenterPoint(GpPathGradient *grad,
 555     GpPointF *point)
 556 {
 557     if(!grad || !point)
 558         return InvalidParameter;
 559
 560     grad->center.X = point->X;
 561     grad->center.Y = point->Y;
 562
 563     return Ok;
 564 }
 565
 566 GpStatus WINGDIPAPI GdipSetPathGradientFocusScales(GpPathGradient *grad,
 567     REAL x, REAL y)
 568 {
 569     if(!grad)
 570         return InvalidParameter;
 571
 572     grad->focus.X = x;
 573     grad->focus.Y = y;
 574
 575     return Ok;
 576 }
 577
 578 GpStatus WINGDIPAPI GdipSetPathGradientGammaCorrection(GpPathGradient *grad,
 579     BOOL gamma)
 580 {
 581     if(!grad)
 582         return InvalidParameter;
 583
 584     grad->gamma = gamma;
 585
 586     return Ok;
 587 }
 588
 589 GpStatus WINGDIPAPI GdipSetPathGradientSigmaBlend(GpPathGradient *grad,
 590     REAL focus, REAL scale)
 591 {
 592     static int calls;
 593
 594     if(!grad || focus < 0.0 || focus > 1.0 || scale < 0.0 || scale > 1.0)
 595         return InvalidParameter;
 596
 597     if(!(calls++))
 598         FIXME("not implemented\n");
 599
 600     return NotImplemented;
 601 }
 602
 603 GpStatus WINGDIPAPI GdipSetPathGradientSurroundColorsWithCount(GpPathGradient
 604     *grad, ARGB *argb, INT *count)
 605 {
 606     static int calls;
 607
 608     if(!grad || !argb || !count || (*count <= 0) ||
 609         (*count > grad->pathdata.Count))
 610         return InvalidParameter;
 611
 612     if(!(calls++))
 613         FIXME("not implemented\n");
 614
 615     return NotImplemented;
 616 }
 617
 618 GpStatus WINGDIPAPI GdipSetPathGradientWrapMode(GpPathGradient *grad,
 619     GpWrapMode wrap)
 620 {
 621     if(!grad)
 622         return InvalidParameter;
 623
 624     grad->wrap = wrap;
 625
 626     return Ok;
 627 }
 628
 629 GpStatus WINGDIPAPI GdipSetSolidFillColor(GpSolidFill *sf, ARGB argb)
 630 {
 631     if(!sf)
 632         return InvalidParameter;
 633
 634     sf->color = argb;
 635     sf->brush.lb.lbColor = ARGB2COLORREF(argb);
 636
 637     DeleteObject(sf->brush.gdibrush);
 638     sf->brush.gdibrush = CreateSolidBrush(sf->brush.lb.lbColor);
 639
 640     return Ok;
 641 }
 642
 643 GpStatus WINGDIPAPI GdipSetTextureTransform(GpTexture *texture,
 644     GDIPCONST GpMatrix *matrix)
 645 {
 646     static int calls;
 647
 648     if(!texture || !matrix)
 649         return InvalidParameter;
 650
 651     if(!(calls++))
 652         FIXME("not implemented\n");
 653
 654     return Ok;
 655 }