git.oblomov.eu Git - wine/blob - dlls/gdiplus/graphics.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 #include <math.h>
  21 #include <limits.h>
  22
  23 #include "windef.h"
  24 #include "winbase.h"
  25 #include "winuser.h"
  26 #include "wingdi.h"
  27 #include "wine/unicode.h"
  28
  29 #define COBJMACROS
  30 #include "objbase.h"
  31 #include "ocidl.h"
  32 #include "olectl.h"
  33 #include "ole2.h"
  34
  35 #include "winreg.h"
  36 #include "shlwapi.h"
  37
  38 #include "gdiplus.h"
  39 #include "gdiplus_private.h"
  40 #include "wine/debug.h"
  41 #include "wine/list.h"
  42
  43 WINE_DEFAULT_DEBUG_CHANNEL(gdiplus);
  44
  45 /* looks-right constants */
  46 #define ANCHOR_WIDTH (2.0)
  47 #define MAX_ITERS (50)
  48
  49 /* Converts angle (in degrees) to x/y coordinates */
  50 static void deg2xy(REAL angle, REAL x_0, REAL y_0, REAL *x, REAL *y)
  51 {
  52     REAL radAngle, hypotenuse;
  53
  54     radAngle = deg2rad(angle);
  55     hypotenuse = 50.0; /* arbitrary */
  56
  57     *x = x_0 + cos(radAngle) * hypotenuse;
  58     *y = y_0 + sin(radAngle) * hypotenuse;
  59 }
  60
  61 /* Converts from gdiplus path point type to gdi path point type. */
  62 static BYTE convert_path_point_type(BYTE type)
  63 {
  64     BYTE ret;
  65
  66     switch(type & PathPointTypePathTypeMask){
  67         case PathPointTypeBezier:
  68             ret = PT_BEZIERTO;
  69             break;
  70         case PathPointTypeLine:
  71             ret = PT_LINETO;
  72             break;
  73         case PathPointTypeStart:
  74             ret = PT_MOVETO;
  75             break;
  76         default:
  77             ERR("Bad point type\n");
  78             return 0;
  79     }
  80
  81     if(type & PathPointTypeCloseSubpath)
  82         ret |= PT_CLOSEFIGURE;
  83
  84     return ret;
  85 }
  86
  87 static COLORREF get_gdi_brush_color(const GpBrush *brush)
  88 {
  89     ARGB argb;
  90
  91     switch (brush->bt)
  92     {
  93         case BrushTypeSolidColor:
  94         {
  95             const GpSolidFill *sf = (const GpSolidFill *)brush;
  96             argb = sf->color;
  97             break;
  98         }
  99         case BrushTypeHatchFill:
 100         {
 101             const GpHatch *hatch = (const GpHatch *)brush;
 102             argb = hatch->forecol;
 103             break;
 104         }
 105         case BrushTypeLinearGradient:
 106         {
 107             const GpLineGradient *line = (const GpLineGradient *)brush;
 108             argb = line->startcolor;
 109             break;
 110         }
 111         case BrushTypePathGradient:
 112         {
 113             const GpPathGradient *grad = (const GpPathGradient *)brush;
 114             argb = grad->centercolor;
 115             break;
 116         }
 117         default:
 118             FIXME("unhandled brush type %d\n", brush->bt);
 119             argb = 0;
 120             break;
 121     }
 122     return ARGB2COLORREF(argb);
 123 }
 124
 125 static HBITMAP create_hatch_bitmap(const GpHatch *hatch)
 126 {
 127     HBITMAP hbmp;
 128     BITMAPINFOHEADER bmih;
 129     DWORD *bits;
 130     int x, y;
 131
 132     bmih.biSize = sizeof(bmih);
 133     bmih.biWidth = 8;
 134     bmih.biHeight = 8;
 135     bmih.biPlanes = 1;
 136     bmih.biBitCount = 32;
 137     bmih.biCompression = BI_RGB;
 138     bmih.biSizeImage = 0;
 139
 140     hbmp = CreateDIBSection(0, (BITMAPINFO *)&bmih, DIB_RGB_COLORS, (void **)&bits, NULL, 0);
 141     if (hbmp)
 142     {
 143         const char *hatch_data;
 144
 145         if (get_hatch_data(hatch->hatchstyle, &hatch_data) == Ok)
 146         {
 147             for (y = 0; y < 8; y++)
 148             {
 149                 for (x = 0; x < 8; x++)
 150                 {
 151                     if (hatch_data[y] & (0x80 >> x))
 152                         bits[y * 8 + x] = hatch->forecol;
 153                     else
 154                         bits[y * 8 + x] = hatch->backcol;
 155                 }
 156             }
 157         }
 158         else
 159         {
 160             FIXME("Unimplemented hatch style %d\n", hatch->hatchstyle);
 161
 162             for (y = 0; y < 64; y++)
 163                 bits[y] = hatch->forecol;
 164         }
 165     }
 166
 167     return hbmp;
 168 }
 169
 170 static GpStatus create_gdi_logbrush(const GpBrush *brush, LOGBRUSH *lb)
 171 {
 172     switch (brush->bt)
 173     {
 174         case BrushTypeSolidColor:
 175         {
 176             const GpSolidFill *sf = (const GpSolidFill *)brush;
 177             lb->lbStyle = BS_SOLID;
 178             lb->lbColor = ARGB2COLORREF(sf->color);
 179             lb->lbHatch = 0;
 180             return Ok;
 181         }
 182
 183         case BrushTypeHatchFill:
 184         {
 185             const GpHatch *hatch = (const GpHatch *)brush;
 186             HBITMAP hbmp;
 187
 188             hbmp = create_hatch_bitmap(hatch);
 189             if (!hbmp) return OutOfMemory;
 190
 191             lb->lbStyle = BS_PATTERN;
 192             lb->lbColor = 0;
 193             lb->lbHatch = (ULONG_PTR)hbmp;
 194             return Ok;
 195         }
 196
 197         default:
 198             FIXME("unhandled brush type %d\n", brush->bt);
 199             lb->lbStyle = BS_SOLID;
 200             lb->lbColor = get_gdi_brush_color(brush);
 201             lb->lbHatch = 0;
 202             return Ok;
 203     }
 204 }
 205
 206 static GpStatus free_gdi_logbrush(LOGBRUSH *lb)
 207 {
 208     switch (lb->lbStyle)
 209     {
 210         case BS_PATTERN:
 211             DeleteObject((HGDIOBJ)(ULONG_PTR)lb->lbHatch);
 212             break;
 213     }
 214     return Ok;
 215 }
 216
 217 static HBRUSH create_gdi_brush(const GpBrush *brush)
 218 {
 219     LOGBRUSH lb;
 220     HBRUSH gdibrush;
 221
 222     if (create_gdi_logbrush(brush, &lb) != Ok) return 0;
 223
 224     gdibrush = CreateBrushIndirect(&lb);
 225     free_gdi_logbrush(&lb);
 226
 227     return gdibrush;
 228 }
 229
 230 static INT prepare_dc(GpGraphics *graphics, GpPen *pen)
 231 {
 232     LOGBRUSH lb;
 233     HPEN gdipen;
 234     REAL width;
 235     INT save_state, i, numdashes;
 236     GpPointF pt[2];
 237     DWORD dash_array[MAX_DASHLEN];
 238
 239     save_state = SaveDC(graphics->hdc);
 240
 241     EndPath(graphics->hdc);
 242
 243     if(pen->unit == UnitPixel){
 244         width = pen->width;
 245     }
 246     else{
 247         /* Get an estimate for the amount the pen width is affected by the world
 248          * transform. (This is similar to what some of the wine drivers do.) */
 249         pt[0].X = 0.0;
 250         pt[0].Y = 0.0;
 251         pt[1].X = 1.0;
 252         pt[1].Y = 1.0;
 253         GdipTransformMatrixPoints(graphics->worldtrans, pt, 2);
 254         width = sqrt((pt[1].X - pt[0].X) * (pt[1].X - pt[0].X) +
 255                      (pt[1].Y - pt[0].Y) * (pt[1].Y - pt[0].Y)) / sqrt(2.0);
 256
 257         width *= units_to_pixels(pen->width, pen->unit == UnitWorld ? graphics->unit : pen->unit, graphics->xres);
 258     }
 259
 260     if(pen->dash == DashStyleCustom){
 261         numdashes = min(pen->numdashes, MAX_DASHLEN);
 262
 263         TRACE("dashes are: ");
 264         for(i = 0; i < numdashes; i++){
 265             dash_array[i] = roundr(width * pen->dashes[i]);
 266             TRACE("%d, ", dash_array[i]);
 267         }
 268         TRACE("\n and the pen style is %x\n", pen->style);
 269
 270         create_gdi_logbrush(pen->brush, &lb);
 271         gdipen = ExtCreatePen(pen->style, roundr(width), &lb,
 272                               numdashes, dash_array);
 273         free_gdi_logbrush(&lb);
 274     }
 275     else
 276     {
 277         create_gdi_logbrush(pen->brush, &lb);
 278         gdipen = ExtCreatePen(pen->style, roundr(width), &lb, 0, NULL);
 279         free_gdi_logbrush(&lb);
 280     }
 281
 282     SelectObject(graphics->hdc, gdipen);
 283
 284     return save_state;
 285 }
 286
 287 static void restore_dc(GpGraphics *graphics, INT state)
 288 {
 289     DeleteObject(SelectObject(graphics->hdc, GetStockObject(NULL_PEN)));
 290     RestoreDC(graphics->hdc, state);
 291 }
 292
 293 static GpStatus get_graphics_transform(GpGraphics *graphics, GpCoordinateSpace dst_space,
 294         GpCoordinateSpace src_space, GpMatrix **matrix);
 295
 296 /* This helper applies all the changes that the points listed in ptf need in
 297  * order to be drawn on the device context.  In the end, this should include at
 298  * least:
 299  *  -scaling by page unit
 300  *  -applying world transformation
 301  *  -converting from float to int
 302  * Native gdiplus uses gdi32 to do all this (via SetMapMode, SetViewportExtEx,
 303  * SetWindowExtEx, SetWorldTransform, etc.) but we cannot because we are using
 304  * gdi to draw, and these functions would irreparably mess with line widths.
 305  */
 306 static void transform_and_round_points(GpGraphics *graphics, POINT *pti,
 307     GpPointF *ptf, INT count)
 308 {
 309     REAL scale_x, scale_y;
 310     GpMatrix *matrix;
 311     int i;
 312
 313     scale_x = units_to_pixels(1.0, graphics->unit, graphics->xres);
 314     scale_y = units_to_pixels(1.0, graphics->unit, graphics->yres);
 315
 316     /* apply page scale */
 317     if(graphics->unit != UnitDisplay)
 318     {
 319         scale_x *= graphics->scale;
 320         scale_y *= graphics->scale;
 321     }
 322
 323     GdipCloneMatrix(graphics->worldtrans, &matrix);
 324     GdipScaleMatrix(matrix, scale_x, scale_y, MatrixOrderAppend);
 325     GdipTransformMatrixPoints(matrix, ptf, count);
 326     GdipDeleteMatrix(matrix);
 327
 328     for(i = 0; i < count; i++){
 329         pti[i].x = roundr(ptf[i].X);
 330         pti[i].y = roundr(ptf[i].Y);
 331     }
 332 }
 333
 334 static void gdi_alpha_blend(GpGraphics *graphics, INT dst_x, INT dst_y, INT dst_width, INT dst_height,
 335                             HDC hdc, INT src_x, INT src_y, INT src_width, INT src_height)
 336 {
 337     if (GetDeviceCaps(graphics->hdc, SHADEBLENDCAPS) == SB_NONE)
 338     {
 339         TRACE("alpha blending not supported by device, fallback to StretchBlt\n");
 340
 341         StretchBlt(graphics->hdc, dst_x, dst_y, dst_width, dst_height,
 342                    hdc, src_x, src_y, src_width, src_height, SRCCOPY);
 343     }
 344     else
 345     {
 346         BLENDFUNCTION bf;
 347
 348         bf.BlendOp = AC_SRC_OVER;
 349         bf.BlendFlags = 0;
 350         bf.SourceConstantAlpha = 255;
 351         bf.AlphaFormat = AC_SRC_ALPHA;
 352
 353         GdiAlphaBlend(graphics->hdc, dst_x, dst_y, dst_width, dst_height,
 354                       hdc, src_x, src_y, src_width, src_height, bf);
 355     }
 356 }
 357
 358 /* Draw non-premultiplied ARGB data to the given graphics object */
 359 static GpStatus alpha_blend_pixels(GpGraphics *graphics, INT dst_x, INT dst_y,
 360     const BYTE *src, INT src_width, INT src_height, INT src_stride)
 361 {
 362     if (graphics->image && graphics->image->type == ImageTypeBitmap)
 363     {
 364         GpBitmap *dst_bitmap = (GpBitmap*)graphics->image;
 365         INT x, y;
 366
 367         for (x=0; x<src_width; x++)
 368         {
 369             for (y=0; y<src_height; y++)
 370             {
 371                 ARGB dst_color, src_color;
 372                 GdipBitmapGetPixel(dst_bitmap, x+dst_x, y+dst_y, &dst_color);
 373                 src_color = ((ARGB*)(src + src_stride * y))[x];
 374                 GdipBitmapSetPixel(dst_bitmap, x+dst_x, y+dst_y, color_over(dst_color, src_color));
 375             }
 376         }
 377
 378         return Ok;
 379     }
 380     else if (graphics->image && graphics->image->type == ImageTypeMetafile)
 381     {
 382         ERR("This should not be used for metafiles; fix caller\n");
 383         return NotImplemented;
 384     }
 385     else
 386     {
 387         HDC hdc;
 388         HBITMAP hbitmap;
 389         BITMAPINFOHEADER bih;
 390         BYTE *temp_bits;
 391
 392         hdc = CreateCompatibleDC(0);
 393
 394         bih.biSize = sizeof(BITMAPINFOHEADER);
 395         bih.biWidth = src_width;
 396         bih.biHeight = -src_height;
 397         bih.biPlanes = 1;
 398         bih.biBitCount = 32;
 399         bih.biCompression = BI_RGB;
 400         bih.biSizeImage = 0;
 401         bih.biXPelsPerMeter = 0;
 402         bih.biYPelsPerMeter = 0;
 403         bih.biClrUsed = 0;
 404         bih.biClrImportant = 0;
 405
 406         hbitmap = CreateDIBSection(hdc, (BITMAPINFO*)&bih, DIB_RGB_COLORS,
 407             (void**)&temp_bits, NULL, 0);
 408
 409         convert_32bppARGB_to_32bppPARGB(src_width, src_height, temp_bits,
 410             4 * src_width, src, src_stride);
 411
 412         SelectObject(hdc, hbitmap);
 413         gdi_alpha_blend(graphics, dst_x, dst_y, src_width, src_height,
 414                         hdc, 0, 0, src_width, src_height);
 415         DeleteDC(hdc);
 416         DeleteObject(hbitmap);
 417
 418         return Ok;
 419     }
 420 }
 421
 422 static GpStatus alpha_blend_pixels_hrgn(GpGraphics *graphics, INT dst_x, INT dst_y,
 423     const BYTE *src, INT src_width, INT src_height, INT src_stride, HRGN hregion)
 424 {
 425     GpStatus stat=Ok;
 426
 427     if (graphics->image && graphics->image->type == ImageTypeBitmap)
 428     {
 429         int i, size;
 430         RGNDATA *rgndata;
 431         RECT *rects;
 432
 433         size = GetRegionData(hregion, 0, NULL);
 434
 435         rgndata = GdipAlloc(size);
 436         if (!rgndata)
 437             return OutOfMemory;
 438
 439         GetRegionData(hregion, size, rgndata);
 440
 441         rects = (RECT*)&rgndata->Buffer;
 442
 443         for (i=0; stat == Ok && i<rgndata->rdh.nCount; i++)
 444         {
 445             stat = alpha_blend_pixels(graphics, rects[i].left, rects[i].top,
 446                 &src[(rects[i].left - dst_x) * 4 + (rects[i].top - dst_y) * src_stride],
 447                 rects[i].right - rects[i].left, rects[i].bottom - rects[i].top,
 448                 src_stride);
 449         }
 450
 451         GdipFree(rgndata);
 452
 453         return stat;
 454     }
 455     else if (graphics->image && graphics->image->type == ImageTypeMetafile)
 456     {
 457         ERR("This should not be used for metafiles; fix caller\n");
 458         return NotImplemented;
 459     }
 460     else
 461     {
 462         int save;
 463
 464         save = SaveDC(graphics->hdc);
 465
 466         ExtSelectClipRgn(graphics->hdc, hregion, RGN_AND);
 467
 468         stat = alpha_blend_pixels(graphics, dst_x, dst_y, src, src_width,
 469             src_height, src_stride);
 470
 471         RestoreDC(graphics->hdc, save);
 472
 473         return stat;
 474     }
 475 }
 476
 477 static ARGB blend_colors(ARGB start, ARGB end, REAL position)
 478 {
 479     ARGB result=0;
 480     ARGB i;
 481     INT a1, a2, a3;
 482
 483     a1 = (start >> 24) & 0xff;
 484     a2 = (end >> 24) & 0xff;
 485
 486     a3 = (int)(a1*(1.0f - position)+a2*(position));
 487
 488     result |= a3 << 24;
 489
 490     for (i=0xff; i<=0xff0000; i = i << 8)
 491         result |= (int)((start&i)*(1.0f - position)+(end&i)*(position))&i;
 492     return result;
 493 }
 494
 495 static ARGB blend_line_gradient(GpLineGradient* brush, REAL position)
 496 {
 497     REAL blendfac;
 498
 499     /* clamp to between 0.0 and 1.0, using the wrap mode */
 500     if (brush->wrap == WrapModeTile)
 501     {
 502         position = fmodf(position, 1.0f);
 503         if (position < 0.0f) position += 1.0f;
 504     }
 505     else /* WrapModeFlip* */
 506     {
 507         position = fmodf(position, 2.0f);
 508         if (position < 0.0f) position += 2.0f;
 509         if (position > 1.0f) position = 2.0f - position;
 510     }
 511
 512     if (brush->blendcount == 1)
 513         blendfac = position;
 514     else
 515     {
 516         int i=1;
 517         REAL left_blendpos, left_blendfac, right_blendpos, right_blendfac;
 518         REAL range;
 519
 520         /* locate the blend positions surrounding this position */
 521         while (position > brush->blendpos[i])
 522             i++;
 523
 524         /* interpolate between the blend positions */
 525         left_blendpos = brush->blendpos[i-1];
 526         left_blendfac = brush->blendfac[i-1];
 527         right_blendpos = brush->blendpos[i];
 528         right_blendfac = brush->blendfac[i];
 529         range = right_blendpos - left_blendpos;
 530         blendfac = (left_blendfac * (right_blendpos - position) +
 531                     right_blendfac * (position - left_blendpos)) / range;
 532     }
 533
 534     if (brush->pblendcount == 0)
 535         return blend_colors(brush->startcolor, brush->endcolor, blendfac);
 536     else
 537     {
 538         int i=1;
 539         ARGB left_blendcolor, right_blendcolor;
 540         REAL left_blendpos, right_blendpos;
 541
 542         /* locate the blend colors surrounding this position */
 543         while (blendfac > brush->pblendpos[i])
 544             i++;
 545
 546         /* interpolate between the blend colors */
 547         left_blendpos = brush->pblendpos[i-1];
 548         left_blendcolor = brush->pblendcolor[i-1];
 549         right_blendpos = brush->pblendpos[i];
 550         right_blendcolor = brush->pblendcolor[i];
 551         blendfac = (blendfac - left_blendpos) / (right_blendpos - left_blendpos);
 552         return blend_colors(left_blendcolor, right_blendcolor, blendfac);
 553     }
 554 }
 555
 556 static ARGB transform_color(ARGB color, const ColorMatrix *matrix)
 557 {
 558     REAL val[5], res[4];
 559     int i, j;
 560     unsigned char a, r, g, b;
 561
 562     val[0] = ((color >> 16) & 0xff) / 255.0; /* red */
 563     val[1] = ((color >> 8) & 0xff) / 255.0; /* green */
 564     val[2] = (color & 0xff) / 255.0; /* blue */
 565     val[3] = ((color >> 24) & 0xff) / 255.0; /* alpha */
 566     val[4] = 1.0; /* translation */
 567
 568     for (i=0; i<4; i++)
 569     {
 570         res[i] = 0.0;
 571
 572         for (j=0; j<5; j++)
 573             res[i] += matrix->m[j][i] * val[j];
 574     }
 575
 576     a = min(max(floorf(res[3]*255.0), 0.0), 255.0);
 577     r = min(max(floorf(res[0]*255.0), 0.0), 255.0);
 578     g = min(max(floorf(res[1]*255.0), 0.0), 255.0);
 579     b = min(max(floorf(res[2]*255.0), 0.0), 255.0);
 580
 581     return (a << 24) | (r << 16) | (g << 8) | b;
 582 }
 583
 584 static int color_is_gray(ARGB color)
 585 {
 586     unsigned char r, g, b;
 587
 588     r = (color >> 16) & 0xff;
 589     g = (color >> 8) & 0xff;
 590     b = color & 0xff;
 591
 592     return (r == g) && (g == b);
 593 }
 594
 595 static void apply_image_attributes(const GpImageAttributes *attributes, LPBYTE data,
 596     UINT width, UINT height, INT stride, ColorAdjustType type)
 597 {
 598     UINT x, y, i;
 599
 600     if (attributes->colorkeys[type].enabled ||
 601         attributes->colorkeys[ColorAdjustTypeDefault].enabled)
 602     {
 603         const struct color_key *key;
 604         BYTE min_blue, min_green, min_red;
 605         BYTE max_blue, max_green, max_red;
 606
 607         if (attributes->colorkeys[type].enabled)
 608             key = &attributes->colorkeys[type];
 609         else
 610             key = &attributes->colorkeys[ColorAdjustTypeDefault];
 611
 612         min_blue = key->low&0xff;
 613         min_green = (key->low>>8)&0xff;
 614         min_red = (key->low>>16)&0xff;
 615
 616         max_blue = key->high&0xff;
 617         max_green = (key->high>>8)&0xff;
 618         max_red = (key->high>>16)&0xff;
 619
 620         for (x=0; x<width; x++)
 621             for (y=0; y<height; y++)
 622             {
 623                 ARGB *src_color;
 624                 BYTE blue, green, red;
 625                 src_color = (ARGB*)(data + stride * y + sizeof(ARGB) * x);
 626                 blue = *src_color&0xff;
 627                 green = (*src_color>>8)&0xff;
 628                 red = (*src_color>>16)&0xff;
 629                 if (blue >= min_blue && green >= min_green && red >= min_red &&
 630                     blue <= max_blue && green <= max_green && red <= max_red)
 631                     *src_color = 0x00000000;
 632             }
 633     }
 634
 635     if (attributes->colorremaptables[type].enabled ||
 636         attributes->colorremaptables[ColorAdjustTypeDefault].enabled)
 637     {
 638         const struct color_remap_table *table;
 639
 640         if (attributes->colorremaptables[type].enabled)
 641             table = &attributes->colorremaptables[type];
 642         else
 643             table = &attributes->colorremaptables[ColorAdjustTypeDefault];
 644
 645         for (x=0; x<width; x++)
 646             for (y=0; y<height; y++)
 647             {
 648                 ARGB *src_color;
 649                 src_color = (ARGB*)(data + stride * y + sizeof(ARGB) * x);
 650                 for (i=0; i<table->mapsize; i++)
 651                 {
 652                     if (*src_color == table->colormap[i].oldColor.Argb)
 653                     {
 654                         *src_color = table->colormap[i].newColor.Argb;
 655                         break;
 656                     }
 657                 }
 658             }
 659     }
 660
 661     if (attributes->colormatrices[type].enabled ||
 662         attributes->colormatrices[ColorAdjustTypeDefault].enabled)
 663     {
 664         const struct color_matrix *colormatrices;
 665
 666         if (attributes->colormatrices[type].enabled)
 667             colormatrices = &attributes->colormatrices[type];
 668         else
 669             colormatrices = &attributes->colormatrices[ColorAdjustTypeDefault];
 670
 671         for (x=0; x<width; x++)
 672             for (y=0; y<height; y++)
 673             {
 674                 ARGB *src_color;
 675                 src_color = (ARGB*)(data + stride * y + sizeof(ARGB) * x);
 676
 677                 if (colormatrices->flags == ColorMatrixFlagsDefault ||
 678                     !color_is_gray(*src_color))
 679                 {
 680                     *src_color = transform_color(*src_color, &colormatrices->colormatrix);
 681                 }
 682                 else if (colormatrices->flags == ColorMatrixFlagsAltGray)
 683                 {
 684                     *src_color = transform_color(*src_color, &colormatrices->graymatrix);
 685                 }
 686             }
 687     }
 688
 689     if (attributes->gamma_enabled[type] ||
 690         attributes->gamma_enabled[ColorAdjustTypeDefault])
 691     {
 692         REAL gamma;
 693
 694         if (attributes->gamma_enabled[type])
 695             gamma = attributes->gamma[type];
 696         else
 697             gamma = attributes->gamma[ColorAdjustTypeDefault];
 698
 699         for (x=0; x<width; x++)
 700             for (y=0; y<height; y++)
 701             {
 702                 ARGB *src_color;
 703                 BYTE blue, green, red;
 704                 src_color = (ARGB*)(data + stride * y + sizeof(ARGB) * x);
 705
 706                 blue = *src_color&0xff;
 707                 green = (*src_color>>8)&0xff;
 708                 red = (*src_color>>16)&0xff;
 709
 710                 /* FIXME: We should probably use a table for this. */
 711                 blue = floorf(powf(blue / 255.0, gamma) * 255.0);
 712                 green = floorf(powf(green / 255.0, gamma) * 255.0);
 713                 red = floorf(powf(red / 255.0, gamma) * 255.0);
 714
 715                 *src_color = (*src_color & 0xff000000) | (red << 16) | (green << 8) | blue;
 716             }
 717     }
 718 }
 719
 720 /* Given a bitmap and its source rectangle, find the smallest rectangle in the
 721  * bitmap that contains all the pixels we may need to draw it. */
 722 static void get_bitmap_sample_size(InterpolationMode interpolation, WrapMode wrap,
 723     GpBitmap* bitmap, REAL srcx, REAL srcy, REAL srcwidth, REAL srcheight,
 724     GpRect *rect)
 725 {
 726     INT left, top, right, bottom;
 727
 728     switch (interpolation)
 729     {
 730     case InterpolationModeHighQualityBilinear:
 731     case InterpolationModeHighQualityBicubic:
 732     /* FIXME: Include a greater range for the prefilter? */
 733     case InterpolationModeBicubic:
 734     case InterpolationModeBilinear:
 735         left = (INT)(floorf(srcx));
 736         top = (INT)(floorf(srcy));
 737         right = (INT)(ceilf(srcx+srcwidth));
 738         bottom = (INT)(ceilf(srcy+srcheight));
 739         break;
 740     case InterpolationModeNearestNeighbor:
 741     default:
 742         left = roundr(srcx);
 743         top = roundr(srcy);
 744         right = roundr(srcx+srcwidth);
 745         bottom = roundr(srcy+srcheight);
 746         break;
 747     }
 748
 749     if (wrap == WrapModeClamp)
 750     {
 751         if (left < 0)
 752             left = 0;
 753         if (top < 0)
 754             top = 0;
 755         if (right >= bitmap->width)
 756             right = bitmap->width-1;
 757         if (bottom >= bitmap->height)
 758             bottom = bitmap->height-1;
 759     }
 760     else
 761     {
 762         /* In some cases we can make the rectangle smaller here, but the logic
 763          * is hard to get right, and tiling suggests we're likely to use the
 764          * entire source image. */
 765         if (left < 0 || right >= bitmap->width)
 766         {
 767             left = 0;
 768             right = bitmap->width-1;
 769         }
 770
 771         if (top < 0 || bottom >= bitmap->height)
 772         {
 773             top = 0;
 774             bottom = bitmap->height-1;
 775         }
 776     }
 777
 778     rect->X = left;
 779     rect->Y = top;
 780     rect->Width = right - left + 1;
 781     rect->Height = bottom - top + 1;
 782 }
 783
 784 static ARGB sample_bitmap_pixel(GDIPCONST GpRect *src_rect, LPBYTE bits, UINT width,
 785     UINT height, INT x, INT y, GDIPCONST GpImageAttributes *attributes)
 786 {
 787     if (attributes->wrap == WrapModeClamp)
 788     {
 789         if (x < 0 || y < 0 || x >= width || y >= height)
 790             return attributes->outside_color;
 791     }
 792     else
 793     {
 794         /* Tiling. Make sure co-ordinates are positive as it simplifies the math. */
 795         if (x < 0)
 796             x = width*2 + x % (width * 2);
 797         if (y < 0)
 798             y = height*2 + y % (height * 2);
 799
 800         if ((attributes->wrap & 1) == 1)
 801         {
 802             /* Flip X */
 803             if ((x / width) % 2 == 0)
 804                 x = x % width;
 805             else
 806                 x = width - 1 - x % width;
 807         }
 808         else
 809             x = x % width;
 810
 811         if ((attributes->wrap & 2) == 2)
 812         {
 813             /* Flip Y */
 814             if ((y / height) % 2 == 0)
 815                 y = y % height;
 816             else
 817                 y = height - 1 - y % height;
 818         }
 819         else
 820             y = y % height;
 821     }
 822
 823     if (x < src_rect->X || y < src_rect->Y || x >= src_rect->X + src_rect->Width || y >= src_rect->Y + src_rect->Height)
 824     {
 825         ERR("out of range pixel requested\n");
 826         return 0xffcd0084;
 827     }
 828
 829     return ((DWORD*)(bits))[(x - src_rect->X) + (y - src_rect->Y) * src_rect->Width];
 830 }
 831
 832 static ARGB resample_bitmap_pixel(GDIPCONST GpRect *src_rect, LPBYTE bits, UINT width,
 833     UINT height, GpPointF *point, GDIPCONST GpImageAttributes *attributes,
 834     InterpolationMode interpolation)
 835 {
 836     static int fixme;
 837
 838     switch (interpolation)
 839     {
 840     default:
 841         if (!fixme++)
 842             FIXME("Unimplemented interpolation %i\n", interpolation);
 843         /* fall-through */
 844     case InterpolationModeBilinear:
 845     {
 846         REAL leftxf, topyf;
 847         INT leftx, rightx, topy, bottomy;
 848         ARGB topleft, topright, bottomleft, bottomright;
 849         ARGB top, bottom;
 850         float x_offset;
 851
 852         leftxf = floorf(point->X);
 853         leftx = (INT)leftxf;
 854         rightx = (INT)ceilf(point->X);
 855         topyf = floorf(point->Y);
 856         topy = (INT)topyf;
 857         bottomy = (INT)ceilf(point->Y);
 858
 859         if (leftx == rightx && topy == bottomy)
 860             return sample_bitmap_pixel(src_rect, bits, width, height,
 861                 leftx, topy, attributes);
 862
 863         topleft = sample_bitmap_pixel(src_rect, bits, width, height,
 864             leftx, topy, attributes);
 865         topright = sample_bitmap_pixel(src_rect, bits, width, height,
 866             rightx, topy, attributes);
 867         bottomleft = sample_bitmap_pixel(src_rect, bits, width, height,
 868             leftx, bottomy, attributes);
 869         bottomright = sample_bitmap_pixel(src_rect, bits, width, height,
 870             rightx, bottomy, attributes);
 871
 872         x_offset = point->X - leftxf;
 873         top = blend_colors(topleft, topright, x_offset);
 874         bottom = blend_colors(bottomleft, bottomright, x_offset);
 875
 876         return blend_colors(top, bottom, point->Y - topyf);
 877     }
 878     case InterpolationModeNearestNeighbor:
 879         return sample_bitmap_pixel(src_rect, bits, width, height,
 880             roundr(point->X), roundr(point->Y), attributes);
 881     }
 882 }
 883
 884 static REAL intersect_line_scanline(const GpPointF *p1, const GpPointF *p2, REAL y)
 885 {
 886     return (p1->X - p2->X) * (p2->Y - y) / (p2->Y - p1->Y) + p2->X;
 887 }
 888
 889 static INT brush_can_fill_path(GpBrush *brush)
 890 {
 891     switch (brush->bt)
 892     {
 893     case BrushTypeSolidColor:
 894         return 1;
 895     case BrushTypeHatchFill:
 896     {
 897         GpHatch *hatch = (GpHatch*)brush;
 898         return ((hatch->forecol & 0xff000000) == 0xff000000) &&
 899                ((hatch->backcol & 0xff000000) == 0xff000000);
 900     }
 901     case BrushTypeLinearGradient:
 902     case BrushTypeTextureFill:
 903     /* Gdi32 isn't much help with these, so we should use brush_fill_pixels instead. */
 904     default:
 905         return 0;
 906     }
 907 }
 908
 909 static void brush_fill_path(GpGraphics *graphics, GpBrush* brush)
 910 {
 911     switch (brush->bt)
 912     {
 913     case BrushTypeSolidColor:
 914     {
 915         GpSolidFill *fill = (GpSolidFill*)brush;
 916         HBITMAP bmp = ARGB2BMP(fill->color);
 917
 918         if (bmp)
 919         {
 920             RECT rc;
 921             /* partially transparent fill */
 922
 923             SelectClipPath(graphics->hdc, RGN_AND);
 924             if (GetClipBox(graphics->hdc, &rc) != NULLREGION)
 925             {
 926                 HDC hdc = CreateCompatibleDC(NULL);
 927
 928                 if (!hdc) break;
 929
 930                 SelectObject(hdc, bmp);
 931                 gdi_alpha_blend(graphics, rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top,
 932                                 hdc, 0, 0, 1, 1);
 933                 DeleteDC(hdc);
 934             }
 935
 936             DeleteObject(bmp);
 937             break;
 938         }
 939         /* else fall through */
 940     }
 941     default:
 942     {
 943         HBRUSH gdibrush, old_brush;
 944
 945         gdibrush = create_gdi_brush(brush);
 946         if (!gdibrush) return;
 947
 948         old_brush = SelectObject(graphics->hdc, gdibrush);
 949         FillPath(graphics->hdc);
 950         SelectObject(graphics->hdc, old_brush);
 951         DeleteObject(gdibrush);
 952         break;
 953     }
 954     }
 955 }
 956
 957 static INT brush_can_fill_pixels(GpBrush *brush)
 958 {
 959     switch (brush->bt)
 960     {
 961     case BrushTypeSolidColor:
 962     case BrushTypeHatchFill:
 963     case BrushTypeLinearGradient:
 964     case BrushTypeTextureFill:
 965     case BrushTypePathGradient:
 966         return 1;
 967     default:
 968         return 0;
 969     }
 970 }
 971
 972 static GpStatus brush_fill_pixels(GpGraphics *graphics, GpBrush *brush,
 973     DWORD *argb_pixels, GpRect *fill_area, UINT cdwStride)
 974 {
 975     switch (brush->bt)
 976     {
 977     case BrushTypeSolidColor:
 978     {
 979         int x, y;
 980         GpSolidFill *fill = (GpSolidFill*)brush;
 981         for (x=0; x<fill_area->Width; x++)
 982             for (y=0; y<fill_area->Height; y++)
 983                 argb_pixels[x + y*cdwStride] = fill->color;
 984         return Ok;
 985     }
 986     case BrushTypeHatchFill:
 987     {
 988         int x, y;
 989         GpHatch *fill = (GpHatch*)brush;
 990         const char *hatch_data;
 991
 992         if (get_hatch_data(fill->hatchstyle, &hatch_data) != Ok)
 993             return NotImplemented;
 994
 995         for (x=0; x<fill_area->Width; x++)
 996             for (y=0; y<fill_area->Height; y++)
 997             {
 998                 int hx, hy;
 999
1000                 /* FIXME: Account for the rendering origin */
1001                 hx = (x + fill_area->X) % 8;
1002                 hy = (y + fill_area->Y) % 8;
1003
1004                 if ((hatch_data[7-hy] & (0x80 >> hx)) != 0)
1005                     argb_pixels[x + y*cdwStride] = fill->forecol;
1006                 else
1007                     argb_pixels[x + y*cdwStride] = fill->backcol;
1008             }
1009
1010         return Ok;
1011     }
1012     case BrushTypeLinearGradient:
1013     {
1014         GpLineGradient *fill = (GpLineGradient*)brush;
1015         GpPointF draw_points[3], line_points[3];
1016         GpStatus stat;
1017         static const GpRectF box_1 = { 0.0, 0.0, 1.0, 1.0 };
1018         GpMatrix *world_to_gradient; /* FIXME: Store this in the brush? */
1019         int x, y;
1020
1021         draw_points[0].X = fill_area->X;
1022         draw_points[0].Y = fill_area->Y;
1023         draw_points[1].X = fill_area->X+1;
1024         draw_points[1].Y = fill_area->Y;
1025         draw_points[2].X = fill_area->X;
1026         draw_points[2].Y = fill_area->Y+1;
1027
1028         /* Transform the points to a co-ordinate space where X is the point's
1029          * position in the gradient, 0.0 being the start point and 1.0 the
1030          * end point. */
1031         stat = GdipTransformPoints(graphics, CoordinateSpaceWorld,
1032             CoordinateSpaceDevice, draw_points, 3);
1033
1034         if (stat == Ok)
1035         {
1036             line_points[0] = fill->startpoint;
1037             line_points[1] = fill->endpoint;
1038             line_points[2].X = fill->startpoint.X + (fill->startpoint.Y - fill->endpoint.Y);
1039             line_points[2].Y = fill->startpoint.Y + (fill->endpoint.X - fill->startpoint.X);
1040
1041             stat = GdipCreateMatrix3(&box_1, line_points, &world_to_gradient);
1042         }
1043
1044         if (stat == Ok)
1045         {
1046             stat = GdipInvertMatrix(world_to_gradient);
1047
1048             if (stat == Ok)
1049                 stat = GdipTransformMatrixPoints(world_to_gradient, draw_points, 3);
1050
1051             GdipDeleteMatrix(world_to_gradient);
1052         }
1053
1054         if (stat == Ok)
1055         {
1056             REAL x_delta = draw_points[1].X - draw_points[0].X;
1057             REAL y_delta = draw_points[2].X - draw_points[0].X;
1058
1059             for (y=0; y<fill_area->Height; y++)
1060             {
1061                 for (x=0; x<fill_area->Width; x++)
1062                 {
1063                     REAL pos = draw_points[0].X + x * x_delta + y * y_delta;
1064
1065                     argb_pixels[x + y*cdwStride] = blend_line_gradient(fill, pos);
1066                 }
1067             }
1068         }
1069
1070         return stat;
1071     }
1072     case BrushTypeTextureFill:
1073     {
1074         GpTexture *fill = (GpTexture*)brush;
1075         GpPointF draw_points[3];
1076         GpStatus stat;
1077         GpMatrix *world_to_texture;
1078         int x, y;
1079         GpBitmap *bitmap;
1080         int src_stride;
1081         GpRect src_area;
1082
1083         if (fill->image->type != ImageTypeBitmap)
1084         {
1085             FIXME("metafile texture brushes not implemented\n");
1086             return NotImplemented;
1087         }
1088
1089         bitmap = (GpBitmap*)fill->image;
1090         src_stride = sizeof(ARGB) * bitmap->width;
1091
1092         src_area.X = src_area.Y = 0;
1093         src_area.Width = bitmap->width;
1094         src_area.Height = bitmap->height;
1095
1096         draw_points[0].X = fill_area->X;
1097         draw_points[0].Y = fill_area->Y;
1098         draw_points[1].X = fill_area->X+1;
1099         draw_points[1].Y = fill_area->Y;
1100         draw_points[2].X = fill_area->X;
1101         draw_points[2].Y = fill_area->Y+1;
1102
1103         /* Transform the points to the co-ordinate space of the bitmap. */
1104         stat = GdipTransformPoints(graphics, CoordinateSpaceWorld,
1105             CoordinateSpaceDevice, draw_points, 3);
1106
1107         if (stat == Ok)
1108         {
1109             stat = GdipCloneMatrix(fill->transform, &world_to_texture);
1110         }
1111
1112         if (stat == Ok)
1113         {
1114             stat = GdipInvertMatrix(world_to_texture);
1115
1116             if (stat == Ok)
1117                 stat = GdipTransformMatrixPoints(world_to_texture, draw_points, 3);
1118
1119             GdipDeleteMatrix(world_to_texture);
1120         }
1121
1122         if (stat == Ok && !fill->bitmap_bits)
1123         {
1124             BitmapData lockeddata;
1125
1126             fill->bitmap_bits = GdipAlloc(sizeof(ARGB) * bitmap->width * bitmap->height);
1127             if (!fill->bitmap_bits)
1128                 stat = OutOfMemory;
1129
1130             if (stat == Ok)
1131             {
1132                 lockeddata.Width = bitmap->width;
1133                 lockeddata.Height = bitmap->height;
1134                 lockeddata.Stride = src_stride;
1135                 lockeddata.PixelFormat = PixelFormat32bppARGB;
1136                 lockeddata.Scan0 = fill->bitmap_bits;
1137
1138                 stat = GdipBitmapLockBits(bitmap, &src_area, ImageLockModeRead|ImageLockModeUserInputBuf,
1139                     PixelFormat32bppARGB, &lockeddata);
1140             }
1141
1142             if (stat == Ok)
1143                 stat = GdipBitmapUnlockBits(bitmap, &lockeddata);
1144
1145             if (stat == Ok)
1146                 apply_image_attributes(fill->imageattributes, fill->bitmap_bits,
1147                     bitmap->width, bitmap->height,
1148                     src_stride, ColorAdjustTypeBitmap);
1149
1150             if (stat != Ok)
1151             {
1152                 GdipFree(fill->bitmap_bits);
1153                 fill->bitmap_bits = NULL;
1154             }
1155         }
1156
1157         if (stat == Ok)
1158         {
1159             REAL x_dx = draw_points[1].X - draw_points[0].X;
1160             REAL x_dy = draw_points[1].Y - draw_points[0].Y;
1161             REAL y_dx = draw_points[2].X - draw_points[0].X;
1162             REAL y_dy = draw_points[2].Y - draw_points[0].Y;
1163
1164             for (y=0; y<fill_area->Height; y++)
1165             {
1166                 for (x=0; x<fill_area->Width; x++)
1167                 {
1168                     GpPointF point;
1169                     point.X = draw_points[0].X + x * x_dx + y * y_dx;
1170                     point.Y = draw_points[0].Y + y * x_dy + y * y_dy;
1171
1172                     argb_pixels[x + y*cdwStride] = resample_bitmap_pixel(
1173                         &src_area, fill->bitmap_bits, bitmap->width, bitmap->height,
1174                         &point, fill->imageattributes, graphics->interpolation);
1175                 }
1176             }
1177         }
1178
1179         return stat;
1180     }
1181     case BrushTypePathGradient:
1182     {
1183         GpPathGradient *fill = (GpPathGradient*)brush;
1184         GpPath *flat_path;
1185         GpMatrix *world_to_device;
1186         GpStatus stat;
1187         int i, figure_start=0;
1188         GpPointF start_point, end_point, center_point;
1189         BYTE type;
1190         REAL min_yf, max_yf, line1_xf, line2_xf;
1191         INT min_y, max_y, min_x, max_x;
1192         INT x, y;
1193         ARGB outer_color;
1194         static int transform_fixme_once;
1195
1196         if (fill->focus.X != 0.0 || fill->focus.Y != 0.0)
1197         {
1198             static int once;
1199             if (!once++)
1200                 FIXME("path gradient focus not implemented\n");
1201         }
1202
1203         if (fill->gamma)
1204         {
1205             static int once;
1206             if (!once++)
1207                 FIXME("path gradient gamma correction not implemented\n");
1208         }
1209
1210         if (fill->blendcount)
1211         {
1212             static int once;
1213             if (!once++)
1214                 FIXME("path gradient blend not implemented\n");
1215         }
1216
1217         if (fill->pblendcount)
1218         {
1219             static int once;
1220             if (!once++)
1221                 FIXME("path gradient preset blend not implemented\n");
1222         }
1223
1224         if (!transform_fixme_once)
1225         {
1226             BOOL is_identity=TRUE;
1227             GdipIsMatrixIdentity(fill->transform, &is_identity);
1228             if (!is_identity)
1229             {
1230                 FIXME("path gradient transform not implemented\n");
1231                 transform_fixme_once = 1;
1232             }
1233         }
1234
1235         stat = GdipClonePath(fill->path, &flat_path);
1236
1237         if (stat != Ok)
1238             return stat;
1239
1240         stat = get_graphics_transform(graphics, CoordinateSpaceDevice,
1241             CoordinateSpaceWorld, &world_to_device);
1242         if (stat == Ok)
1243         {
1244             stat = GdipTransformPath(flat_path, world_to_device);
1245
1246             if (stat == Ok)
1247             {
1248                 center_point = fill->center;
1249                 stat = GdipTransformMatrixPoints(world_to_device, &center_point, 1);
1250             }
1251
1252             if (stat == Ok)
1253                 stat = GdipFlattenPath(flat_path, NULL, 0.5);
1254
1255             GdipDeleteMatrix(world_to_device);
1256         }
1257
1258         if (stat != Ok)
1259         {
1260             GdipDeletePath(flat_path);
1261             return stat;
1262         }
1263
1264         for (i=0; i<flat_path->pathdata.Count; i++)
1265         {
1266             int start_center_line=0, end_center_line=0;
1267             int seen_start=0, seen_end=0, seen_center=0;
1268             REAL center_distance;
1269             ARGB start_color, end_color;
1270             REAL dy, dx;
1271
1272             type = flat_path->pathdata.Types[i];
1273
1274             if ((type&PathPointTypePathTypeMask) == PathPointTypeStart)
1275                 figure_start = i;
1276
1277             start_point = flat_path->pathdata.Points[i];
1278
1279             start_color = fill->surroundcolors[min(i, fill->surroundcolorcount-1)];
1280
1281             if ((type&PathPointTypeCloseSubpath) == PathPointTypeCloseSubpath || i+1 >= flat_path->pathdata.Count)
1282             {
1283                 end_point = flat_path->pathdata.Points[figure_start];
1284                 end_color = fill->surroundcolors[min(figure_start, fill->surroundcolorcount-1)];
1285             }
1286             else if ((flat_path->pathdata.Types[i+1] & PathPointTypePathTypeMask) == PathPointTypeLine)
1287             {
1288                 end_point = flat_path->pathdata.Points[i+1];
1289                 end_color = fill->surroundcolors[min(i+1, fill->surroundcolorcount-1)];
1290             }
1291             else
1292                 continue;
1293
1294             outer_color = start_color;
1295
1296             min_yf = center_point.Y;
1297             if (min_yf > start_point.Y) min_yf = start_point.Y;
1298             if (min_yf > end_point.Y) min_yf = end_point.Y;
1299
1300             if (min_yf < fill_area->Y)
1301                 min_y = fill_area->Y;
1302             else
1303                 min_y = (INT)ceil(min_yf);
1304
1305             max_yf = center_point.Y;
1306             if (max_yf < start_point.Y) max_yf = start_point.Y;
1307             if (max_yf < end_point.Y) max_yf = end_point.Y;
1308
1309             if (max_yf > fill_area->Y + fill_area->Height)
1310                 max_y = fill_area->Y + fill_area->Height;
1311             else
1312                 max_y = (INT)ceil(max_yf);
1313
1314             dy = end_point.Y - start_point.Y;
1315             dx = end_point.X - start_point.X;
1316
1317             /* This is proportional to the distance from start-end line to center point. */
1318             center_distance = dy * (start_point.X - center_point.X) +
1319                 dx * (center_point.Y - start_point.Y);
1320
1321             for (y=min_y; y<max_y; y++)
1322             {
1323                 REAL yf = (REAL)y;
1324
1325                 if (!seen_start && yf >= start_point.Y)
1326                 {
1327                     seen_start = 1;
1328                     start_center_line ^= 1;
1329                 }
1330                 if (!seen_end && yf >= end_point.Y)
1331                 {
1332                     seen_end = 1;
1333                     end_center_line ^= 1;
1334                 }
1335                 if (!seen_center && yf >= center_point.Y)
1336                 {
1337                     seen_center = 1;
1338                     start_center_line ^= 1;
1339                     end_center_line ^= 1;
1340                 }
1341
1342                 if (start_center_line)
1343                     line1_xf = intersect_line_scanline(&start_point, &center_point, yf);
1344                 else
1345                     line1_xf = intersect_line_scanline(&start_point, &end_point, yf);
1346
1347                 if (end_center_line)
1348                     line2_xf = intersect_line_scanline(&end_point, &center_point, yf);
1349                 else
1350                     line2_xf = intersect_line_scanline(&start_point, &end_point, yf);
1351
1352                 if (line1_xf < line2_xf)
1353                 {
1354                     min_x = (INT)ceil(line1_xf);
1355                     max_x = (INT)ceil(line2_xf);
1356                 }
1357                 else
1358                 {
1359                     min_x = (INT)ceil(line2_xf);
1360                     max_x = (INT)ceil(line1_xf);
1361                 }
1362
1363                 if (min_x < fill_area->X)
1364                     min_x = fill_area->X;
1365                 if (max_x > fill_area->X + fill_area->Width)
1366                     max_x = fill_area->X + fill_area->Width;
1367
1368                 for (x=min_x; x<max_x; x++)
1369                 {
1370                     REAL xf = (REAL)x;
1371                     REAL distance;
1372
1373                     if (start_color != end_color)
1374                     {
1375                         REAL blend_amount, pdy, pdx;
1376                         pdy = yf - center_point.Y;
1377                         pdx = xf - center_point.X;
1378                         blend_amount = ( (center_point.Y - start_point.Y) * pdx + (start_point.X - center_point.X) * pdy ) / ( dy * pdx - dx * pdy );
1379                         outer_color = blend_colors(start_color, end_color, blend_amount);
1380                     }
1381
1382                     distance = (end_point.Y - start_point.Y) * (start_point.X - xf) +
1383                         (end_point.X - start_point.X) * (yf - start_point.Y);
1384
1385                     distance = distance / center_distance;
1386
1387                     argb_pixels[(x-fill_area->X) + (y-fill_area->Y)*cdwStride] =
1388                         blend_colors(outer_color, fill->centercolor, distance);
1389                 }
1390             }
1391         }
1392
1393         GdipDeletePath(flat_path);
1394         return stat;
1395     }
1396     default:
1397         return NotImplemented;
1398     }
1399 }
1400
1401 /* GdipDrawPie/GdipFillPie helper function */
1402 static void draw_pie(GpGraphics *graphics, REAL x, REAL y, REAL width,
1403     REAL height, REAL startAngle, REAL sweepAngle)
1404 {
1405     GpPointF ptf[4];
1406     POINT pti[4];
1407
1408     ptf[0].X = x;
1409     ptf[0].Y = y;
1410     ptf[1].X = x + width;
1411     ptf[1].Y = y + height;
1412
1413     deg2xy(startAngle+sweepAngle, x + width / 2.0, y + width / 2.0, &ptf[2].X, &ptf[2].Y);
1414     deg2xy(startAngle, x + width / 2.0, y + width / 2.0, &ptf[3].X, &ptf[3].Y);
1415
1416     transform_and_round_points(graphics, pti, ptf, 4);
1417
1418     Pie(graphics->hdc, pti[0].x, pti[0].y, pti[1].x, pti[1].y, pti[2].x,
1419         pti[2].y, pti[3].x, pti[3].y);
1420 }
1421
1422 /* Draws the linecap the specified color and size on the hdc.  The linecap is in
1423  * direction of the line from x1, y1 to x2, y2 and is anchored on x2, y2. Probably
1424  * should not be called on an hdc that has a path you care about. */
1425 static void draw_cap(GpGraphics *graphics, COLORREF color, GpLineCap cap, REAL size,
1426     const GpCustomLineCap *custom, REAL x1, REAL y1, REAL x2, REAL y2)
1427 {
1428     HGDIOBJ oldbrush = NULL, oldpen = NULL;
1429     GpMatrix *matrix = NULL;
1430     HBRUSH brush = NULL;
1431     HPEN pen = NULL;
1432     PointF ptf[4], *custptf = NULL;
1433     POINT pt[4], *custpt = NULL;
1434     BYTE *tp = NULL;
1435     REAL theta, dsmall, dbig, dx, dy = 0.0;
1436     INT i, count;
1437     LOGBRUSH lb;
1438     BOOL customstroke;
1439
1440     if((x1 == x2) && (y1 == y2))
1441         return;
1442
1443     theta = gdiplus_atan2(y2 - y1, x2 - x1);
1444
1445     customstroke = (cap == LineCapCustom) && custom && (!custom->fill);
1446     if(!customstroke){
1447         brush = CreateSolidBrush(color);
1448         lb.lbStyle = BS_SOLID;
1449         lb.lbColor = color;
1450         lb.lbHatch = 0;
1451         pen = ExtCreatePen(PS_GEOMETRIC | PS_SOLID | PS_ENDCAP_FLAT |
1452                            PS_JOIN_MITER, 1, &lb, 0,
1453                            NULL);
1454         oldbrush = SelectObject(graphics->hdc, brush);
1455         oldpen = SelectObject(graphics->hdc, pen);
1456     }
1457
1458     switch(cap){
1459         case LineCapFlat:
1460             break;
1461         case LineCapSquare:
1462         case LineCapSquareAnchor:
1463         case LineCapDiamondAnchor:
1464             size = size * (cap & LineCapNoAnchor ? ANCHOR_WIDTH : 1.0) / 2.0;
1465             if(cap == LineCapDiamondAnchor){
1466                 dsmall = cos(theta + M_PI_2) * size;
1467                 dbig = sin(theta + M_PI_2) * size;
1468             }
1469             else{
1470                 dsmall = cos(theta + M_PI_4) * size;
1471                 dbig = sin(theta + M_PI_4) * size;
1472             }
1473
1474             ptf[0].X = x2 - dsmall;
1475             ptf[1].X = x2 + dbig;
1476
1477             ptf[0].Y = y2 - dbig;
1478             ptf[3].Y = y2 + dsmall;
1479
1480             ptf[1].Y = y2 - dsmall;
1481             ptf[2].Y = y2 + dbig;
1482
1483             ptf[3].X = x2 - dbig;
1484             ptf[2].X = x2 + dsmall;
1485
1486             transform_and_round_points(graphics, pt, ptf, 4);
1487             Polygon(graphics->hdc, pt, 4);
1488
1489             break;
1490         case LineCapArrowAnchor:
1491             size = size * 4.0 / sqrt(3.0);
1492
1493             dx = cos(M_PI / 6.0 + theta) * size;
1494             dy = sin(M_PI / 6.0 + theta) * size;
1495
1496             ptf[0].X = x2 - dx;
1497             ptf[0].Y = y2 - dy;
1498
1499             dx = cos(- M_PI / 6.0 + theta) * size;
1500             dy = sin(- M_PI / 6.0 + theta) * size;
1501
1502             ptf[1].X = x2 - dx;
1503             ptf[1].Y = y2 - dy;
1504
1505             ptf[2].X = x2;
1506             ptf[2].Y = y2;
1507
1508             transform_and_round_points(graphics, pt, ptf, 3);
1509             Polygon(graphics->hdc, pt, 3);
1510
1511             break;
1512         case LineCapRoundAnchor:
1513             dx = dy = ANCHOR_WIDTH * size / 2.0;
1514
1515             ptf[0].X = x2 - dx;
1516             ptf[0].Y = y2 - dy;
1517             ptf[1].X = x2 + dx;
1518             ptf[1].Y = y2 + dy;
1519
1520             transform_and_round_points(graphics, pt, ptf, 2);
1521             Ellipse(graphics->hdc, pt[0].x, pt[0].y, pt[1].x, pt[1].y);
1522
1523             break;
1524         case LineCapTriangle:
1525             size = size / 2.0;
1526             dx = cos(M_PI_2 + theta) * size;
1527             dy = sin(M_PI_2 + theta) * size;
1528
1529             ptf[0].X = x2 - dx;
1530             ptf[0].Y = y2 - dy;
1531             ptf[1].X = x2 + dx;
1532             ptf[1].Y = y2 + dy;
1533
1534             dx = cos(theta) * size;
1535             dy = sin(theta) * size;
1536
1537             ptf[2].X = x2 + dx;
1538             ptf[2].Y = y2 + dy;
1539
1540             transform_and_round_points(graphics, pt, ptf, 3);
1541             Polygon(graphics->hdc, pt, 3);
1542
1543             break;
1544         case LineCapRound:
1545             dx = dy = size / 2.0;
1546
1547             ptf[0].X = x2 - dx;
1548             ptf[0].Y = y2 - dy;
1549             ptf[1].X = x2 + dx;
1550             ptf[1].Y = y2 + dy;
1551
1552             dx = -cos(M_PI_2 + theta) * size;
1553             dy = -sin(M_PI_2 + theta) * size;
1554
1555             ptf[2].X = x2 - dx;
1556             ptf[2].Y = y2 - dy;
1557             ptf[3].X = x2 + dx;
1558             ptf[3].Y = y2 + dy;
1559
1560             transform_and_round_points(graphics, pt, ptf, 4);
1561             Pie(graphics->hdc, pt[0].x, pt[0].y, pt[1].x, pt[1].y, pt[2].x,
1562                 pt[2].y, pt[3].x, pt[3].y);
1563
1564             break;
1565         case LineCapCustom:
1566             if(!custom)
1567                 break;
1568
1569             count = custom->pathdata.Count;
1570             custptf = GdipAlloc(count * sizeof(PointF));
1571             custpt = GdipAlloc(count * sizeof(POINT));
1572             tp = GdipAlloc(count);
1573
1574             if(!custptf || !custpt || !tp || (GdipCreateMatrix(&matrix) != Ok))
1575                 goto custend;
1576
1577             memcpy(custptf, custom->pathdata.Points, count * sizeof(PointF));
1578
1579             GdipScaleMatrix(matrix, size, size, MatrixOrderAppend);
1580             GdipRotateMatrix(matrix, (180.0 / M_PI) * (theta - M_PI_2),
1581                              MatrixOrderAppend);
1582             GdipTranslateMatrix(matrix, x2, y2, MatrixOrderAppend);
1583             GdipTransformMatrixPoints(matrix, custptf, count);
1584
1585             transform_and_round_points(graphics, custpt, custptf, count);
1586
1587             for(i = 0; i < count; i++)
1588                 tp[i] = convert_path_point_type(custom->pathdata.Types[i]);
1589
1590             if(custom->fill){
1591                 BeginPath(graphics->hdc);
1592                 PolyDraw(graphics->hdc, custpt, tp, count);
1593                 EndPath(graphics->hdc);
1594                 StrokeAndFillPath(graphics->hdc);
1595             }
1596             else
1597                 PolyDraw(graphics->hdc, custpt, tp, count);
1598
1599 custend:
1600             GdipFree(custptf);
1601             GdipFree(custpt);
1602             GdipFree(tp);
1603             GdipDeleteMatrix(matrix);
1604             break;
1605         default:
1606             break;
1607     }
1608
1609     if(!customstroke){
1610         SelectObject(graphics->hdc, oldbrush);
1611         SelectObject(graphics->hdc, oldpen);
1612         DeleteObject(brush);
1613         DeleteObject(pen);
1614     }
1615 }
1616
1617 /* Shortens the line by the given percent by changing x2, y2.
1618  * If percent is > 1.0 then the line will change direction.
1619  * If percent is negative it can lengthen the line. */
1620 static void shorten_line_percent(REAL x1, REAL  y1, REAL *x2, REAL *y2, REAL percent)
1621 {
1622     REAL dist, theta, dx, dy;
1623
1624     if((y1 == *y2) && (x1 == *x2))
1625         return;
1626
1627     dist = sqrt((*x2 - x1) * (*x2 - x1) + (*y2 - y1) * (*y2 - y1)) * -percent;
1628     theta = gdiplus_atan2((*y2 - y1), (*x2 - x1));
1629     dx = cos(theta) * dist;
1630     dy = sin(theta) * dist;
1631
1632     *x2 = *x2 + dx;
1633     *y2 = *y2 + dy;
1634 }
1635
1636 /* Shortens the line by the given amount by changing x2, y2.
1637  * If the amount is greater than the distance, the line will become length 0.
1638  * If the amount is negative, it can lengthen the line. */
1639 static void shorten_line_amt(REAL x1, REAL y1, REAL *x2, REAL *y2, REAL amt)
1640 {
1641     REAL dx, dy, percent;
1642
1643     dx = *x2 - x1;
1644     dy = *y2 - y1;
1645     if(dx == 0 && dy == 0)
1646         return;
1647
1648     percent = amt / sqrt(dx * dx + dy * dy);
1649     if(percent >= 1.0){
1650         *x2 = x1;
1651         *y2 = y1;
1652         return;
1653     }
1654
1655     shorten_line_percent(x1, y1, x2, y2, percent);
1656 }
1657
1658 /* Draws lines between the given points, and if caps is true then draws an endcap
1659  * at the end of the last line. */
1660 static GpStatus draw_polyline(GpGraphics *graphics, GpPen *pen,
1661     GDIPCONST GpPointF * pt, INT count, BOOL caps)
1662 {
1663     POINT *pti = NULL;
1664     GpPointF *ptcopy = NULL;
1665     GpStatus status = GenericError;
1666
1667     if(!count)
1668         return Ok;
1669
1670     pti = GdipAlloc(count * sizeof(POINT));
1671     ptcopy = GdipAlloc(count * sizeof(GpPointF));
1672
1673     if(!pti || !ptcopy){
1674         status = OutOfMemory;
1675         goto end;
1676     }
1677
1678     memcpy(ptcopy, pt, count * sizeof(GpPointF));
1679
1680     if(caps){
1681         if(pen->endcap == LineCapArrowAnchor)
1682             shorten_line_amt(ptcopy[count-2].X, ptcopy[count-2].Y,
1683                              &ptcopy[count-1].X, &ptcopy[count-1].Y, pen->width);
1684         else if((pen->endcap == LineCapCustom) && pen->customend)
1685             shorten_line_amt(ptcopy[count-2].X, ptcopy[count-2].Y,
1686                              &ptcopy[count-1].X, &ptcopy[count-1].Y,
1687                              pen->customend->inset * pen->width);
1688
1689         if(pen->startcap == LineCapArrowAnchor)
1690             shorten_line_amt(ptcopy[1].X, ptcopy[1].Y,
1691                              &ptcopy[0].X, &ptcopy[0].Y, pen->width);
1692         else if((pen->startcap == LineCapCustom) && pen->customstart)
1693             shorten_line_amt(ptcopy[1].X, ptcopy[1].Y,
1694                              &ptcopy[0].X, &ptcopy[0].Y,
1695                              pen->customstart->inset * pen->width);
1696
1697         draw_cap(graphics, get_gdi_brush_color(pen->brush), pen->endcap, pen->width, pen->customend,
1698                  pt[count - 2].X, pt[count - 2].Y, pt[count - 1].X, pt[count - 1].Y);
1699         draw_cap(graphics, get_gdi_brush_color(pen->brush), pen->startcap, pen->width, pen->customstart,
1700                          pt[1].X, pt[1].Y, pt[0].X, pt[0].Y);
1701     }
1702
1703     transform_and_round_points(graphics, pti, ptcopy, count);
1704
1705     if(Polyline(graphics->hdc, pti, count))
1706         status = Ok;
1707
1708 end:
1709     GdipFree(pti);
1710     GdipFree(ptcopy);
1711
1712     return status;
1713 }
1714
1715 /* Conducts a linear search to find the bezier points that will back off
1716  * the endpoint of the curve by a distance of amt. Linear search works
1717  * better than binary in this case because there are multiple solutions,
1718  * and binary searches often find a bad one. I don't think this is what
1719  * Windows does but short of rendering the bezier without GDI's help it's
1720  * the best we can do. If rev then work from the start of the passed points
1721  * instead of the end. */
1722 static void shorten_bezier_amt(GpPointF * pt, REAL amt, BOOL rev)
1723 {
1724     GpPointF origpt[4];
1725     REAL percent = 0.00, dx, dy, origx, origy, diff = -1.0;
1726     INT i, first = 0, second = 1, third = 2, fourth = 3;
1727
1728     if(rev){
1729         first = 3;
1730         second = 2;
1731         third = 1;
1732         fourth = 0;
1733     }
1734
1735     origx = pt[fourth].X;
1736     origy = pt[fourth].Y;
1737     memcpy(origpt, pt, sizeof(GpPointF) * 4);
1738
1739     for(i = 0; (i < MAX_ITERS) && (diff < amt); i++){
1740         /* reset bezier points to original values */
1741         memcpy(pt, origpt, sizeof(GpPointF) * 4);
1742         /* Perform magic on bezier points. Order is important here.*/
1743         shorten_line_percent(pt[third].X, pt[third].Y, &pt[fourth].X, &pt[fourth].Y, percent);
1744         shorten_line_percent(pt[second].X, pt[second].Y, &pt[third].X, &pt[third].Y, percent);
1745         shorten_line_percent(pt[third].X, pt[third].Y, &pt[fourth].X, &pt[fourth].Y, percent);
1746         shorten_line_percent(pt[first].X, pt[first].Y, &pt[second].X, &pt[second].Y, percent);
1747         shorten_line_percent(pt[second].X, pt[second].Y, &pt[third].X, &pt[third].Y, percent);
1748         shorten_line_percent(pt[third].X, pt[third].Y, &pt[fourth].X, &pt[fourth].Y, percent);
1749
1750         dx = pt[fourth].X - origx;
1751         dy = pt[fourth].Y - origy;
1752
1753         diff = sqrt(dx * dx + dy * dy);
1754         percent += 0.0005 * amt;
1755     }
1756 }
1757
1758 /* Draws bezier curves between given points, and if caps is true then draws an
1759  * endcap at the end of the last line. */
1760 static GpStatus draw_polybezier(GpGraphics *graphics, GpPen *pen,
1761     GDIPCONST GpPointF * pt, INT count, BOOL caps)
1762 {
1763     POINT *pti;
1764     GpPointF *ptcopy;
1765     GpStatus status = GenericError;
1766
1767     if(!count)
1768         return Ok;
1769
1770     pti = GdipAlloc(count * sizeof(POINT));
1771     ptcopy = GdipAlloc(count * sizeof(GpPointF));
1772
1773     if(!pti || !ptcopy){
1774         status = OutOfMemory;
1775         goto end;
1776     }
1777
1778     memcpy(ptcopy, pt, count * sizeof(GpPointF));
1779
1780     if(caps){
1781         if(pen->endcap == LineCapArrowAnchor)
1782             shorten_bezier_amt(&ptcopy[count-4], pen->width, FALSE);
1783         else if((pen->endcap == LineCapCustom) && pen->customend)
1784             shorten_bezier_amt(&ptcopy[count-4], pen->width * pen->customend->inset,
1785                                FALSE);
1786
1787         if(pen->startcap == LineCapArrowAnchor)
1788             shorten_bezier_amt(ptcopy, pen->width, TRUE);
1789         else if((pen->startcap == LineCapCustom) && pen->customstart)
1790             shorten_bezier_amt(ptcopy, pen->width * pen->customstart->inset, TRUE);
1791
1792         /* the direction of the line cap is parallel to the direction at the
1793          * end of the bezier (which, if it has been shortened, is not the same
1794          * as the direction from pt[count-2] to pt[count-1]) */
1795         draw_cap(graphics, get_gdi_brush_color(pen->brush), pen->endcap, pen->width, pen->customend,
1796             pt[count - 1].X - (ptcopy[count - 1].X - ptcopy[count - 2].X),
1797             pt[count - 1].Y - (ptcopy[count - 1].Y - ptcopy[count - 2].Y),
1798             pt[count - 1].X, pt[count - 1].Y);
1799
1800         draw_cap(graphics, get_gdi_brush_color(pen->brush), pen->startcap, pen->width, pen->customstart,
1801             pt[0].X - (ptcopy[0].X - ptcopy[1].X),
1802             pt[0].Y - (ptcopy[0].Y - ptcopy[1].Y), pt[0].X, pt[0].Y);
1803     }
1804
1805     transform_and_round_points(graphics, pti, ptcopy, count);
1806
1807     PolyBezier(graphics->hdc, pti, count);
1808
1809     status = Ok;
1810
1811 end:
1812     GdipFree(pti);
1813     GdipFree(ptcopy);
1814
1815     return status;
1816 }
1817
1818 /* Draws a combination of bezier curves and lines between points. */
1819 static GpStatus draw_poly(GpGraphics *graphics, GpPen *pen, GDIPCONST GpPointF * pt,
1820     GDIPCONST BYTE * types, INT count, BOOL caps)
1821 {
1822     POINT *pti = GdipAlloc(count * sizeof(POINT));
1823     BYTE *tp = GdipAlloc(count);
1824     GpPointF *ptcopy = GdipAlloc(count * sizeof(GpPointF));
1825     INT i, j;
1826     GpStatus status = GenericError;
1827
1828     if(!count){
1829         status = Ok;
1830         goto end;
1831     }
1832     if(!pti || !tp || !ptcopy){
1833         status = OutOfMemory;
1834         goto end;
1835     }
1836
1837     for(i = 1; i < count; i++){
1838         if((types[i] & PathPointTypePathTypeMask) == PathPointTypeBezier){
1839             if((i + 2 >= count) || !(types[i + 1] & PathPointTypeBezier)
1840                 || !(types[i + 1] & PathPointTypeBezier)){
1841                 ERR("Bad bezier points\n");
1842                 goto end;
1843             }
1844             i += 2;
1845         }
1846     }
1847
1848     memcpy(ptcopy, pt, count * sizeof(GpPointF));
1849
1850     /* If we are drawing caps, go through the points and adjust them accordingly,
1851      * and draw the caps. */
1852     if(caps){
1853         switch(types[count - 1] & PathPointTypePathTypeMask){
1854             case PathPointTypeBezier:
1855                 if(pen->endcap == LineCapArrowAnchor)
1856                     shorten_bezier_amt(&ptcopy[count - 4], pen->width, FALSE);
1857                 else if((pen->endcap == LineCapCustom) && pen->customend)
1858                     shorten_bezier_amt(&ptcopy[count - 4],
1859                                        pen->width * pen->customend->inset, FALSE);
1860
1861                 draw_cap(graphics, get_gdi_brush_color(pen->brush), pen->endcap, pen->width, pen->customend,
1862                     pt[count - 1].X - (ptcopy[count - 1].X - ptcopy[count - 2].X),
1863                     pt[count - 1].Y - (ptcopy[count - 1].Y - ptcopy[count - 2].Y),
1864                     pt[count - 1].X, pt[count - 1].Y);
1865
1866                 break;
1867             case PathPointTypeLine:
1868                 if(pen->endcap == LineCapArrowAnchor)
1869                     shorten_line_amt(ptcopy[count - 2].X, ptcopy[count - 2].Y,
1870                                      &ptcopy[count - 1].X, &ptcopy[count - 1].Y,
1871                                      pen->width);
1872                 else if((pen->endcap == LineCapCustom) && pen->customend)
1873                     shorten_line_amt(ptcopy[count - 2].X, ptcopy[count - 2].Y,
1874                                      &ptcopy[count - 1].X, &ptcopy[count - 1].Y,
1875                                      pen->customend->inset * pen->width);
1876
1877                 draw_cap(graphics, get_gdi_brush_color(pen->brush), pen->endcap, pen->width, pen->customend,
1878                          pt[count - 2].X, pt[count - 2].Y, pt[count - 1].X,
1879                          pt[count - 1].Y);
1880
1881                 break;
1882             default:
1883                 ERR("Bad path last point\n");
1884                 goto end;
1885         }
1886
1887         /* Find start of points */
1888         for(j = 1; j < count && ((types[j] & PathPointTypePathTypeMask)
1889             == PathPointTypeStart); j++);
1890
1891         switch(types[j] & PathPointTypePathTypeMask){
1892             case PathPointTypeBezier:
1893                 if(pen->startcap == LineCapArrowAnchor)
1894                     shorten_bezier_amt(&ptcopy[j - 1], pen->width, TRUE);
1895                 else if((pen->startcap == LineCapCustom) && pen->customstart)
1896                     shorten_bezier_amt(&ptcopy[j - 1],
1897                                        pen->width * pen->customstart->inset, TRUE);
1898
1899                 draw_cap(graphics, get_gdi_brush_color(pen->brush), pen->startcap, pen->width, pen->customstart,
1900                     pt[j - 1].X - (ptcopy[j - 1].X - ptcopy[j].X),
1901                     pt[j - 1].Y - (ptcopy[j - 1].Y - ptcopy[j].Y),
1902                     pt[j - 1].X, pt[j - 1].Y);
1903
1904                 break;
1905             case PathPointTypeLine:
1906                 if(pen->startcap == LineCapArrowAnchor)
1907                     shorten_line_amt(ptcopy[j].X, ptcopy[j].Y,
1908                                      &ptcopy[j - 1].X, &ptcopy[j - 1].Y,
1909                                      pen->width);
1910                 else if((pen->startcap == LineCapCustom) && pen->customstart)
1911                     shorten_line_amt(ptcopy[j].X, ptcopy[j].Y,
1912                                      &ptcopy[j - 1].X, &ptcopy[j - 1].Y,
1913                                      pen->customstart->inset * pen->width);
1914
1915                 draw_cap(graphics, get_gdi_brush_color(pen->brush), pen->startcap, pen->width, pen->customstart,
1916                          pt[j].X, pt[j].Y, pt[j - 1].X,
1917                          pt[j - 1].Y);
1918
1919                 break;
1920             default:
1921                 ERR("Bad path points\n");
1922                 goto end;
1923         }
1924     }
1925
1926     transform_and_round_points(graphics, pti, ptcopy, count);
1927
1928     for(i = 0; i < count; i++){
1929         tp[i] = convert_path_point_type(types[i]);
1930     }
1931
1932     PolyDraw(graphics->hdc, pti, tp, count);
1933
1934     status = Ok;
1935
1936 end:
1937     GdipFree(pti);
1938     GdipFree(ptcopy);
1939     GdipFree(tp);
1940
1941     return status;
1942 }
1943
1944 GpStatus trace_path(GpGraphics *graphics, GpPath *path)
1945 {
1946     GpStatus result;
1947
1948     BeginPath(graphics->hdc);
1949     result = draw_poly(graphics, NULL, path->pathdata.Points,
1950                        path->pathdata.Types, path->pathdata.Count, FALSE);
1951     EndPath(graphics->hdc);
1952     return result;
1953 }
1954
1955 typedef struct _GraphicsContainerItem {
1956     struct list entry;
1957     GraphicsContainer contid;
1958
1959     SmoothingMode smoothing;
1960     CompositingQuality compqual;
1961     InterpolationMode interpolation;
1962     CompositingMode compmode;
1963     TextRenderingHint texthint;
1964     REAL scale;
1965     GpUnit unit;
1966     PixelOffsetMode pixeloffset;
1967     UINT textcontrast;
1968     GpMatrix* worldtrans;
1969     GpRegion* clip;
1970     INT origin_x, origin_y;
1971 } GraphicsContainerItem;
1972
1973 static GpStatus init_container(GraphicsContainerItem** container,
1974         GDIPCONST GpGraphics* graphics){
1975     GpStatus sts;
1976
1977     *container = GdipAlloc(sizeof(GraphicsContainerItem));
1978     if(!(*container))
1979         return OutOfMemory;
1980
1981     (*container)->contid = graphics->contid + 1;
1982
1983     (*container)->smoothing = graphics->smoothing;
1984     (*container)->compqual = graphics->compqual;
1985     (*container)->interpolation = graphics->interpolation;
1986     (*container)->compmode = graphics->compmode;
1987     (*container)->texthint = graphics->texthint;
1988     (*container)->scale = graphics->scale;
1989     (*container)->unit = graphics->unit;
1990     (*container)->textcontrast = graphics->textcontrast;
1991     (*container)->pixeloffset = graphics->pixeloffset;
1992     (*container)->origin_x = graphics->origin_x;
1993     (*container)->origin_y = graphics->origin_y;
1994
1995     sts = GdipCloneMatrix(graphics->worldtrans, &(*container)->worldtrans);
1996     if(sts != Ok){
1997         GdipFree(*container);
1998         *container = NULL;
1999         return sts;
2000     }
2001
2002     sts = GdipCloneRegion(graphics->clip, &(*container)->clip);
2003     if(sts != Ok){
2004         GdipDeleteMatrix((*container)->worldtrans);
2005         GdipFree(*container);
2006         *container = NULL;
2007         return sts;
2008     }
2009
2010     return Ok;
2011 }
2012
2013 static void delete_container(GraphicsContainerItem* container){
2014     GdipDeleteMatrix(container->worldtrans);
2015     GdipDeleteRegion(container->clip);
2016     GdipFree(container);
2017 }
2018
2019 static GpStatus restore_container(GpGraphics* graphics,
2020         GDIPCONST GraphicsContainerItem* container){
2021     GpStatus sts;
2022     GpMatrix *newTrans;
2023     GpRegion *newClip;
2024
2025     sts = GdipCloneMatrix(container->worldtrans, &newTrans);
2026     if(sts != Ok)
2027         return sts;
2028
2029     sts = GdipCloneRegion(container->clip, &newClip);
2030     if(sts != Ok){
2031         GdipDeleteMatrix(newTrans);
2032         return sts;
2033     }
2034
2035     GdipDeleteMatrix(graphics->worldtrans);
2036     graphics->worldtrans = newTrans;
2037
2038     GdipDeleteRegion(graphics->clip);
2039     graphics->clip = newClip;
2040
2041     graphics->contid = container->contid - 1;
2042
2043     graphics->smoothing = container->smoothing;
2044     graphics->compqual = container->compqual;
2045     graphics->interpolation = container->interpolation;
2046     graphics->compmode = container->compmode;
2047     graphics->texthint = container->texthint;
2048     graphics->scale = container->scale;
2049     graphics->unit = container->unit;
2050     graphics->textcontrast = container->textcontrast;
2051     graphics->pixeloffset = container->pixeloffset;
2052     graphics->origin_x = container->origin_x;
2053     graphics->origin_y = container->origin_y;
2054
2055     return Ok;
2056 }
2057
2058 static GpStatus get_graphics_bounds(GpGraphics* graphics, GpRectF* rect)
2059 {
2060     RECT wnd_rect;
2061     GpStatus stat=Ok;
2062     GpUnit unit;
2063
2064     if(graphics->hwnd) {
2065         if(!GetClientRect(graphics->hwnd, &wnd_rect))
2066             return GenericError;
2067
2068         rect->X = wnd_rect.left;
2069         rect->Y = wnd_rect.top;
2070         rect->Width = wnd_rect.right - wnd_rect.left;
2071         rect->Height = wnd_rect.bottom - wnd_rect.top;
2072     }else if (graphics->image){
2073         stat = GdipGetImageBounds(graphics->image, rect, &unit);
2074         if (stat == Ok && unit != UnitPixel)
2075             FIXME("need to convert from unit %i\n", unit);
2076     }else{
2077         rect->X = 0;
2078         rect->Y = 0;
2079         rect->Width = GetDeviceCaps(graphics->hdc, HORZRES);
2080         rect->Height = GetDeviceCaps(graphics->hdc, VERTRES);
2081     }
2082
2083     return stat;
2084 }
2085
2086 /* on success, rgn will contain the region of the graphics object which
2087  * is visible after clipping has been applied */
2088 static GpStatus get_visible_clip_region(GpGraphics *graphics, GpRegion *rgn)
2089 {
2090     GpStatus stat;
2091     GpRectF rectf;
2092     GpRegion* tmp;
2093
2094     if((stat = get_graphics_bounds(graphics, &rectf)) != Ok)
2095         return stat;
2096
2097     if((stat = GdipCreateRegion(&tmp)) != Ok)
2098         return stat;
2099
2100     if((stat = GdipCombineRegionRect(tmp, &rectf, CombineModeReplace)) != Ok)
2101         goto end;
2102
2103     if((stat = GdipCombineRegionRegion(tmp, graphics->clip, CombineModeIntersect)) != Ok)
2104         goto end;
2105
2106     stat = GdipCombineRegionRegion(rgn, tmp, CombineModeReplace);
2107
2108 end:
2109     GdipDeleteRegion(tmp);
2110     return stat;
2111 }
2112
2113 static void get_font_hfont(GpGraphics *graphics, GDIPCONST GpFont *font, HFONT *hfont)
2114 {
2115     HDC hdc = CreateCompatibleDC(0);
2116     GpPointF pt[3];
2117     REAL angle, rel_width, rel_height, font_height, font_to_pixel_scale;
2118     LOGFONTW lfw;
2119     HFONT unscaled_font;
2120     TEXTMETRICW textmet;
2121
2122     font_to_pixel_scale = units_scale(UnitPoint, UnitPixel, font->family->dpi);
2123
2124     if (font->unit == UnitPixel)
2125         font_height = font->emSize * font_to_pixel_scale;
2126     else
2127     {
2128         REAL unit_scale, res;
2129
2130         res = (graphics->unit == UnitDisplay || graphics->unit == UnitPixel) ? graphics->xres : graphics->yres;
2131         unit_scale = units_scale(font->unit, graphics->unit, res);
2132
2133         font_height = font->emSize * font_to_pixel_scale * unit_scale;
2134         if (graphics->unit != UnitDisplay)
2135             font_height /= graphics->scale;
2136     }
2137
2138     pt[0].X = 0.0;
2139     pt[0].Y = 0.0;
2140     pt[1].X = 1.0;
2141     pt[1].Y = 0.0;
2142     pt[2].X = 0.0;
2143     pt[2].Y = 1.0;
2144     if (graphics)
2145         GdipTransformPoints(graphics, CoordinateSpaceDevice, CoordinateSpaceWorld, pt, 3);
2146     angle = -gdiplus_atan2((pt[1].Y - pt[0].Y), (pt[1].X - pt[0].X));
2147     rel_width = sqrt((pt[1].Y-pt[0].Y)*(pt[1].Y-pt[0].Y)+
2148                      (pt[1].X-pt[0].X)*(pt[1].X-pt[0].X));
2149     rel_height = sqrt((pt[2].Y-pt[0].Y)*(pt[2].Y-pt[0].Y)+
2150                       (pt[2].X-pt[0].X)*(pt[2].X-pt[0].X));
2151
2152     get_log_fontW(font, graphics, &lfw);
2153     lfw.lfHeight = roundr(font_height * rel_height);
2154     unscaled_font = CreateFontIndirectW(&lfw);
2155
2156     SelectObject(hdc, unscaled_font);
2157     GetTextMetricsW(hdc, &textmet);
2158
2159     lfw.lfWidth = roundr(textmet.tmAveCharWidth * rel_width / rel_height);
2160     lfw.lfEscapement = lfw.lfOrientation = roundr((angle / M_PI) * 1800.0);
2161
2162     *hfont = CreateFontIndirectW(&lfw);
2163
2164     DeleteDC(hdc);
2165     DeleteObject(unscaled_font);
2166 }
2167
2168 GpStatus WINGDIPAPI GdipCreateFromHDC(HDC hdc, GpGraphics **graphics)
2169 {
2170     TRACE("(%p, %p)\n", hdc, graphics);
2171
2172     return GdipCreateFromHDC2(hdc, NULL, graphics);
2173 }
2174
2175 GpStatus WINGDIPAPI GdipCreateFromHDC2(HDC hdc, HANDLE hDevice, GpGraphics **graphics)
2176 {
2177     GpStatus retval;
2178
2179     TRACE("(%p, %p, %p)\n", hdc, hDevice, graphics);
2180
2181     if(hDevice != NULL) {
2182         FIXME("Don't know how to handle parameter hDevice\n");
2183         return NotImplemented;
2184     }
2185
2186     if(hdc == NULL)
2187         return OutOfMemory;
2188
2189     if(graphics == NULL)
2190         return InvalidParameter;
2191
2192     *graphics = GdipAlloc(sizeof(GpGraphics));
2193     if(!*graphics)  return OutOfMemory;
2194
2195     if((retval = GdipCreateMatrix(&(*graphics)->worldtrans)) != Ok){
2196         GdipFree(*graphics);
2197         return retval;
2198     }
2199
2200     if((retval = GdipCreateRegion(&(*graphics)->clip)) != Ok){
2201         GdipFree((*graphics)->worldtrans);
2202         GdipFree(*graphics);
2203         return retval;
2204     }
2205
2206     (*graphics)->hdc = hdc;
2207     (*graphics)->hwnd = WindowFromDC(hdc);
2208     (*graphics)->owndc = FALSE;
2209     (*graphics)->smoothing = SmoothingModeDefault;
2210     (*graphics)->compqual = CompositingQualityDefault;
2211     (*graphics)->interpolation = InterpolationModeBilinear;
2212     (*graphics)->pixeloffset = PixelOffsetModeDefault;
2213     (*graphics)->compmode = CompositingModeSourceOver;
2214     (*graphics)->unit = UnitDisplay;
2215     (*graphics)->scale = 1.0;
2216     (*graphics)->xres = GetDeviceCaps(hdc, LOGPIXELSX);
2217     (*graphics)->yres = GetDeviceCaps(hdc, LOGPIXELSY);
2218     (*graphics)->busy = FALSE;
2219     (*graphics)->textcontrast = 4;
2220     list_init(&(*graphics)->containers);
2221     (*graphics)->contid = 0;
2222
2223     TRACE("<-- %p\n", *graphics);
2224
2225     return Ok;
2226 }
2227
2228 GpStatus graphics_from_image(GpImage *image, GpGraphics **graphics)
2229 {
2230     GpStatus retval;
2231
2232     *graphics = GdipAlloc(sizeof(GpGraphics));
2233     if(!*graphics)  return OutOfMemory;
2234
2235     if((retval = GdipCreateMatrix(&(*graphics)->worldtrans)) != Ok){
2236         GdipFree(*graphics);
2237         return retval;
2238     }
2239
2240     if((retval = GdipCreateRegion(&(*graphics)->clip)) != Ok){
2241         GdipFree((*graphics)->worldtrans);
2242         GdipFree(*graphics);
2243         return retval;
2244     }
2245
2246     (*graphics)->hdc = NULL;
2247     (*graphics)->hwnd = NULL;
2248     (*graphics)->owndc = FALSE;
2249     (*graphics)->image = image;
2250     (*graphics)->smoothing = SmoothingModeDefault;
2251     (*graphics)->compqual = CompositingQualityDefault;
2252     (*graphics)->interpolation = InterpolationModeBilinear;
2253     (*graphics)->pixeloffset = PixelOffsetModeDefault;
2254     (*graphics)->compmode = CompositingModeSourceOver;
2255     (*graphics)->unit = UnitDisplay;
2256     (*graphics)->scale = 1.0;
2257     (*graphics)->xres = image->xres;
2258     (*graphics)->yres = image->yres;
2259     (*graphics)->busy = FALSE;
2260     (*graphics)->textcontrast = 4;
2261     list_init(&(*graphics)->containers);
2262     (*graphics)->contid = 0;
2263
2264     TRACE("<-- %p\n", *graphics);
2265
2266     return Ok;
2267 }
2268
2269 GpStatus WINGDIPAPI GdipCreateFromHWND(HWND hwnd, GpGraphics **graphics)
2270 {
2271     GpStatus ret;
2272     HDC hdc;
2273
2274     TRACE("(%p, %p)\n", hwnd, graphics);
2275
2276     hdc = GetDC(hwnd);
2277
2278     if((ret = GdipCreateFromHDC(hdc, graphics)) != Ok)
2279     {
2280         ReleaseDC(hwnd, hdc);
2281         return ret;
2282     }
2283
2284     (*graphics)->hwnd = hwnd;
2285     (*graphics)->owndc = TRUE;
2286
2287     return Ok;
2288 }
2289
2290 /* FIXME: no icm handling */
2291 GpStatus WINGDIPAPI GdipCreateFromHWNDICM(HWND hwnd, GpGraphics **graphics)
2292 {
2293     TRACE("(%p, %p)\n", hwnd, graphics);
2294
2295     return GdipCreateFromHWND(hwnd, graphics);
2296 }
2297
2298 GpStatus WINGDIPAPI GdipCreateMetafileFromEmf(HENHMETAFILE hemf, BOOL delete,
2299     GpMetafile **metafile)
2300 {
2301     IStream *stream = NULL;
2302     UINT read;
2303     ENHMETAHEADER *copy;
2304     GpStatus retval = Ok;
2305
2306     TRACE("(%p,%i,%p)\n", hemf, delete, metafile);
2307
2308     if(!hemf || !metafile)
2309         return InvalidParameter;
2310
2311     read = GetEnhMetaFileBits(hemf, 0, NULL);
2312     copy = GdipAlloc(read);
2313     GetEnhMetaFileBits(hemf, read, (BYTE *)copy);
2314
2315     if(CreateStreamOnHGlobal(copy, TRUE, &stream) != S_OK){
2316         ERR("could not make stream\n");
2317         GdipFree(copy);
2318         retval = GenericError;
2319         goto err;
2320     }
2321
2322     *metafile = GdipAlloc(sizeof(GpMetafile));
2323     if(!*metafile){
2324         retval = OutOfMemory;
2325         goto err;
2326     }
2327
2328     if(OleLoadPicture(stream, 0, FALSE, &IID_IPicture,
2329         (LPVOID*) &((*metafile)->image.picture)) != S_OK)
2330     {
2331         retval = GenericError;
2332         goto err;
2333     }
2334
2335
2336     (*metafile)->image.type = ImageTypeMetafile;
2337     memcpy(&(*metafile)->image.format, &ImageFormatWMF, sizeof(GUID));
2338     (*metafile)->image.palette = NULL;
2339     (*metafile)->image.xres = (REAL)copy->szlDevice.cx;
2340     (*metafile)->image.yres = (REAL)copy->szlDevice.cy;
2341     (*metafile)->bounds.X = (REAL)copy->rclBounds.left;
2342     (*metafile)->bounds.Y = (REAL)copy->rclBounds.top;
2343     (*metafile)->bounds.Width = (REAL)(copy->rclBounds.right - copy->rclBounds.left);
2344     (*metafile)->bounds.Height = (REAL)(copy->rclBounds.bottom - copy->rclBounds.top);
2345     (*metafile)->unit = UnitPixel;
2346
2347     if(delete)
2348         DeleteEnhMetaFile(hemf);
2349
2350     TRACE("<-- %p\n", *metafile);
2351
2352 err:
2353     if (retval != Ok)
2354         GdipFree(*metafile);
2355     IStream_Release(stream);
2356     return retval;
2357 }
2358
2359 GpStatus WINGDIPAPI GdipCreateMetafileFromWmf(HMETAFILE hwmf, BOOL delete,
2360     GDIPCONST WmfPlaceableFileHeader * placeable, GpMetafile **metafile)
2361 {
2362     UINT read;
2363     BYTE *copy;
2364     HENHMETAFILE hemf;
2365     GpStatus retval = Ok;
2366
2367     TRACE("(%p, %d, %p, %p)\n", hwmf, delete, placeable, metafile);
2368
2369     if(!hwmf || !metafile || !placeable)
2370         return InvalidParameter;
2371
2372     *metafile = NULL;
2373     read = GetMetaFileBitsEx(hwmf, 0, NULL);
2374     if(!read)
2375         return GenericError;
2376     copy = GdipAlloc(read);
2377     GetMetaFileBitsEx(hwmf, read, copy);
2378
2379     hemf = SetWinMetaFileBits(read, copy, NULL, NULL);
2380     GdipFree(copy);
2381
2382     retval = GdipCreateMetafileFromEmf(hemf, FALSE, metafile);
2383
2384     if (retval == Ok)
2385     {
2386         (*metafile)->image.xres = (REAL)placeable->Inch;
2387         (*metafile)->image.yres = (REAL)placeable->Inch;
2388         (*metafile)->bounds.X = ((REAL)placeable->BoundingBox.Left) / ((REAL)placeable->Inch);
2389         (*metafile)->bounds.Y = ((REAL)placeable->BoundingBox.Top) / ((REAL)placeable->Inch);
2390         (*metafile)->bounds.Width = (REAL)(placeable->BoundingBox.Right -
2391                                            placeable->BoundingBox.Left);
2392         (*metafile)->bounds.Height = (REAL)(placeable->BoundingBox.Bottom -
2393                                             placeable->BoundingBox.Top);
2394
2395         if (delete) DeleteMetaFile(hwmf);
2396     }
2397     return retval;
2398 }
2399
2400 GpStatus WINGDIPAPI GdipCreateMetafileFromWmfFile(GDIPCONST WCHAR *file,
2401     GDIPCONST WmfPlaceableFileHeader * placeable, GpMetafile **metafile)
2402 {
2403     HMETAFILE hmf = GetMetaFileW(file);
2404
2405     TRACE("(%s, %p, %p)\n", debugstr_w(file), placeable, metafile);
2406
2407     if(!hmf) return InvalidParameter;
2408
2409     return GdipCreateMetafileFromWmf(hmf, TRUE, placeable, metafile);
2410 }
2411
2412 GpStatus WINGDIPAPI GdipCreateMetafileFromFile(GDIPCONST WCHAR *file,
2413     GpMetafile **metafile)
2414 {
2415     FIXME("(%p, %p): stub\n", file, metafile);
2416     return NotImplemented;
2417 }
2418
2419 GpStatus WINGDIPAPI GdipCreateMetafileFromStream(IStream *stream,
2420     GpMetafile **metafile)
2421 {
2422     FIXME("(%p, %p): stub\n", stream, metafile);
2423     return NotImplemented;
2424 }
2425
2426 GpStatus WINGDIPAPI GdipCreateStreamOnFile(GDIPCONST WCHAR * filename,
2427     UINT access, IStream **stream)
2428 {
2429     DWORD dwMode;
2430     HRESULT ret;
2431
2432     TRACE("(%s, %u, %p)\n", debugstr_w(filename), access, stream);
2433
2434     if(!stream || !filename)
2435         return InvalidParameter;
2436
2437     if(access & GENERIC_WRITE)
2438         dwMode = STGM_SHARE_DENY_WRITE | STGM_WRITE | STGM_CREATE;
2439     else if(access & GENERIC_READ)
2440         dwMode = STGM_SHARE_DENY_WRITE | STGM_READ | STGM_FAILIFTHERE;
2441     else
2442         return InvalidParameter;
2443
2444     ret = SHCreateStreamOnFileW(filename, dwMode, stream);
2445
2446     return hresult_to_status(ret);
2447 }
2448
2449 GpStatus WINGDIPAPI GdipDeleteGraphics(GpGraphics *graphics)
2450 {
2451     GraphicsContainerItem *cont, *next;
2452     GpStatus stat;
2453     TRACE("(%p)\n", graphics);
2454
2455     if(!graphics) return InvalidParameter;
2456     if(graphics->busy) return ObjectBusy;
2457
2458     if (graphics->image && graphics->image->type == ImageTypeMetafile)
2459     {
2460         stat = METAFILE_GraphicsDeleted((GpMetafile*)graphics->image);
2461         if (stat != Ok)
2462             return stat;
2463     }
2464
2465     if(graphics->owndc)
2466         ReleaseDC(graphics->hwnd, graphics->hdc);
2467
2468     LIST_FOR_EACH_ENTRY_SAFE(cont, next, &graphics->containers, GraphicsContainerItem, entry){
2469         list_remove(&cont->entry);
2470         delete_container(cont);
2471     }
2472
2473     GdipDeleteRegion(graphics->clip);
2474     GdipDeleteMatrix(graphics->worldtrans);
2475     GdipFree(graphics);
2476
2477     return Ok;
2478 }
2479
2480 GpStatus WINGDIPAPI GdipDrawArc(GpGraphics *graphics, GpPen *pen, REAL x,
2481     REAL y, REAL width, REAL height, REAL startAngle, REAL sweepAngle)
2482 {
2483     INT save_state, num_pts;
2484     GpPointF points[MAX_ARC_PTS];
2485     GpStatus retval;
2486
2487     TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f)\n", graphics, pen, x, y,
2488           width, height, startAngle, sweepAngle);
2489
2490     if(!graphics || !pen || width <= 0 || height <= 0)
2491         return InvalidParameter;
2492
2493     if(graphics->busy)
2494         return ObjectBusy;
2495
2496     if (!graphics->hdc)
2497     {
2498         FIXME("graphics object has no HDC\n");
2499         return Ok;
2500     }
2501
2502     num_pts = arc2polybezier(points, x, y, width, height, startAngle, sweepAngle);
2503
2504     save_state = prepare_dc(graphics, pen);
2505
2506     retval = draw_polybezier(graphics, pen, points, num_pts, TRUE);
2507
2508     restore_dc(graphics, save_state);
2509
2510     return retval;
2511 }
2512
2513 GpStatus WINGDIPAPI GdipDrawArcI(GpGraphics *graphics, GpPen *pen, INT x,
2514     INT y, INT width, INT height, REAL startAngle, REAL sweepAngle)
2515 {
2516     TRACE("(%p, %p, %d, %d, %d, %d, %.2f, %.2f)\n", graphics, pen, x, y,
2517           width, height, startAngle, sweepAngle);
2518
2519     return GdipDrawArc(graphics,pen,(REAL)x,(REAL)y,(REAL)width,(REAL)height,startAngle,sweepAngle);
2520 }
2521
2522 GpStatus WINGDIPAPI GdipDrawBezier(GpGraphics *graphics, GpPen *pen, REAL x1,
2523     REAL y1, REAL x2, REAL y2, REAL x3, REAL y3, REAL x4, REAL y4)
2524 {
2525     INT save_state;
2526     GpPointF pt[4];
2527     GpStatus retval;
2528
2529     TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f)\n", graphics, pen, x1, y1,
2530           x2, y2, x3, y3, x4, y4);
2531
2532     if(!graphics || !pen)
2533         return InvalidParameter;
2534
2535     if(graphics->busy)
2536         return ObjectBusy;
2537
2538     if (!graphics->hdc)
2539     {
2540         FIXME("graphics object has no HDC\n");
2541         return Ok;
2542     }
2543
2544     pt[0].X = x1;
2545     pt[0].Y = y1;
2546     pt[1].X = x2;
2547     pt[1].Y = y2;
2548     pt[2].X = x3;
2549     pt[2].Y = y3;
2550     pt[3].X = x4;
2551     pt[3].Y = y4;
2552
2553     save_state = prepare_dc(graphics, pen);
2554
2555     retval = draw_polybezier(graphics, pen, pt, 4, TRUE);
2556
2557     restore_dc(graphics, save_state);
2558
2559     return retval;
2560 }
2561
2562 GpStatus WINGDIPAPI GdipDrawBezierI(GpGraphics *graphics, GpPen *pen, INT x1,
2563     INT y1, INT x2, INT y2, INT x3, INT y3, INT x4, INT y4)
2564 {
2565     INT save_state;
2566     GpPointF pt[4];
2567     GpStatus retval;
2568
2569     TRACE("(%p, %p, %d, %d, %d, %d, %d, %d, %d, %d)\n", graphics, pen, x1, y1,
2570           x2, y2, x3, y3, x4, y4);
2571
2572     if(!graphics || !pen)
2573         return InvalidParameter;
2574
2575     if(graphics->busy)
2576         return ObjectBusy;
2577
2578     if (!graphics->hdc)
2579     {
2580         FIXME("graphics object has no HDC\n");
2581         return Ok;
2582     }
2583
2584     pt[0].X = x1;
2585     pt[0].Y = y1;
2586     pt[1].X = x2;
2587     pt[1].Y = y2;
2588     pt[2].X = x3;
2589     pt[2].Y = y3;
2590     pt[3].X = x4;
2591     pt[3].Y = y4;
2592
2593     save_state = prepare_dc(graphics, pen);
2594
2595     retval = draw_polybezier(graphics, pen, pt, 4, TRUE);
2596
2597     restore_dc(graphics, save_state);
2598
2599     return retval;
2600 }
2601
2602 GpStatus WINGDIPAPI GdipDrawBeziers(GpGraphics *graphics, GpPen *pen,
2603     GDIPCONST GpPointF *points, INT count)
2604 {
2605     INT i;
2606     GpStatus ret;
2607
2608     TRACE("(%p, %p, %p, %d)\n", graphics, pen, points, count);
2609
2610     if(!graphics || !pen || !points || (count <= 0))
2611         return InvalidParameter;
2612
2613     if(graphics->busy)
2614         return ObjectBusy;
2615
2616     for(i = 0; i < floor(count / 4); i++){
2617         ret = GdipDrawBezier(graphics, pen,
2618                              points[4*i].X, points[4*i].Y,
2619                              points[4*i + 1].X, points[4*i + 1].Y,
2620                              points[4*i + 2].X, points[4*i + 2].Y,
2621                              points[4*i + 3].X, points[4*i + 3].Y);
2622         if(ret != Ok)
2623             return ret;
2624     }
2625
2626     return Ok;
2627 }
2628
2629 GpStatus WINGDIPAPI GdipDrawBeziersI(GpGraphics *graphics, GpPen *pen,
2630     GDIPCONST GpPoint *points, INT count)
2631 {
2632     GpPointF *pts;
2633     GpStatus ret;
2634     INT i;
2635
2636     TRACE("(%p, %p, %p, %d)\n", graphics, pen, points, count);
2637
2638     if(!graphics || !pen || !points || (count <= 0))
2639         return InvalidParameter;
2640
2641     if(graphics->busy)
2642         return ObjectBusy;
2643
2644     pts = GdipAlloc(sizeof(GpPointF) * count);
2645     if(!pts)
2646         return OutOfMemory;
2647
2648     for(i = 0; i < count; i++){
2649         pts[i].X = (REAL)points[i].X;
2650         pts[i].Y = (REAL)points[i].Y;
2651     }
2652
2653     ret = GdipDrawBeziers(graphics,pen,pts,count);
2654
2655     GdipFree(pts);
2656
2657     return ret;
2658 }
2659
2660 GpStatus WINGDIPAPI GdipDrawClosedCurve(GpGraphics *graphics, GpPen *pen,
2661     GDIPCONST GpPointF *points, INT count)
2662 {
2663     TRACE("(%p, %p, %p, %d)\n", graphics, pen, points, count);
2664
2665     return GdipDrawClosedCurve2(graphics, pen, points, count, 1.0);
2666 }
2667
2668 GpStatus WINGDIPAPI GdipDrawClosedCurveI(GpGraphics *graphics, GpPen *pen,
2669     GDIPCONST GpPoint *points, INT count)
2670 {
2671     TRACE("(%p, %p, %p, %d)\n", graphics, pen, points, count);
2672
2673     return GdipDrawClosedCurve2I(graphics, pen, points, count, 1.0);
2674 }
2675
2676 GpStatus WINGDIPAPI GdipDrawClosedCurve2(GpGraphics *graphics, GpPen *pen,
2677     GDIPCONST GpPointF *points, INT count, REAL tension)
2678 {
2679     GpPath *path;
2680     GpStatus stat;
2681
2682     TRACE("(%p, %p, %p, %d, %.2f)\n", graphics, pen, points, count, tension);
2683
2684     if(!graphics || !pen || !points || count <= 0)
2685         return InvalidParameter;
2686
2687     if(graphics->busy)
2688         return ObjectBusy;
2689
2690     if((stat = GdipCreatePath(FillModeAlternate, &path)) != Ok)
2691         return stat;
2692
2693     stat = GdipAddPathClosedCurve2(path, points, count, tension);
2694     if(stat != Ok){
2695         GdipDeletePath(path);
2696         return stat;
2697     }
2698
2699     stat = GdipDrawPath(graphics, pen, path);
2700
2701     GdipDeletePath(path);
2702
2703     return stat;
2704 }
2705
2706 GpStatus WINGDIPAPI GdipDrawClosedCurve2I(GpGraphics *graphics, GpPen *pen,
2707     GDIPCONST GpPoint *points, INT count, REAL tension)
2708 {
2709     GpPointF *ptf;
2710     GpStatus stat;
2711     INT i;
2712
2713     TRACE("(%p, %p, %p, %d, %.2f)\n", graphics, pen, points, count, tension);
2714
2715     if(!points || count <= 0)
2716         return InvalidParameter;
2717
2718     ptf = GdipAlloc(sizeof(GpPointF)*count);
2719     if(!ptf)
2720         return OutOfMemory;
2721
2722     for(i = 0; i < count; i++){
2723         ptf[i].X = (REAL)points[i].X;
2724         ptf[i].Y = (REAL)points[i].Y;
2725     }
2726
2727     stat = GdipDrawClosedCurve2(graphics, pen, ptf, count, tension);
2728
2729     GdipFree(ptf);
2730
2731     return stat;
2732 }
2733
2734 GpStatus WINGDIPAPI GdipDrawCurve(GpGraphics *graphics, GpPen *pen,
2735     GDIPCONST GpPointF *points, INT count)
2736 {
2737     TRACE("(%p, %p, %p, %d)\n", graphics, pen, points, count);
2738
2739     return GdipDrawCurve2(graphics,pen,points,count,1.0);
2740 }
2741
2742 GpStatus WINGDIPAPI GdipDrawCurveI(GpGraphics *graphics, GpPen *pen,
2743     GDIPCONST GpPoint *points, INT count)
2744 {
2745     GpPointF *pointsF;
2746     GpStatus ret;
2747     INT i;
2748
2749     TRACE("(%p, %p, %p, %d)\n", graphics, pen, points, count);
2750
2751     if(!points)
2752         return InvalidParameter;
2753
2754     pointsF = GdipAlloc(sizeof(GpPointF)*count);
2755     if(!pointsF)
2756         return OutOfMemory;
2757
2758     for(i = 0; i < count; i++){
2759         pointsF[i].X = (REAL)points[i].X;
2760         pointsF[i].Y = (REAL)points[i].Y;
2761     }
2762
2763     ret = GdipDrawCurve(graphics,pen,pointsF,count);
2764     GdipFree(pointsF);
2765
2766     return ret;
2767 }
2768
2769 /* Approximates cardinal spline with Bezier curves. */
2770 GpStatus WINGDIPAPI GdipDrawCurve2(GpGraphics *graphics, GpPen *pen,
2771     GDIPCONST GpPointF *points, INT count, REAL tension)
2772 {
2773     /* PolyBezier expects count*3-2 points. */
2774     INT i, len_pt = count*3-2, save_state;
2775     GpPointF *pt;
2776     REAL x1, x2, y1, y2;
2777     GpStatus retval;
2778
2779     TRACE("(%p, %p, %p, %d, %.2f)\n", graphics, pen, points, count, tension);
2780
2781     if(!graphics || !pen)
2782         return InvalidParameter;
2783
2784     if(graphics->busy)
2785         return ObjectBusy;
2786
2787     if(count < 2)
2788         return InvalidParameter;
2789
2790     if (!graphics->hdc)
2791     {
2792         FIXME("graphics object has no HDC\n");
2793         return Ok;
2794     }
2795
2796     pt = GdipAlloc(len_pt * sizeof(GpPointF));
2797     if(!pt)
2798         return OutOfMemory;
2799
2800     tension = tension * TENSION_CONST;
2801
2802     calc_curve_bezier_endp(points[0].X, points[0].Y, points[1].X, points[1].Y,
2803         tension, &x1, &y1);
2804
2805     pt[0].X = points[0].X;
2806     pt[0].Y = points[0].Y;
2807     pt[1].X = x1;
2808     pt[1].Y = y1;
2809
2810     for(i = 0; i < count-2; i++){
2811         calc_curve_bezier(&(points[i]), tension, &x1, &y1, &x2, &y2);
2812
2813         pt[3*i+2].X = x1;
2814         pt[3*i+2].Y = y1;
2815         pt[3*i+3].X = points[i+1].X;
2816         pt[3*i+3].Y = points[i+1].Y;
2817         pt[3*i+4].X = x2;
2818         pt[3*i+4].Y = y2;
2819     }
2820
2821     calc_curve_bezier_endp(points[count-1].X, points[count-1].Y,
2822         points[count-2].X, points[count-2].Y, tension, &x1, &y1);
2823
2824     pt[len_pt-2].X = x1;
2825     pt[len_pt-2].Y = y1;
2826     pt[len_pt-1].X = points[count-1].X;
2827     pt[len_pt-1].Y = points[count-1].Y;
2828
2829     save_state = prepare_dc(graphics, pen);
2830
2831     retval = draw_polybezier(graphics, pen, pt, len_pt, TRUE);
2832
2833     GdipFree(pt);
2834     restore_dc(graphics, save_state);
2835
2836     return retval;
2837 }
2838
2839 GpStatus WINGDIPAPI GdipDrawCurve2I(GpGraphics *graphics, GpPen *pen,
2840     GDIPCONST GpPoint *points, INT count, REAL tension)
2841 {
2842     GpPointF *pointsF;
2843     GpStatus ret;
2844     INT i;
2845
2846     TRACE("(%p, %p, %p, %d, %.2f)\n", graphics, pen, points, count, tension);
2847
2848     if(!points)
2849         return InvalidParameter;
2850
2851     pointsF = GdipAlloc(sizeof(GpPointF)*count);
2852     if(!pointsF)
2853         return OutOfMemory;
2854
2855     for(i = 0; i < count; i++){
2856         pointsF[i].X = (REAL)points[i].X;
2857         pointsF[i].Y = (REAL)points[i].Y;
2858     }
2859
2860     ret = GdipDrawCurve2(graphics,pen,pointsF,count,tension);
2861     GdipFree(pointsF);
2862
2863     return ret;
2864 }
2865
2866 GpStatus WINGDIPAPI GdipDrawCurve3(GpGraphics *graphics, GpPen *pen,
2867     GDIPCONST GpPointF *points, INT count, INT offset, INT numberOfSegments,
2868     REAL tension)
2869 {
2870     TRACE("(%p, %p, %p, %d, %d, %d, %.2f)\n", graphics, pen, points, count, offset, numberOfSegments, tension);
2871
2872     if(offset >= count || numberOfSegments > count - offset - 1 || numberOfSegments <= 0){
2873         return InvalidParameter;
2874     }
2875
2876     return GdipDrawCurve2(graphics, pen, points + offset, numberOfSegments + 1, tension);
2877 }
2878
2879 GpStatus WINGDIPAPI GdipDrawCurve3I(GpGraphics *graphics, GpPen *pen,
2880     GDIPCONST GpPoint *points, INT count, INT offset, INT numberOfSegments,
2881     REAL tension)
2882 {
2883     TRACE("(%p, %p, %p, %d, %d, %d, %.2f)\n", graphics, pen, points, count, offset, numberOfSegments, tension);
2884
2885     if(count < 0){
2886         return OutOfMemory;
2887     }
2888
2889     if(offset >= count || numberOfSegments > count - offset - 1 || numberOfSegments <= 0){
2890         return InvalidParameter;
2891     }
2892
2893     return GdipDrawCurve2I(graphics, pen, points + offset, numberOfSegments + 1, tension);
2894 }
2895
2896 GpStatus WINGDIPAPI GdipDrawEllipse(GpGraphics *graphics, GpPen *pen, REAL x,
2897     REAL y, REAL width, REAL height)
2898 {
2899     INT save_state;
2900     GpPointF ptf[2];
2901     POINT pti[2];
2902
2903     TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f)\n", graphics, pen, x, y, width, height);
2904
2905     if(!graphics || !pen)
2906         return InvalidParameter;
2907
2908     if(graphics->busy)
2909         return ObjectBusy;
2910
2911     if (!graphics->hdc)
2912     {
2913         FIXME("graphics object has no HDC\n");
2914         return Ok;
2915     }
2916
2917     ptf[0].X = x;
2918     ptf[0].Y = y;
2919     ptf[1].X = x + width;
2920     ptf[1].Y = y + height;
2921
2922     save_state = prepare_dc(graphics, pen);
2923     SelectObject(graphics->hdc, GetStockObject(NULL_BRUSH));
2924
2925     transform_and_round_points(graphics, pti, ptf, 2);
2926
2927     Ellipse(graphics->hdc, pti[0].x, pti[0].y, pti[1].x, pti[1].y);
2928
2929     restore_dc(graphics, save_state);
2930
2931     return Ok;
2932 }
2933
2934 GpStatus WINGDIPAPI GdipDrawEllipseI(GpGraphics *graphics, GpPen *pen, INT x,
2935     INT y, INT width, INT height)
2936 {
2937     TRACE("(%p, %p, %d, %d, %d, %d)\n", graphics, pen, x, y, width, height);
2938
2939     return GdipDrawEllipse(graphics,pen,(REAL)x,(REAL)y,(REAL)width,(REAL)height);
2940 }
2941
2942
2943 GpStatus WINGDIPAPI GdipDrawImage(GpGraphics *graphics, GpImage *image, REAL x, REAL y)
2944 {
2945     UINT width, height;
2946
2947     TRACE("(%p, %p, %.2f, %.2f)\n", graphics, image, x, y);
2948
2949     if(!graphics || !image)
2950         return InvalidParameter;
2951
2952     GdipGetImageWidth(image, &width);
2953     GdipGetImageHeight(image, &height);
2954
2955     return GdipDrawImagePointRect(graphics, image, x, y,
2956                                   0.0, 0.0, (REAL)width, (REAL)height, UnitPixel);
2957 }
2958
2959 GpStatus WINGDIPAPI GdipDrawImageI(GpGraphics *graphics, GpImage *image, INT x,
2960     INT y)
2961 {
2962     TRACE("(%p, %p, %d, %d)\n", graphics, image, x, y);
2963
2964     return GdipDrawImage(graphics, image, (REAL)x, (REAL)y);
2965 }
2966
2967 GpStatus WINGDIPAPI GdipDrawImagePointRect(GpGraphics *graphics, GpImage *image,
2968     REAL x, REAL y, REAL srcx, REAL srcy, REAL srcwidth, REAL srcheight,
2969     GpUnit srcUnit)
2970 {
2971     GpPointF points[3];
2972     REAL scale_x, scale_y, width, height;
2973
2974     TRACE("(%p, %p, %f, %f, %f, %f, %f, %f, %d)\n", graphics, image, x, y, srcx, srcy, srcwidth, srcheight, srcUnit);
2975
2976     scale_x = units_scale(srcUnit, graphics->unit, graphics->xres);
2977     scale_x *= graphics->xres / image->xres;
2978     scale_y = units_scale(srcUnit, graphics->unit, graphics->yres);
2979     scale_y *= graphics->yres / image->yres;
2980     width = srcwidth * scale_x;
2981     height = srcheight * scale_y;
2982
2983     points[0].X = points[2].X = x;
2984     points[0].Y = points[1].Y = y;
2985     points[1].X = x + width;
2986     points[2].Y = y + height;
2987
2988     return GdipDrawImagePointsRect(graphics, image, points, 3, srcx, srcy,
2989         srcwidth, srcheight, srcUnit, NULL, NULL, NULL);
2990 }
2991
2992 GpStatus WINGDIPAPI GdipDrawImagePointRectI(GpGraphics *graphics, GpImage *image,
2993     INT x, INT y, INT srcx, INT srcy, INT srcwidth, INT srcheight,
2994     GpUnit srcUnit)
2995 {
2996     return GdipDrawImagePointRect(graphics, image, x, y, srcx, srcy, srcwidth, srcheight, srcUnit);
2997 }
2998
2999 GpStatus WINGDIPAPI GdipDrawImagePoints(GpGraphics *graphics, GpImage *image,
3000     GDIPCONST GpPointF *dstpoints, INT count)
3001 {
3002     UINT width, height;
3003
3004     TRACE("(%p, %p, %p, %d)\n", graphics, image, dstpoints, count);
3005
3006     if(!image)
3007         return InvalidParameter;
3008
3009     GdipGetImageWidth(image, &width);
3010     GdipGetImageHeight(image, &height);
3011
3012     return GdipDrawImagePointsRect(graphics, image, dstpoints, count, 0, 0,
3013         width, height, UnitPixel, NULL, NULL, NULL);
3014 }
3015
3016 GpStatus WINGDIPAPI GdipDrawImagePointsI(GpGraphics *graphics, GpImage *image,
3017     GDIPCONST GpPoint *dstpoints, INT count)
3018 {
3019     GpPointF ptf[3];
3020
3021     TRACE("(%p, %p, %p, %d)\n", graphics, image, dstpoints, count);
3022
3023     if (count != 3 || !dstpoints)
3024         return InvalidParameter;
3025
3026     ptf[0].X = (REAL)dstpoints[0].X;
3027     ptf[0].Y = (REAL)dstpoints[0].Y;
3028     ptf[1].X = (REAL)dstpoints[1].X;
3029     ptf[1].Y = (REAL)dstpoints[1].Y;
3030     ptf[2].X = (REAL)dstpoints[2].X;
3031     ptf[2].Y = (REAL)dstpoints[2].Y;
3032
3033     return GdipDrawImagePoints(graphics, image, ptf, count);
3034 }
3035
3036 GpStatus WINGDIPAPI GdipDrawImagePointsRect(GpGraphics *graphics, GpImage *image,
3037      GDIPCONST GpPointF *points, INT count, REAL srcx, REAL srcy, REAL srcwidth,
3038      REAL srcheight, GpUnit srcUnit, GDIPCONST GpImageAttributes* imageAttributes,
3039      DrawImageAbort callback, VOID * callbackData)
3040 {
3041     GpPointF ptf[4];
3042     POINT pti[4];
3043     GpStatus stat;
3044
3045     TRACE("(%p, %p, %p, %d, %f, %f, %f, %f, %d, %p, %p, %p)\n", graphics, image, points,
3046           count, srcx, srcy, srcwidth, srcheight, srcUnit, imageAttributes, callback,
3047           callbackData);
3048
3049     if (count > 3)
3050         return NotImplemented;
3051
3052     if(!graphics || !image || !points || count != 3)
3053          return InvalidParameter;
3054
3055     TRACE("%s %s %s\n", debugstr_pointf(&points[0]), debugstr_pointf(&points[1]),
3056         debugstr_pointf(&points[2]));
3057
3058     memcpy(ptf, points, 3 * sizeof(GpPointF));
3059     ptf[3].X = ptf[2].X + ptf[1].X - ptf[0].X;
3060     ptf[3].Y = ptf[2].Y + ptf[1].Y - ptf[0].Y;
3061     if (!srcwidth || !srcheight || ptf[3].X == ptf[0].X || ptf[3].Y == ptf[0].Y)
3062         return Ok;
3063     transform_and_round_points(graphics, pti, ptf, 4);
3064
3065     TRACE("%s %s %s %s\n", wine_dbgstr_point(&pti[0]), wine_dbgstr_point(&pti[1]),
3066         wine_dbgstr_point(&pti[2]), wine_dbgstr_point(&pti[3]));
3067
3068     srcx = units_to_pixels(srcx, srcUnit, image->xres);
3069     srcy = units_to_pixels(srcy, srcUnit, image->yres);
3070     srcwidth = units_to_pixels(srcwidth, srcUnit, image->xres);
3071     srcheight = units_to_pixels(srcheight, srcUnit, image->yres);
3072     TRACE("src pixels: %f,%f %fx%f\n", srcx, srcy, srcwidth, srcheight);
3073
3074     if (image->picture)
3075     {
3076         if (!graphics->hdc)
3077         {
3078             FIXME("graphics object has no HDC\n");
3079         }
3080
3081         if(IPicture_Render(image->picture, graphics->hdc,
3082             pti[0].x, pti[0].y, pti[1].x - pti[0].x, pti[2].y - pti[0].y,
3083             srcx, srcy, srcwidth, srcheight, NULL) != S_OK)
3084         {
3085             if(callback)
3086                 callback(callbackData);
3087             return GenericError;
3088         }
3089     }
3090     else if (image->type == ImageTypeBitmap)
3091     {
3092         GpBitmap* bitmap = (GpBitmap*)image;
3093         int use_software=0;
3094
3095         if (imageAttributes ||
3096             (graphics->image && graphics->image->type == ImageTypeBitmap) ||
3097             !((GpBitmap*)image)->hbitmap ||
3098             ptf[1].Y != ptf[0].Y || ptf[2].X != ptf[0].X ||
3099             ptf[1].X - ptf[0].X != srcwidth || ptf[2].Y - ptf[0].Y != srcheight ||
3100             srcx < 0 || srcy < 0 ||
3101             srcx + srcwidth > bitmap->width || srcy + srcheight > bitmap->height)
3102             use_software = 1;
3103
3104         if (use_software)
3105         {
3106             RECT dst_area;
3107             GpRect src_area;
3108             int i, x, y, src_stride, dst_stride;
3109             GpMatrix *dst_to_src;
3110             REAL m11, m12, m21, m22, mdx, mdy;
3111             LPBYTE src_data, dst_data;
3112             BitmapData lockeddata;
3113             InterpolationMode interpolation = graphics->interpolation;
3114             GpPointF dst_to_src_points[3] = {{0.0, 0.0}, {1.0, 0.0}, {0.0, 1.0}};
3115             REAL x_dx, x_dy, y_dx, y_dy;
3116             static const GpImageAttributes defaultImageAttributes = {WrapModeClamp, 0, FALSE};
3117
3118             if (!imageAttributes)
3119                 imageAttributes = &defaultImageAttributes;
3120
3121             dst_area.left = dst_area.right = pti[0].x;
3122             dst_area.top = dst_area.bottom = pti[0].y;
3123             for (i=1; i<4; i++)
3124             {
3125                 if (dst_area.left > pti[i].x) dst_area.left = pti[i].x;
3126                 if (dst_area.right < pti[i].x) dst_area.right = pti[i].x;
3127                 if (dst_area.top > pti[i].y) dst_area.top = pti[i].y;
3128                 if (dst_area.bottom < pti[i].y) dst_area.bottom = pti[i].y;
3129             }
3130
3131             TRACE("dst_area: %s\n", wine_dbgstr_rect(&dst_area));
3132
3133             m11 = (ptf[1].X - ptf[0].X) / srcwidth;
3134             m21 = (ptf[2].X - ptf[0].X) / srcheight;
3135             mdx = ptf[0].X - m11 * srcx - m21 * srcy;
3136             m12 = (ptf[1].Y - ptf[0].Y) / srcwidth;
3137             m22 = (ptf[2].Y - ptf[0].Y) / srcheight;
3138             mdy = ptf[0].Y - m12 * srcx - m22 * srcy;
3139
3140             stat = GdipCreateMatrix2(m11, m12, m21, m22, mdx, mdy, &dst_to_src);
3141             if (stat != Ok) return stat;
3142
3143             stat = GdipInvertMatrix(dst_to_src);
3144             if (stat != Ok)
3145             {
3146                 GdipDeleteMatrix(dst_to_src);
3147                 return stat;
3148             }
3149
3150             dst_data = GdipAlloc(sizeof(ARGB) * (dst_area.right - dst_area.left) * (dst_area.bottom - dst_area.top));
3151             if (!dst_data)
3152             {
3153                 GdipDeleteMatrix(dst_to_src);
3154                 return OutOfMemory;
3155             }
3156
3157             dst_stride = sizeof(ARGB) * (dst_area.right - dst_area.left);
3158
3159             get_bitmap_sample_size(interpolation, imageAttributes->wrap,
3160                 bitmap, srcx, srcy, srcwidth, srcheight, &src_area);
3161
3162             TRACE("src_area: %d x %d\n", src_area.Width, src_area.Height);
3163
3164             src_data = GdipAlloc(sizeof(ARGB) * src_area.Width * src_area.Height);
3165             if (!src_data)
3166             {
3167                 GdipFree(dst_data);
3168                 GdipDeleteMatrix(dst_to_src);
3169                 return OutOfMemory;
3170             }
3171             src_stride = sizeof(ARGB) * src_area.Width;
3172
3173             /* Read the bits we need from the source bitmap into an ARGB buffer. */
3174             lockeddata.Width = src_area.Width;
3175             lockeddata.Height = src_area.Height;
3176             lockeddata.Stride = src_stride;
3177             lockeddata.PixelFormat = PixelFormat32bppARGB;
3178             lockeddata.Scan0 = src_data;
3179
3180             stat = GdipBitmapLockBits(bitmap, &src_area, ImageLockModeRead|ImageLockModeUserInputBuf,
3181                 PixelFormat32bppARGB, &lockeddata);
3182
3183             if (stat == Ok)
3184                 stat = GdipBitmapUnlockBits(bitmap, &lockeddata);
3185
3186             if (stat != Ok)
3187             {
3188                 if (src_data != dst_data)
3189                     GdipFree(src_data);
3190                 GdipFree(dst_data);
3191                 GdipDeleteMatrix(dst_to_src);
3192                 return OutOfMemory;
3193             }
3194
3195             apply_image_attributes(imageAttributes, src_data,
3196                 src_area.Width, src_area.Height,
3197                 src_stride, ColorAdjustTypeBitmap);
3198
3199             /* Transform the bits as needed to the destination. */
3200             GdipTransformMatrixPoints(dst_to_src, dst_to_src_points, 3);
3201
3202             x_dx = dst_to_src_points[1].X - dst_to_src_points[0].X;
3203             x_dy = dst_to_src_points[1].Y - dst_to_src_points[0].Y;
3204             y_dx = dst_to_src_points[2].X - dst_to_src_points[0].X;
3205             y_dy = dst_to_src_points[2].Y - dst_to_src_points[0].Y;
3206
3207             for (x=dst_area.left; x<dst_area.right; x++)
3208             {
3209                 for (y=dst_area.top; y<dst_area.bottom; y++)
3210                 {
3211                     GpPointF src_pointf;
3212                     ARGB *dst_color;
3213
3214                     src_pointf.X = dst_to_src_points[0].X + x * x_dx + y * y_dx;
3215                     src_pointf.Y = dst_to_src_points[0].Y + x * x_dy + y * y_dy;
3216
3217                     dst_color = (ARGB*)(dst_data + dst_stride * (y - dst_area.top) + sizeof(ARGB) * (x - dst_area.left));
3218
3219                     if (src_pointf.X >= srcx && src_pointf.X < srcx + srcwidth && src_pointf.Y >= srcy && src_pointf.Y < srcy+srcheight)
3220                         *dst_color = resample_bitmap_pixel(&src_area, src_data, bitmap->width, bitmap->height, &src_pointf, imageAttributes, interpolation);
3221                     else
3222                         *dst_color = 0;
3223                 }
3224             }
3225
3226             GdipDeleteMatrix(dst_to_src);
3227
3228             GdipFree(src_data);
3229
3230             stat = alpha_blend_pixels(graphics, dst_area.left, dst_area.top,
3231                 dst_data, dst_area.right - dst_area.left, dst_area.bottom - dst_area.top, dst_stride);
3232
3233             GdipFree(dst_data);
3234
3235             return stat;
3236         }
3237         else
3238         {
3239             HDC hdc;
3240             int temp_hdc=0, temp_bitmap=0;
3241             HBITMAP hbitmap, old_hbm=NULL;
3242
3243             if (!(bitmap->format == PixelFormat16bppRGB555 ||
3244                   bitmap->format == PixelFormat24bppRGB ||
3245                   bitmap->format == PixelFormat32bppRGB ||
3246                   bitmap->format == PixelFormat32bppPARGB))
3247             {
3248                 BITMAPINFOHEADER bih;
3249                 BYTE *temp_bits;
3250                 PixelFormat dst_format;
3251
3252                 /* we can't draw a bitmap of this format directly */
3253                 hdc = CreateCompatibleDC(0);
3254                 temp_hdc = 1;
3255                 temp_bitmap = 1;
3256
3257                 bih.biSize = sizeof(BITMAPINFOHEADER);
3258                 bih.biWidth = bitmap->width;
3259                 bih.biHeight = -bitmap->height;
3260                 bih.biPlanes = 1;
3261                 bih.biBitCount = 32;
3262                 bih.biCompression = BI_RGB;
3263                 bih.biSizeImage = 0;
3264                 bih.biXPelsPerMeter = 0;
3265                 bih.biYPelsPerMeter = 0;
3266                 bih.biClrUsed = 0;
3267                 bih.biClrImportant = 0;
3268
3269                 hbitmap = CreateDIBSection(hdc, (BITMAPINFO*)&bih, DIB_RGB_COLORS,
3270                     (void**)&temp_bits, NULL, 0);
3271
3272                 if (bitmap->format & (PixelFormatAlpha|PixelFormatPAlpha))
3273                     dst_format = PixelFormat32bppPARGB;
3274                 else
3275                     dst_format = PixelFormat32bppRGB;
3276
3277                 convert_pixels(bitmap->width, bitmap->height,
3278                     bitmap->width*4, temp_bits, dst_format,
3279                     bitmap->stride, bitmap->bits, bitmap->format,
3280                     bitmap->image.palette);
3281             }
3282             else
3283             {
3284                 hbitmap = bitmap->hbitmap;
3285                 hdc = bitmap->hdc;
3286                 temp_hdc = (hdc == 0);
3287             }
3288
3289             if (temp_hdc)
3290             {
3291                 if (!hdc) hdc = CreateCompatibleDC(0);
3292                 old_hbm = SelectObject(hdc, hbitmap);
3293             }
3294
3295             if (bitmap->format & (PixelFormatAlpha|PixelFormatPAlpha))
3296             {
3297                 gdi_alpha_blend(graphics, pti[0].x, pti[0].y, pti[1].x - pti[0].x, pti[2].y - pti[0].y,
3298                                 hdc, srcx, srcy, srcwidth, srcheight);
3299             }
3300             else
3301             {
3302                 StretchBlt(graphics->hdc, pti[0].x, pti[0].y, pti[1].x-pti[0].x, pti[2].y-pti[0].y,
3303                     hdc, srcx, srcy, srcwidth, srcheight, SRCCOPY);
3304             }
3305
3306             if (temp_hdc)
3307             {
3308                 SelectObject(hdc, old_hbm);
3309                 DeleteDC(hdc);
3310             }
3311
3312             if (temp_bitmap)
3313                 DeleteObject(hbitmap);
3314         }
3315     }
3316     else
3317     {
3318         ERR("GpImage with no IPicture or HBITMAP?!\n");
3319         return NotImplemented;
3320     }
3321
3322     return Ok;
3323 }
3324
3325 GpStatus WINGDIPAPI GdipDrawImagePointsRectI(GpGraphics *graphics, GpImage *image,
3326      GDIPCONST GpPoint *points, INT count, INT srcx, INT srcy, INT srcwidth,
3327      INT srcheight, GpUnit srcUnit, GDIPCONST GpImageAttributes* imageAttributes,
3328      DrawImageAbort callback, VOID * callbackData)
3329 {
3330     GpPointF pointsF[3];
3331     INT i;
3332
3333     TRACE("(%p, %p, %p, %d, %d, %d, %d, %d, %d, %p, %p, %p)\n", graphics, image, points, count,
3334           srcx, srcy, srcwidth, srcheight, srcUnit, imageAttributes, callback,
3335           callbackData);
3336
3337     if(!points || count!=3)
3338         return InvalidParameter;
3339
3340     for(i = 0; i < count; i++){
3341         pointsF[i].X = (REAL)points[i].X;
3342         pointsF[i].Y = (REAL)points[i].Y;
3343     }
3344
3345     return GdipDrawImagePointsRect(graphics, image, pointsF, count, (REAL)srcx, (REAL)srcy,
3346                                    (REAL)srcwidth, (REAL)srcheight, srcUnit, imageAttributes,
3347                                    callback, callbackData);
3348 }
3349
3350 GpStatus WINGDIPAPI GdipDrawImageRectRect(GpGraphics *graphics, GpImage *image,
3351     REAL dstx, REAL dsty, REAL dstwidth, REAL dstheight, REAL srcx, REAL srcy,
3352     REAL srcwidth, REAL srcheight, GpUnit srcUnit,
3353     GDIPCONST GpImageAttributes* imageattr, DrawImageAbort callback,
3354     VOID * callbackData)
3355 {
3356     GpPointF points[3];
3357
3358     TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %d, %p, %p, %p)\n",
3359           graphics, image, dstx, dsty, dstwidth, dstheight, srcx, srcy,
3360           srcwidth, srcheight, srcUnit, imageattr, callback, callbackData);
3361
3362     points[0].X = dstx;
3363     points[0].Y = dsty;
3364     points[1].X = dstx + dstwidth;
3365     points[1].Y = dsty;
3366     points[2].X = dstx;
3367     points[2].Y = dsty + dstheight;
3368
3369     return GdipDrawImagePointsRect(graphics, image, points, 3, srcx, srcy,
3370                srcwidth, srcheight, srcUnit, imageattr, callback, callbackData);
3371 }
3372
3373 GpStatus WINGDIPAPI GdipDrawImageRectRectI(GpGraphics *graphics, GpImage *image,
3374         INT dstx, INT dsty, INT dstwidth, INT dstheight, INT srcx, INT srcy,
3375         INT srcwidth, INT srcheight, GpUnit srcUnit,
3376         GDIPCONST GpImageAttributes* imageAttributes, DrawImageAbort callback,
3377         VOID * callbackData)
3378 {
3379     GpPointF points[3];
3380
3381     TRACE("(%p, %p, %d, %d, %d, %d, %d, %d, %d, %d, %d, %p, %p, %p)\n",
3382           graphics, image, dstx, dsty, dstwidth, dstheight, srcx, srcy,
3383           srcwidth, srcheight, srcUnit, imageAttributes, callback, callbackData);
3384
3385     points[0].X = dstx;
3386     points[0].Y = dsty;
3387     points[1].X = dstx + dstwidth;
3388     points[1].Y = dsty;
3389     points[2].X = dstx;
3390     points[2].Y = dsty + dstheight;
3391
3392     return GdipDrawImagePointsRect(graphics, image, points, 3, srcx, srcy,
3393                srcwidth, srcheight, srcUnit, imageAttributes, callback, callbackData);
3394 }
3395
3396 GpStatus WINGDIPAPI GdipDrawImageRect(GpGraphics *graphics, GpImage *image,
3397     REAL x, REAL y, REAL width, REAL height)
3398 {
3399     RectF bounds;
3400     GpUnit unit;
3401     GpStatus ret;
3402
3403     TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f)\n", graphics, image, x, y, width, height);
3404
3405     if(!graphics || !image)
3406         return InvalidParameter;
3407
3408     ret = GdipGetImageBounds(image, &bounds, &unit);
3409     if(ret != Ok)
3410         return ret;
3411
3412     return GdipDrawImageRectRect(graphics, image, x, y, width, height,
3413                                  bounds.X, bounds.Y, bounds.Width, bounds.Height,
3414                                  unit, NULL, NULL, NULL);
3415 }
3416
3417 GpStatus WINGDIPAPI GdipDrawImageRectI(GpGraphics *graphics, GpImage *image,
3418     INT x, INT y, INT width, INT height)
3419 {
3420     TRACE("(%p, %p, %d, %d, %d, %d)\n", graphics, image, x, y, width, height);
3421
3422     return GdipDrawImageRect(graphics, image, (REAL)x, (REAL)y, (REAL)width, (REAL)height);
3423 }
3424
3425 GpStatus WINGDIPAPI GdipDrawLine(GpGraphics *graphics, GpPen *pen, REAL x1,
3426     REAL y1, REAL x2, REAL y2)
3427 {
3428     INT save_state;
3429     GpPointF pt[2];
3430     GpStatus retval;
3431
3432     TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f)\n", graphics, pen, x1, y1, x2, y2);
3433
3434     if(!pen || !graphics)
3435         return InvalidParameter;
3436
3437     if(graphics->busy)
3438         return ObjectBusy;
3439
3440     if (!graphics->hdc)
3441     {
3442         FIXME("graphics object has no HDC\n");
3443         return Ok;
3444     }
3445
3446     pt[0].X = x1;
3447     pt[0].Y = y1;
3448     pt[1].X = x2;
3449     pt[1].Y = y2;
3450
3451     save_state = prepare_dc(graphics, pen);
3452
3453     retval = draw_polyline(graphics, pen, pt, 2, TRUE);
3454
3455     restore_dc(graphics, save_state);
3456
3457     return retval;
3458 }
3459
3460 GpStatus WINGDIPAPI GdipDrawLineI(GpGraphics *graphics, GpPen *pen, INT x1,
3461     INT y1, INT x2, INT y2)
3462 {
3463     INT save_state;
3464     GpPointF pt[2];
3465     GpStatus retval;
3466
3467     TRACE("(%p, %p, %d, %d, %d, %d)\n", graphics, pen, x1, y1, x2, y2);
3468
3469     if(!pen || !graphics)
3470         return InvalidParameter;
3471
3472     if(graphics->busy)
3473         return ObjectBusy;
3474
3475     if (!graphics->hdc)
3476     {
3477         FIXME("graphics object has no HDC\n");
3478         return Ok;
3479     }
3480
3481     pt[0].X = (REAL)x1;
3482     pt[0].Y = (REAL)y1;
3483     pt[1].X = (REAL)x2;
3484     pt[1].Y = (REAL)y2;
3485
3486     save_state = prepare_dc(graphics, pen);
3487
3488     retval = draw_polyline(graphics, pen, pt, 2, TRUE);
3489
3490     restore_dc(graphics, save_state);
3491
3492     return retval;
3493 }
3494
3495 GpStatus WINGDIPAPI GdipDrawLines(GpGraphics *graphics, GpPen *pen, GDIPCONST
3496     GpPointF *points, INT count)
3497 {
3498     INT save_state;
3499     GpStatus retval;
3500
3501     TRACE("(%p, %p, %p, %d)\n", graphics, pen, points, count);
3502
3503     if(!pen || !graphics || (count < 2))
3504         return InvalidParameter;
3505
3506     if(graphics->busy)
3507         return ObjectBusy;
3508
3509     if (!graphics->hdc)
3510     {
3511         FIXME("graphics object has no HDC\n");
3512         return Ok;
3513     }
3514
3515     save_state = prepare_dc(graphics, pen);
3516
3517     retval = draw_polyline(graphics, pen, points, count, TRUE);
3518
3519     restore_dc(graphics, save_state);
3520
3521     return retval;
3522 }
3523
3524 GpStatus WINGDIPAPI GdipDrawLinesI(GpGraphics *graphics, GpPen *pen, GDIPCONST
3525     GpPoint *points, INT count)
3526 {
3527     INT save_state;
3528     GpStatus retval;
3529     GpPointF *ptf = NULL;
3530     int i;
3531
3532     TRACE("(%p, %p, %p, %d)\n", graphics, pen, points, count);
3533
3534     if(!pen || !graphics || (count < 2))
3535         return InvalidParameter;
3536
3537     if(graphics->busy)
3538         return ObjectBusy;
3539
3540     if (!graphics->hdc)
3541     {
3542         FIXME("graphics object has no HDC\n");
3543         return Ok;
3544     }
3545
3546     ptf = GdipAlloc(count * sizeof(GpPointF));
3547     if(!ptf) return OutOfMemory;
3548
3549     for(i = 0; i < count; i ++){
3550         ptf[i].X = (REAL) points[i].X;
3551         ptf[i].Y = (REAL) points[i].Y;
3552     }
3553
3554     save_state = prepare_dc(graphics, pen);
3555
3556     retval = draw_polyline(graphics, pen, ptf, count, TRUE);
3557
3558     restore_dc(graphics, save_state);
3559
3560     GdipFree(ptf);
3561     return retval;
3562 }
3563
3564 GpStatus WINGDIPAPI GdipDrawPath(GpGraphics *graphics, GpPen *pen, GpPath *path)
3565 {
3566     INT save_state;
3567     GpStatus retval;
3568
3569     TRACE("(%p, %p, %p)\n", graphics, pen, path);
3570
3571     if(!pen || !graphics)
3572         return InvalidParameter;
3573
3574     if(graphics->busy)
3575         return ObjectBusy;
3576
3577     if (!graphics->hdc)
3578     {
3579         FIXME("graphics object has no HDC\n");
3580         return Ok;
3581     }
3582
3583     save_state = prepare_dc(graphics, pen);
3584
3585     retval = draw_poly(graphics, pen, path->pathdata.Points,
3586                        path->pathdata.Types, path->pathdata.Count, TRUE);
3587
3588     restore_dc(graphics, save_state);
3589
3590     return retval;
3591 }
3592
3593 GpStatus WINGDIPAPI GdipDrawPie(GpGraphics *graphics, GpPen *pen, REAL x,
3594     REAL y, REAL width, REAL height, REAL startAngle, REAL sweepAngle)
3595 {
3596     INT save_state;
3597
3598     TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f)\n", graphics, pen, x, y,
3599             width, height, startAngle, sweepAngle);
3600
3601     if(!graphics || !pen)
3602         return InvalidParameter;
3603
3604     if(graphics->busy)
3605         return ObjectBusy;
3606
3607     if (!graphics->hdc)
3608     {
3609         FIXME("graphics object has no HDC\n");
3610         return Ok;
3611     }
3612
3613     save_state = prepare_dc(graphics, pen);
3614     SelectObject(graphics->hdc, GetStockObject(NULL_BRUSH));
3615
3616     draw_pie(graphics, x, y, width, height, startAngle, sweepAngle);
3617
3618     restore_dc(graphics, save_state);
3619
3620     return Ok;
3621 }
3622
3623 GpStatus WINGDIPAPI GdipDrawPieI(GpGraphics *graphics, GpPen *pen, INT x,
3624     INT y, INT width, INT height, REAL startAngle, REAL sweepAngle)
3625 {
3626     TRACE("(%p, %p, %d, %d, %d, %d, %.2f, %.2f)\n", graphics, pen, x, y,
3627             width, height, startAngle, sweepAngle);
3628
3629     return GdipDrawPie(graphics,pen,(REAL)x,(REAL)y,(REAL)width,(REAL)height,startAngle,sweepAngle);
3630 }
3631
3632 GpStatus WINGDIPAPI GdipDrawRectangle(GpGraphics *graphics, GpPen *pen, REAL x,
3633     REAL y, REAL width, REAL height)
3634 {
3635     INT save_state;
3636     GpPointF ptf[4];
3637     POINT pti[4];
3638
3639     TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f)\n", graphics, pen, x, y, width, height);
3640
3641     if(!pen || !graphics)
3642         return InvalidParameter;
3643
3644     if(graphics->busy)
3645         return ObjectBusy;
3646
3647     if (!graphics->hdc)
3648     {
3649         FIXME("graphics object has no HDC\n");
3650         return Ok;
3651     }
3652
3653     ptf[0].X = x;
3654     ptf[0].Y = y;
3655     ptf[1].X = x + width;
3656     ptf[1].Y = y;
3657     ptf[2].X = x + width;
3658     ptf[2].Y = y + height;
3659     ptf[3].X = x;
3660     ptf[3].Y = y + height;
3661
3662     save_state = prepare_dc(graphics, pen);
3663     SelectObject(graphics->hdc, GetStockObject(NULL_BRUSH));
3664
3665     transform_and_round_points(graphics, pti, ptf, 4);
3666     Polygon(graphics->hdc, pti, 4);
3667
3668     restore_dc(graphics, save_state);
3669
3670     return Ok;
3671 }
3672
3673 GpStatus WINGDIPAPI GdipDrawRectangleI(GpGraphics *graphics, GpPen *pen, INT x,
3674     INT y, INT width, INT height)
3675 {
3676     TRACE("(%p, %p, %d, %d, %d, %d)\n", graphics, pen, x, y, width, height);
3677
3678     return GdipDrawRectangle(graphics,pen,(REAL)x,(REAL)y,(REAL)width,(REAL)height);
3679 }
3680
3681 GpStatus WINGDIPAPI GdipDrawRectangles(GpGraphics *graphics, GpPen *pen,
3682     GDIPCONST GpRectF* rects, INT count)
3683 {
3684     GpPointF *ptf;
3685     POINT *pti;
3686     INT save_state, i;
3687
3688     TRACE("(%p, %p, %p, %d)\n", graphics, pen, rects, count);
3689
3690     if(!graphics || !pen || !rects || count < 1)
3691         return InvalidParameter;
3692
3693     if(graphics->busy)
3694         return ObjectBusy;
3695
3696     if (!graphics->hdc)
3697     {
3698         FIXME("graphics object has no HDC\n");
3699         return Ok;
3700     }
3701
3702     ptf = GdipAlloc(4 * count * sizeof(GpPointF));
3703     pti = GdipAlloc(4 * count * sizeof(POINT));
3704
3705     if(!ptf || !pti){
3706         GdipFree(ptf);
3707         GdipFree(pti);
3708         return OutOfMemory;
3709     }
3710
3711     for(i = 0; i < count; i++){
3712         ptf[4 * i + 3].X = ptf[4 * i].X = rects[i].X;
3713         ptf[4 * i + 1].Y = ptf[4 * i].Y = rects[i].Y;
3714         ptf[4 * i + 2].X = ptf[4 * i + 1].X = rects[i].X + rects[i].Width;
3715         ptf[4 * i + 3].Y = ptf[4 * i + 2].Y = rects[i].Y + rects[i].Height;
3716     }
3717
3718     save_state = prepare_dc(graphics, pen);
3719     SelectObject(graphics->hdc, GetStockObject(NULL_BRUSH));
3720
3721     transform_and_round_points(graphics, pti, ptf, 4 * count);
3722
3723     for(i = 0; i < count; i++)
3724         Polygon(graphics->hdc, &pti[4 * i], 4);
3725
3726     restore_dc(graphics, save_state);
3727
3728     GdipFree(ptf);
3729     GdipFree(pti);
3730
3731     return Ok;
3732 }
3733
3734 GpStatus WINGDIPAPI GdipDrawRectanglesI(GpGraphics *graphics, GpPen *pen,
3735     GDIPCONST GpRect* rects, INT count)
3736 {
3737     GpRectF *rectsF;
3738     GpStatus ret;
3739     INT i;
3740
3741     TRACE("(%p, %p, %p, %d)\n", graphics, pen, rects, count);
3742
3743     if(!rects || count<=0)
3744         return InvalidParameter;
3745
3746     rectsF = GdipAlloc(sizeof(GpRectF) * count);
3747     if(!rectsF)
3748         return OutOfMemory;
3749
3750     for(i = 0;i < count;i++){
3751         rectsF[i].X      = (REAL)rects[i].X;
3752         rectsF[i].Y      = (REAL)rects[i].Y;
3753         rectsF[i].Width  = (REAL)rects[i].Width;
3754         rectsF[i].Height = (REAL)rects[i].Height;
3755     }
3756
3757     ret = GdipDrawRectangles(graphics, pen, rectsF, count);
3758     GdipFree(rectsF);
3759
3760     return ret;
3761 }
3762
3763 GpStatus WINGDIPAPI GdipFillClosedCurve2(GpGraphics *graphics, GpBrush *brush,
3764     GDIPCONST GpPointF *points, INT count, REAL tension, GpFillMode fill)
3765 {
3766     GpPath *path;
3767     GpStatus stat;
3768
3769     TRACE("(%p, %p, %p, %d, %.2f, %d)\n", graphics, brush, points,
3770             count, tension, fill);
3771
3772     if(!graphics || !brush || !points)
3773         return InvalidParameter;
3774
3775     if(graphics->busy)
3776         return ObjectBusy;
3777
3778     if(count == 1)    /* Do nothing */
3779         return Ok;
3780
3781     stat = GdipCreatePath(fill, &path);
3782     if(stat != Ok)
3783         return stat;
3784
3785     stat = GdipAddPathClosedCurve2(path, points, count, tension);
3786     if(stat != Ok){
3787         GdipDeletePath(path);
3788         return stat;
3789     }
3790
3791     stat = GdipFillPath(graphics, brush, path);
3792     if(stat != Ok){
3793         GdipDeletePath(path);
3794         return stat;
3795     }
3796
3797     GdipDeletePath(path);
3798
3799     return Ok;
3800 }
3801
3802 GpStatus WINGDIPAPI GdipFillClosedCurve2I(GpGraphics *graphics, GpBrush *brush,
3803     GDIPCONST GpPoint *points, INT count, REAL tension, GpFillMode fill)
3804 {
3805     GpPointF *ptf;
3806     GpStatus stat;
3807     INT i;
3808
3809     TRACE("(%p, %p, %p, %d, %.2f, %d)\n", graphics, brush, points,
3810             count, tension, fill);
3811
3812     if(!points || count == 0)
3813         return InvalidParameter;
3814
3815     if(count == 1)    /* Do nothing */
3816         return Ok;
3817
3818     ptf = GdipAlloc(sizeof(GpPointF)*count);
3819     if(!ptf)
3820         return OutOfMemory;
3821
3822     for(i = 0;i < count;i++){
3823         ptf[i].X = (REAL)points[i].X;
3824         ptf[i].Y = (REAL)points[i].Y;
3825     }
3826
3827     stat = GdipFillClosedCurve2(graphics, brush, ptf, count, tension, fill);
3828
3829     GdipFree(ptf);
3830
3831     return stat;
3832 }
3833
3834 GpStatus WINGDIPAPI GdipFillClosedCurve(GpGraphics *graphics, GpBrush *brush,
3835     GDIPCONST GpPointF *points, INT count)
3836 {
3837     TRACE("(%p, %p, %p, %d)\n", graphics, brush, points, count);
3838     return GdipFillClosedCurve2(graphics, brush, points, count,
3839                0.5f, FillModeAlternate);
3840 }
3841
3842 GpStatus WINGDIPAPI GdipFillClosedCurveI(GpGraphics *graphics, GpBrush *brush,
3843     GDIPCONST GpPoint *points, INT count)
3844 {
3845     TRACE("(%p, %p, %p, %d)\n", graphics, brush, points, count);
3846     return GdipFillClosedCurve2I(graphics, brush, points, count,
3847                0.5f, FillModeAlternate);
3848 }
3849
3850 GpStatus WINGDIPAPI GdipFillEllipse(GpGraphics *graphics, GpBrush *brush, REAL x,
3851     REAL y, REAL width, REAL height)
3852 {
3853     GpStatus stat;
3854     GpPath *path;
3855
3856     TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f)\n", graphics, brush, x, y, width, height);
3857
3858     if(!graphics || !brush)
3859         return InvalidParameter;
3860
3861     if(graphics->busy)
3862         return ObjectBusy;
3863
3864     stat = GdipCreatePath(FillModeAlternate, &path);
3865
3866     if (stat == Ok)
3867     {
3868         stat = GdipAddPathEllipse(path, x, y, width, height);
3869
3870         if (stat == Ok)
3871             stat = GdipFillPath(graphics, brush, path);
3872
3873         GdipDeletePath(path);
3874     }
3875
3876     return stat;
3877 }
3878
3879 GpStatus WINGDIPAPI GdipFillEllipseI(GpGraphics *graphics, GpBrush *brush, INT x,
3880     INT y, INT width, INT height)
3881 {
3882     TRACE("(%p, %p, %d, %d, %d, %d)\n", graphics, brush, x, y, width, height);
3883
3884     return GdipFillEllipse(graphics,brush,(REAL)x,(REAL)y,(REAL)width,(REAL)height);
3885 }
3886
3887 static GpStatus GDI32_GdipFillPath(GpGraphics *graphics, GpBrush *brush, GpPath *path)
3888 {
3889     INT save_state;
3890     GpStatus retval;
3891
3892     if(!graphics->hdc || !brush_can_fill_path(brush))
3893         return NotImplemented;
3894
3895     save_state = SaveDC(graphics->hdc);
3896     EndPath(graphics->hdc);
3897     SetPolyFillMode(graphics->hdc, (path->fill == FillModeAlternate ? ALTERNATE
3898                                                                     : WINDING));
3899
3900     BeginPath(graphics->hdc);
3901     retval = draw_poly(graphics, NULL, path->pathdata.Points,
3902                        path->pathdata.Types, path->pathdata.Count, FALSE);
3903
3904     if(retval != Ok)
3905         goto end;
3906
3907     EndPath(graphics->hdc);
3908     brush_fill_path(graphics, brush);
3909
3910     retval = Ok;
3911
3912 end:
3913     RestoreDC(graphics->hdc, save_state);
3914
3915     return retval;
3916 }
3917
3918 static GpStatus SOFTWARE_GdipFillPath(GpGraphics *graphics, GpBrush *brush, GpPath *path)
3919 {
3920     GpStatus stat;
3921     GpRegion *rgn;
3922
3923     if (!brush_can_fill_pixels(brush))
3924         return NotImplemented;
3925
3926     /* FIXME: This could probably be done more efficiently without regions. */
3927
3928     stat = GdipCreateRegionPath(path, &rgn);
3929
3930     if (stat == Ok)
3931     {
3932         stat = GdipFillRegion(graphics, brush, rgn);
3933
3934         GdipDeleteRegion(rgn);
3935     }
3936
3937     return stat;
3938 }
3939
3940 GpStatus WINGDIPAPI GdipFillPath(GpGraphics *graphics, GpBrush *brush, GpPath *path)
3941 {
3942     GpStatus stat = NotImplemented;
3943
3944     TRACE("(%p, %p, %p)\n", graphics, brush, path);
3945
3946     if(!brush || !graphics || !path)
3947         return InvalidParameter;
3948
3949     if(graphics->busy)
3950         return ObjectBusy;
3951
3952     if (!graphics->image)
3953         stat = GDI32_GdipFillPath(graphics, brush, path);
3954
3955     if (stat == NotImplemented)
3956         stat = SOFTWARE_GdipFillPath(graphics, brush, path);
3957
3958     if (stat == NotImplemented)
3959     {
3960         FIXME("Not implemented for brushtype %i\n", brush->bt);
3961         stat = Ok;
3962     }
3963
3964     return stat;
3965 }
3966
3967 GpStatus WINGDIPAPI GdipFillPie(GpGraphics *graphics, GpBrush *brush, REAL x,
3968     REAL y, REAL width, REAL height, REAL startAngle, REAL sweepAngle)
3969 {
3970     GpStatus stat;
3971     GpPath *path;
3972
3973     TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f)\n",
3974             graphics, brush, x, y, width, height, startAngle, sweepAngle);
3975
3976     if(!graphics || !brush)
3977         return InvalidParameter;
3978
3979     if(graphics->busy)
3980         return ObjectBusy;
3981
3982     stat = GdipCreatePath(FillModeAlternate, &path);
3983
3984     if (stat == Ok)
3985     {
3986         stat = GdipAddPathPie(path, x, y, width, height, startAngle, sweepAngle);
3987
3988         if (stat == Ok)
3989             stat = GdipFillPath(graphics, brush, path);
3990
3991         GdipDeletePath(path);
3992     }
3993
3994     return stat;
3995 }
3996
3997 GpStatus WINGDIPAPI GdipFillPieI(GpGraphics *graphics, GpBrush *brush, INT x,
3998     INT y, INT width, INT height, REAL startAngle, REAL sweepAngle)
3999 {
4000     TRACE("(%p, %p, %d, %d, %d, %d, %.2f, %.2f)\n",
4001             graphics, brush, x, y, width, height, startAngle, sweepAngle);
4002
4003     return GdipFillPie(graphics,brush,(REAL)x,(REAL)y,(REAL)width,(REAL)height,startAngle,sweepAngle);
4004 }
4005
4006 GpStatus WINGDIPAPI GdipFillPolygon(GpGraphics *graphics, GpBrush *brush,
4007     GDIPCONST GpPointF *points, INT count, GpFillMode fillMode)
4008 {
4009     GpStatus stat;
4010     GpPath *path;
4011
4012     TRACE("(%p, %p, %p, %d, %d)\n", graphics, brush, points, count, fillMode);
4013
4014     if(!graphics || !brush || !points || !count)
4015         return InvalidParameter;
4016
4017     if(graphics->busy)
4018         return ObjectBusy;
4019
4020     stat = GdipCreatePath(fillMode, &path);
4021
4022     if (stat == Ok)
4023     {
4024         stat = GdipAddPathPolygon(path, points, count);
4025
4026         if (stat == Ok)
4027             stat = GdipFillPath(graphics, brush, path);
4028
4029         GdipDeletePath(path);
4030     }
4031
4032     return stat;
4033 }
4034
4035 GpStatus WINGDIPAPI GdipFillPolygonI(GpGraphics *graphics, GpBrush *brush,
4036     GDIPCONST GpPoint *points, INT count, GpFillMode fillMode)
4037 {
4038     GpStatus stat;
4039     GpPath *path;
4040
4041     TRACE("(%p, %p, %p, %d, %d)\n", graphics, brush, points, count, fillMode);
4042
4043     if(!graphics || !brush || !points || !count)
4044         return InvalidParameter;
4045
4046     if(graphics->busy)
4047         return ObjectBusy;
4048
4049     stat = GdipCreatePath(fillMode, &path);
4050
4051     if (stat == Ok)
4052     {
4053         stat = GdipAddPathPolygonI(path, points, count);
4054
4055         if (stat == Ok)
4056             stat = GdipFillPath(graphics, brush, path);
4057
4058         GdipDeletePath(path);
4059     }
4060
4061     return stat;
4062 }
4063
4064 GpStatus WINGDIPAPI GdipFillPolygon2(GpGraphics *graphics, GpBrush *brush,
4065     GDIPCONST GpPointF *points, INT count)
4066 {
4067     TRACE("(%p, %p, %p, %d)\n", graphics, brush, points, count);
4068
4069     return GdipFillPolygon(graphics, brush, points, count, FillModeAlternate);
4070 }
4071
4072 GpStatus WINGDIPAPI GdipFillPolygon2I(GpGraphics *graphics, GpBrush *brush,
4073     GDIPCONST GpPoint *points, INT count)
4074 {
4075     TRACE("(%p, %p, %p, %d)\n", graphics, brush, points, count);
4076
4077     return GdipFillPolygonI(graphics, brush, points, count, FillModeAlternate);
4078 }
4079
4080 GpStatus WINGDIPAPI GdipFillRectangle(GpGraphics *graphics, GpBrush *brush,
4081     REAL x, REAL y, REAL width, REAL height)
4082 {
4083     GpStatus stat;
4084     GpPath *path;
4085
4086     TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f)\n", graphics, brush, x, y, width, height);
4087
4088     if(!graphics || !brush)
4089         return InvalidParameter;
4090
4091     if(graphics->busy)
4092         return ObjectBusy;
4093
4094     stat = GdipCreatePath(FillModeAlternate, &path);
4095
4096     if (stat == Ok)
4097     {
4098         stat = GdipAddPathRectangle(path, x, y, width, height);
4099
4100         if (stat == Ok)
4101             stat = GdipFillPath(graphics, brush, path);
4102
4103         GdipDeletePath(path);
4104     }
4105
4106     return stat;
4107 }
4108
4109 GpStatus WINGDIPAPI GdipFillRectangleI(GpGraphics *graphics, GpBrush *brush,
4110     INT x, INT y, INT width, INT height)
4111 {
4112     TRACE("(%p, %p, %d, %d, %d, %d)\n", graphics, brush, x, y, width, height);
4113
4114     return GdipFillRectangle(graphics, brush, x, y, width, height);
4115 }
4116
4117 GpStatus WINGDIPAPI GdipFillRectangles(GpGraphics *graphics, GpBrush *brush, GDIPCONST GpRectF *rects,
4118     INT count)
4119 {
4120     GpStatus ret;
4121     INT i;
4122
4123     TRACE("(%p, %p, %p, %d)\n", graphics, brush, rects, count);
4124
4125     if(!rects)
4126         return InvalidParameter;
4127
4128     for(i = 0; i < count; i++){
4129         ret = GdipFillRectangle(graphics, brush, rects[i].X, rects[i].Y, rects[i].Width, rects[i].Height);
4130         if(ret != Ok)   return ret;
4131     }
4132
4133     return Ok;
4134 }
4135
4136 GpStatus WINGDIPAPI GdipFillRectanglesI(GpGraphics *graphics, GpBrush *brush, GDIPCONST GpRect *rects,
4137     INT count)
4138 {
4139     GpRectF *rectsF;
4140     GpStatus ret;
4141     INT i;
4142
4143     TRACE("(%p, %p, %p, %d)\n", graphics, brush, rects, count);
4144
4145     if(!rects || count <= 0)
4146         return InvalidParameter;
4147
4148     rectsF = GdipAlloc(sizeof(GpRectF)*count);
4149     if(!rectsF)
4150         return OutOfMemory;
4151
4152     for(i = 0; i < count; i++){
4153         rectsF[i].X      = (REAL)rects[i].X;
4154         rectsF[i].Y      = (REAL)rects[i].Y;
4155         rectsF[i].X      = (REAL)rects[i].Width;
4156         rectsF[i].Height = (REAL)rects[i].Height;
4157     }
4158
4159     ret = GdipFillRectangles(graphics,brush,rectsF,count);
4160     GdipFree(rectsF);
4161
4162     return ret;
4163 }
4164
4165 static GpStatus GDI32_GdipFillRegion(GpGraphics* graphics, GpBrush* brush,
4166     GpRegion* region)
4167 {
4168     INT save_state;
4169     GpStatus status;
4170     HRGN hrgn;
4171     RECT rc;
4172
4173     if(!graphics->hdc || !brush_can_fill_path(brush))
4174         return NotImplemented;
4175
4176     status = GdipGetRegionHRgn(region, graphics, &hrgn);
4177     if(status != Ok)
4178         return status;
4179
4180     save_state = SaveDC(graphics->hdc);
4181     EndPath(graphics->hdc);
4182
4183     ExtSelectClipRgn(graphics->hdc, hrgn, RGN_AND);
4184
4185     if (GetClipBox(graphics->hdc, &rc) != NULLREGION)
4186     {
4187         BeginPath(graphics->hdc);
4188         Rectangle(graphics->hdc, rc.left, rc.top, rc.right, rc.bottom);
4189         EndPath(graphics->hdc);
4190
4191         brush_fill_path(graphics, brush);
4192     }
4193
4194     RestoreDC(graphics->hdc, save_state);
4195
4196     DeleteObject(hrgn);
4197
4198     return Ok;
4199 }
4200
4201 static GpStatus SOFTWARE_GdipFillRegion(GpGraphics *graphics, GpBrush *brush,
4202     GpRegion* region)
4203 {
4204     GpStatus stat;
4205     GpRegion *temp_region;
4206     GpMatrix *world_to_device;
4207     GpRectF graphics_bounds;
4208     DWORD *pixel_data;
4209     HRGN hregion;
4210     RECT bound_rect;
4211     GpRect gp_bound_rect;
4212
4213     if (!brush_can_fill_pixels(brush))
4214         return NotImplemented;
4215
4216     stat = get_graphics_bounds(graphics, &graphics_bounds);
4217
4218     if (stat == Ok)
4219         stat = GdipCloneRegion(region, &temp_region);
4220
4221     if (stat == Ok)
4222     {
4223         stat = get_graphics_transform(graphics, CoordinateSpaceDevice,
4224             CoordinateSpaceWorld, &world_to_device);
4225
4226         if (stat == Ok)
4227         {
4228             stat = GdipTransformRegion(temp_region, world_to_device);
4229
4230             GdipDeleteMatrix(world_to_device);
4231         }
4232
4233         if (stat == Ok)
4234             stat = GdipCombineRegionRect(temp_region, &graphics_bounds, CombineModeIntersect);
4235
4236         if (stat == Ok)
4237             stat = GdipGetRegionHRgn(temp_region, NULL, &hregion);
4238
4239         GdipDeleteRegion(temp_region);
4240     }
4241
4242     if (stat == Ok && GetRgnBox(hregion, &bound_rect) == NULLREGION)
4243     {
4244         DeleteObject(hregion);
4245         return Ok;
4246     }
4247
4248     if (stat == Ok)
4249     {
4250         gp_bound_rect.X = bound_rect.left;
4251         gp_bound_rect.Y = bound_rect.top;
4252         gp_bound_rect.Width = bound_rect.right - bound_rect.left;
4253         gp_bound_rect.Height = bound_rect.bottom - bound_rect.top;
4254
4255         pixel_data = GdipAlloc(sizeof(*pixel_data) * gp_bound_rect.Width * gp_bound_rect.Height);
4256         if (!pixel_data)
4257             stat = OutOfMemory;
4258
4259         if (stat == Ok)
4260         {
4261             stat = brush_fill_pixels(graphics, brush, pixel_data,
4262                 &gp_bound_rect, gp_bound_rect.Width);
4263
4264             if (stat == Ok)
4265                 stat = alpha_blend_pixels_hrgn(graphics, gp_bound_rect.X,
4266                     gp_bound_rect.Y, (BYTE*)pixel_data, gp_bound_rect.Width,
4267                     gp_bound_rect.Height, gp_bound_rect.Width * 4, hregion);
4268
4269             GdipFree(pixel_data);
4270         }
4271
4272         DeleteObject(hregion);
4273     }
4274
4275     return stat;
4276 }
4277
4278 /*****************************************************************************
4279  * GdipFillRegion [GDIPLUS.@]
4280  */
4281 GpStatus WINGDIPAPI GdipFillRegion(GpGraphics* graphics, GpBrush* brush,
4282         GpRegion* region)
4283 {
4284     GpStatus stat = NotImplemented;
4285
4286     TRACE("(%p, %p, %p)\n", graphics, brush, region);
4287
4288     if (!(graphics && brush && region))
4289         return InvalidParameter;
4290
4291     if(graphics->busy)
4292         return ObjectBusy;
4293
4294     if (!graphics->image)
4295         stat = GDI32_GdipFillRegion(graphics, brush, region);
4296
4297     if (stat == NotImplemented)
4298         stat = SOFTWARE_GdipFillRegion(graphics, brush, region);
4299
4300     if (stat == NotImplemented)
4301     {
4302         FIXME("not implemented for brushtype %i\n", brush->bt);
4303         stat = Ok;
4304     }
4305
4306     return stat;
4307 }
4308
4309 GpStatus WINGDIPAPI GdipFlush(GpGraphics *graphics, GpFlushIntention intention)
4310 {
4311     TRACE("(%p,%u)\n", graphics, intention);
4312
4313     if(!graphics)
4314         return InvalidParameter;
4315
4316     if(graphics->busy)
4317         return ObjectBusy;
4318
4319     /* We have no internal operation queue, so there's no need to clear it. */
4320
4321     if (graphics->hdc)
4322         GdiFlush();
4323
4324     return Ok;
4325 }
4326
4327 /*****************************************************************************
4328  * GdipGetClipBounds [GDIPLUS.@]
4329  */
4330 GpStatus WINGDIPAPI GdipGetClipBounds(GpGraphics *graphics, GpRectF *rect)
4331 {
4332     TRACE("(%p, %p)\n", graphics, rect);
4333
4334     if(!graphics)
4335         return InvalidParameter;
4336
4337     if(graphics->busy)
4338         return ObjectBusy;
4339
4340     return GdipGetRegionBounds(graphics->clip, graphics, rect);
4341 }
4342
4343 /*****************************************************************************
4344  * GdipGetClipBoundsI [GDIPLUS.@]
4345  */
4346 GpStatus WINGDIPAPI GdipGetClipBoundsI(GpGraphics *graphics, GpRect *rect)
4347 {
4348     TRACE("(%p, %p)\n", graphics, rect);
4349
4350     if(!graphics)
4351         return InvalidParameter;
4352
4353     if(graphics->busy)
4354         return ObjectBusy;
4355
4356     return GdipGetRegionBoundsI(graphics->clip, graphics, rect);
4357 }
4358
4359 /* FIXME: Compositing mode is not used anywhere except the getter/setter. */
4360 GpStatus WINGDIPAPI GdipGetCompositingMode(GpGraphics *graphics,
4361     CompositingMode *mode)
4362 {
4363     TRACE("(%p, %p)\n", graphics, mode);
4364
4365     if(!graphics || !mode)
4366         return InvalidParameter;
4367
4368     if(graphics->busy)
4369         return ObjectBusy;
4370
4371     *mode = graphics->compmode;
4372
4373     return Ok;
4374 }
4375
4376 /* FIXME: Compositing quality is not used anywhere except the getter/setter. */
4377 GpStatus WINGDIPAPI GdipGetCompositingQuality(GpGraphics *graphics,
4378     CompositingQuality *quality)
4379 {
4380     TRACE("(%p, %p)\n", graphics, quality);
4381
4382     if(!graphics || !quality)
4383         return InvalidParameter;
4384
4385     if(graphics->busy)
4386         return ObjectBusy;
4387
4388     *quality = graphics->compqual;
4389
4390     return Ok;
4391 }
4392
4393 /* FIXME: Interpolation mode is not used anywhere except the getter/setter. */
4394 GpStatus WINGDIPAPI GdipGetInterpolationMode(GpGraphics *graphics,
4395     InterpolationMode *mode)
4396 {
4397     TRACE("(%p, %p)\n", graphics, mode);
4398
4399     if(!graphics || !mode)
4400         return InvalidParameter;
4401
4402     if(graphics->busy)
4403         return ObjectBusy;
4404
4405     *mode = graphics->interpolation;
4406
4407     return Ok;
4408 }
4409
4410 /* FIXME: Need to handle color depths less than 24bpp */
4411 GpStatus WINGDIPAPI GdipGetNearestColor(GpGraphics *graphics, ARGB* argb)
4412 {
4413     FIXME("(%p, %p): Passing color unmodified\n", graphics, argb);
4414
4415     if(!graphics || !argb)
4416         return InvalidParameter;
4417
4418     if(graphics->busy)
4419         return ObjectBusy;
4420
4421     return Ok;
4422 }
4423
4424 GpStatus WINGDIPAPI GdipGetPageScale(GpGraphics *graphics, REAL *scale)
4425 {
4426     TRACE("(%p, %p)\n", graphics, scale);
4427
4428     if(!graphics || !scale)
4429         return InvalidParameter;
4430
4431     if(graphics->busy)
4432         return ObjectBusy;
4433
4434     *scale = graphics->scale;
4435
4436     return Ok;
4437 }
4438
4439 GpStatus WINGDIPAPI GdipGetPageUnit(GpGraphics *graphics, GpUnit *unit)
4440 {
4441     TRACE("(%p, %p)\n", graphics, unit);
4442
4443     if(!graphics || !unit)
4444         return InvalidParameter;
4445
4446     if(graphics->busy)
4447         return ObjectBusy;
4448
4449     *unit = graphics->unit;
4450
4451     return Ok;
4452 }
4453
4454 /* FIXME: Pixel offset mode is not used anywhere except the getter/setter. */
4455 GpStatus WINGDIPAPI GdipGetPixelOffsetMode(GpGraphics *graphics, PixelOffsetMode
4456     *mode)
4457 {
4458     TRACE("(%p, %p)\n", graphics, mode);
4459
4460     if(!graphics || !mode)
4461         return InvalidParameter;
4462
4463     if(graphics->busy)
4464         return ObjectBusy;
4465
4466     *mode = graphics->pixeloffset;
4467
4468     return Ok;
4469 }
4470
4471 /* FIXME: Smoothing mode is not used anywhere except the getter/setter. */
4472 GpStatus WINGDIPAPI GdipGetSmoothingMode(GpGraphics *graphics, SmoothingMode *mode)
4473 {
4474     TRACE("(%p, %p)\n", graphics, mode);
4475
4476     if(!graphics || !mode)
4477         return InvalidParameter;
4478
4479     if(graphics->busy)
4480         return ObjectBusy;
4481
4482     *mode = graphics->smoothing;
4483
4484     return Ok;
4485 }
4486
4487 GpStatus WINGDIPAPI GdipGetTextContrast(GpGraphics *graphics, UINT *contrast)
4488 {
4489     TRACE("(%p, %p)\n", graphics, contrast);
4490
4491     if(!graphics || !contrast)
4492         return InvalidParameter;
4493
4494     *contrast = graphics->textcontrast;
4495
4496     return Ok;
4497 }
4498
4499 /* FIXME: Text rendering hint is not used anywhere except the getter/setter. */
4500 GpStatus WINGDIPAPI GdipGetTextRenderingHint(GpGraphics *graphics,
4501     TextRenderingHint *hint)
4502 {
4503     TRACE("(%p, %p)\n", graphics, hint);
4504
4505     if(!graphics || !hint)
4506         return InvalidParameter;
4507
4508     if(graphics->busy)
4509         return ObjectBusy;
4510
4511     *hint = graphics->texthint;
4512
4513     return Ok;
4514 }
4515
4516 GpStatus WINGDIPAPI GdipGetVisibleClipBounds(GpGraphics *graphics, GpRectF *rect)
4517 {
4518     GpRegion *clip_rgn;
4519     GpStatus stat;
4520
4521     TRACE("(%p, %p)\n", graphics, rect);
4522
4523     if(!graphics || !rect)
4524         return InvalidParameter;
4525
4526     if(graphics->busy)
4527         return ObjectBusy;
4528
4529     /* intersect window and graphics clipping regions */
4530     if((stat = GdipCreateRegion(&clip_rgn)) != Ok)
4531         return stat;
4532
4533     if((stat = get_visible_clip_region(graphics, clip_rgn)) != Ok)
4534         goto cleanup;
4535
4536     /* get bounds of the region */
4537     stat = GdipGetRegionBounds(clip_rgn, graphics, rect);
4538
4539 cleanup:
4540     GdipDeleteRegion(clip_rgn);
4541
4542     return stat;
4543 }
4544
4545 GpStatus WINGDIPAPI GdipGetVisibleClipBoundsI(GpGraphics *graphics, GpRect *rect)
4546 {
4547     GpRectF rectf;
4548     GpStatus stat;
4549
4550     TRACE("(%p, %p)\n", graphics, rect);
4551
4552     if(!graphics || !rect)
4553         return InvalidParameter;
4554
4555     if((stat = GdipGetVisibleClipBounds(graphics, &rectf)) == Ok)
4556     {
4557         rect->X = roundr(rectf.X);
4558         rect->Y = roundr(rectf.Y);
4559         rect->Width  = roundr(rectf.Width);
4560         rect->Height = roundr(rectf.Height);
4561     }
4562
4563     return stat;
4564 }
4565
4566 GpStatus WINGDIPAPI GdipGetWorldTransform(GpGraphics *graphics, GpMatrix *matrix)
4567 {
4568     TRACE("(%p, %p)\n", graphics, matrix);
4569
4570     if(!graphics || !matrix)
4571         return InvalidParameter;
4572
4573     if(graphics->busy)
4574         return ObjectBusy;
4575
4576     *matrix = *graphics->worldtrans;
4577     return Ok;
4578 }
4579
4580 GpStatus WINGDIPAPI GdipGraphicsClear(GpGraphics *graphics, ARGB color)
4581 {
4582     GpSolidFill *brush;
4583     GpStatus stat;
4584     GpRectF wnd_rect;
4585
4586     TRACE("(%p, %x)\n", graphics, color);
4587
4588     if(!graphics)
4589         return InvalidParameter;
4590
4591     if(graphics->busy)
4592         return ObjectBusy;
4593
4594     if((stat = GdipCreateSolidFill(color, &brush)) != Ok)
4595         return stat;
4596
4597     if((stat = get_graphics_bounds(graphics, &wnd_rect)) != Ok){
4598         GdipDeleteBrush((GpBrush*)brush);
4599         return stat;
4600     }
4601
4602     GdipFillRectangle(graphics, (GpBrush*)brush, wnd_rect.X, wnd_rect.Y,
4603                                                  wnd_rect.Width, wnd_rect.Height);
4604
4605     GdipDeleteBrush((GpBrush*)brush);
4606
4607     return Ok;
4608 }
4609
4610 GpStatus WINGDIPAPI GdipIsClipEmpty(GpGraphics *graphics, BOOL *res)
4611 {
4612     TRACE("(%p, %p)\n", graphics, res);
4613
4614     if(!graphics || !res)
4615         return InvalidParameter;
4616
4617     return GdipIsEmptyRegion(graphics->clip, graphics, res);
4618 }
4619
4620 GpStatus WINGDIPAPI GdipIsVisiblePoint(GpGraphics *graphics, REAL x, REAL y, BOOL *result)
4621 {
4622     GpStatus stat;
4623     GpRegion* rgn;
4624     GpPointF pt;
4625
4626     TRACE("(%p, %.2f, %.2f, %p)\n", graphics, x, y, result);
4627
4628     if(!graphics || !result)
4629         return InvalidParameter;
4630
4631     if(graphics->busy)
4632         return ObjectBusy;
4633
4634     pt.X = x;
4635     pt.Y = y;
4636     if((stat = GdipTransformPoints(graphics, CoordinateSpaceDevice,
4637                    CoordinateSpaceWorld, &pt, 1)) != Ok)
4638         return stat;
4639
4640     if((stat = GdipCreateRegion(&rgn)) != Ok)
4641         return stat;
4642
4643     if((stat = get_visible_clip_region(graphics, rgn)) != Ok)
4644         goto cleanup;
4645
4646     stat = GdipIsVisibleRegionPoint(rgn, pt.X, pt.Y, graphics, result);
4647
4648 cleanup:
4649     GdipDeleteRegion(rgn);
4650     return stat;
4651 }
4652
4653 GpStatus WINGDIPAPI GdipIsVisiblePointI(GpGraphics *graphics, INT x, INT y, BOOL *result)
4654 {
4655     return GdipIsVisiblePoint(graphics, (REAL)x, (REAL)y, result);
4656 }
4657
4658 GpStatus WINGDIPAPI GdipIsVisibleRect(GpGraphics *graphics, REAL x, REAL y, REAL width, REAL height, BOOL *result)
4659 {
4660     GpStatus stat;
4661     GpRegion* rgn;
4662     GpPointF pts[2];
4663
4664     TRACE("(%p %.2f %.2f %.2f %.2f %p)\n", graphics, x, y, width, height, result);
4665
4666     if(!graphics || !result)
4667         return InvalidParameter;
4668
4669     if(graphics->busy)
4670         return ObjectBusy;
4671
4672     pts[0].X = x;
4673     pts[0].Y = y;
4674     pts[1].X = x + width;
4675     pts[1].Y = y + height;
4676
4677     if((stat = GdipTransformPoints(graphics, CoordinateSpaceDevice,
4678                     CoordinateSpaceWorld, pts, 2)) != Ok)
4679         return stat;
4680
4681     pts[1].X -= pts[0].X;
4682     pts[1].Y -= pts[0].Y;
4683
4684     if((stat = GdipCreateRegion(&rgn)) != Ok)
4685         return stat;
4686
4687     if((stat = get_visible_clip_region(graphics, rgn)) != Ok)
4688         goto cleanup;
4689
4690     stat = GdipIsVisibleRegionRect(rgn, pts[0].X, pts[0].Y, pts[1].X, pts[1].Y, graphics, result);
4691
4692 cleanup:
4693     GdipDeleteRegion(rgn);
4694     return stat;
4695 }
4696
4697 GpStatus WINGDIPAPI GdipIsVisibleRectI(GpGraphics *graphics, INT x, INT y, INT width, INT height, BOOL *result)
4698 {
4699     return GdipIsVisibleRect(graphics, (REAL)x, (REAL)y, (REAL)width, (REAL)height, result);
4700 }
4701
4702 GpStatus gdip_format_string(HDC hdc,
4703     GDIPCONST WCHAR *string, INT length, GDIPCONST GpFont *font,
4704     GDIPCONST RectF *rect, GDIPCONST GpStringFormat *format,
4705     gdip_format_string_callback callback, void *user_data)
4706 {
4707     WCHAR* stringdup;
4708     int sum = 0, height = 0, fit, fitcpy, i, j, lret, nwidth,
4709         nheight, lineend, lineno = 0;
4710     RectF bounds;
4711     StringAlignment halign;
4712     GpStatus stat = Ok;
4713     SIZE size;
4714     HotkeyPrefix hkprefix;
4715     INT *hotkeyprefix_offsets=NULL;
4716     INT hotkeyprefix_count=0;
4717     INT hotkeyprefix_pos=0, hotkeyprefix_end_pos=0;
4718     int seen_prefix=0;
4719
4720     if(length == -1) length = lstrlenW(string);
4721
4722     stringdup = GdipAlloc((length + 1) * sizeof(WCHAR));
4723     if(!stringdup) return OutOfMemory;
4724
4725     nwidth = roundr(rect->Width);
4726     nheight = roundr(rect->Height);
4727
4728     if (rect->Width >= INT_MAX || rect->Width < 0.5) nwidth = INT_MAX;
4729     if (rect->Height >= INT_MAX || rect->Height < 0.5) nheight = INT_MAX;
4730
4731     if (format)
4732         hkprefix = format->hkprefix;
4733     else
4734         hkprefix = HotkeyPrefixNone;
4735
4736     if (hkprefix == HotkeyPrefixShow)
4737     {
4738         for (i=0; i<length; i++)
4739         {
4740             if (string[i] == '&')
4741                 hotkeyprefix_count++;
4742         }
4743     }
4744
4745     if (hotkeyprefix_count)
4746         hotkeyprefix_offsets = GdipAlloc(sizeof(INT) * hotkeyprefix_count);
4747
4748     hotkeyprefix_count = 0;
4749
4750     for(i = 0, j = 0; i < length; i++){
4751         /* FIXME: This makes the indexes passed to callback inaccurate. */
4752         if(!isprintW(string[i]) && (string[i] != '\n'))
4753             continue;
4754
4755         if (seen_prefix && hkprefix == HotkeyPrefixShow && string[i] != '&')
4756             hotkeyprefix_offsets[hotkeyprefix_count++] = j;
4757         else if (!seen_prefix && hkprefix != HotkeyPrefixNone && string[i] == '&')
4758         {
4759             seen_prefix = 1;
4760             continue;
4761         }
4762
4763         seen_prefix = 0;
4764
4765         stringdup[j] = string[i];
4766         j++;
4767     }
4768
4769     length = j;
4770
4771     if (format) halign = format->align;
4772     else halign = StringAlignmentNear;
4773
4774     while(sum < length){
4775         GetTextExtentExPointW(hdc, stringdup + sum, length - sum,
4776                               nwidth, &fit, NULL, &size);
4777         fitcpy = fit;
4778
4779         if(fit == 0)
4780             break;
4781
4782         for(lret = 0; lret < fit; lret++)
4783             if(*(stringdup + sum + lret) == '\n')
4784                 break;
4785
4786         /* Line break code (may look strange, but it imitates windows). */
4787         if(lret < fit)
4788             lineend = fit = lret;    /* this is not an off-by-one error */
4789         else if(fit < (length - sum)){
4790             if(*(stringdup + sum + fit) == ' ')
4791                 while(*(stringdup + sum + fit) == ' ')
4792                     fit++;
4793             else
4794                 while(*(stringdup + sum + fit - 1) != ' '){
4795                     fit--;
4796
4797                     if(*(stringdup + sum + fit) == '\t')
4798                         break;
4799
4800                     if(fit == 0){
4801                         fit = fitcpy;
4802                         break;
4803                     }
4804                 }
4805             lineend = fit;
4806             while(*(stringdup + sum + lineend - 1) == ' ' ||
4807                   *(stringdup + sum + lineend - 1) == '\t')
4808                 lineend--;
4809         }
4810         else
4811             lineend = fit;
4812
4813         GetTextExtentExPointW(hdc, stringdup + sum, lineend,
4814                               nwidth, &j, NULL, &size);
4815
4816         bounds.Width = size.cx;
4817
4818         if(height + size.cy > nheight)
4819             bounds.Height = nheight - (height + size.cy);
4820         else
4821             bounds.Height = size.cy;
4822
4823         bounds.Y = rect->Y + height;
4824
4825         switch (halign)
4826         {
4827         case StringAlignmentNear:
4828         default:
4829             bounds.X = rect->X;
4830             break;
4831         case StringAlignmentCenter:
4832             bounds.X = rect->X + (rect->Width/2) - (bounds.Width/2);
4833             break;
4834         case StringAlignmentFar:
4835             bounds.X = rect->X + rect->Width - bounds.Width;
4836             break;
4837         }
4838
4839         for (hotkeyprefix_end_pos=hotkeyprefix_pos; hotkeyprefix_end_pos<hotkeyprefix_count; hotkeyprefix_end_pos++)
4840             if (hotkeyprefix_offsets[hotkeyprefix_end_pos] >= sum + lineend)
4841                 break;
4842
4843         stat = callback(hdc, stringdup, sum, lineend,
4844             font, rect, format, lineno, &bounds,
4845             &hotkeyprefix_offsets[hotkeyprefix_pos],
4846             hotkeyprefix_end_pos-hotkeyprefix_pos, user_data);
4847
4848         if (stat != Ok)
4849             break;
4850
4851         sum += fit + (lret < fitcpy ? 1 : 0);
4852         height += size.cy;
4853         lineno++;
4854
4855         hotkeyprefix_pos = hotkeyprefix_end_pos;
4856
4857         if(height > nheight)
4858             break;
4859
4860         /* Stop if this was a linewrap (but not if it was a linebreak). */
4861         if((lret == fitcpy) && format && (format->attr & StringFormatFlagsNoWrap))
4862             break;
4863     }
4864
4865     GdipFree(stringdup);
4866     GdipFree(hotkeyprefix_offsets);
4867
4868     return stat;
4869 }
4870
4871 struct measure_ranges_args {
4872     GpRegion **regions;
4873 };
4874
4875 static GpStatus measure_ranges_callback(HDC hdc,
4876     GDIPCONST WCHAR *string, INT index, INT length, GDIPCONST GpFont *font,
4877     GDIPCONST RectF *rect, GDIPCONST GpStringFormat *format,
4878     INT lineno, const RectF *bounds, INT *underlined_indexes,
4879     INT underlined_index_count, void *user_data)
4880 {
4881     int i;
4882     GpStatus stat = Ok;
4883     struct measure_ranges_args *args = user_data;
4884
4885     for (i=0; i<format->range_count; i++)
4886     {
4887         INT range_start = max(index, format->character_ranges[i].First);
4888         INT range_end = min(index+length, format->character_ranges[i].First+format->character_ranges[i].Length);
4889         if (range_start < range_end)
4890         {
4891             GpRectF range_rect;
4892             SIZE range_size;
4893
4894             range_rect.Y = bounds->Y;
4895             range_rect.Height = bounds->Height;
4896
4897             GetTextExtentExPointW(hdc, string + index, range_start - index,
4898                                   INT_MAX, NULL, NULL, &range_size);
4899             range_rect.X = bounds->X + range_size.cx;
4900
4901             GetTextExtentExPointW(hdc, string + index, range_end - index,
4902                                   INT_MAX, NULL, NULL, &range_size);
4903             range_rect.Width = (bounds->X + range_size.cx) - range_rect.X;
4904
4905             stat = GdipCombineRegionRect(args->regions[i], &range_rect, CombineModeUnion);
4906             if (stat != Ok)
4907                 break;
4908         }
4909     }
4910
4911     return stat;
4912 }
4913
4914 GpStatus WINGDIPAPI GdipMeasureCharacterRanges(GpGraphics* graphics,
4915         GDIPCONST WCHAR* string, INT length, GDIPCONST GpFont* font,
4916         GDIPCONST RectF* layoutRect, GDIPCONST GpStringFormat *stringFormat,
4917         INT regionCount, GpRegion** regions)
4918 {
4919     GpStatus stat;
4920     int i;
4921     LOGFONTW lfw;
4922     HFONT oldfont;
4923     struct measure_ranges_args args;
4924     HDC hdc, temp_hdc=NULL;
4925
4926     TRACE("(%p %s %d %p %s %p %d %p)\n", graphics, debugstr_w(string),
4927             length, font, debugstr_rectf(layoutRect), stringFormat, regionCount, regions);
4928
4929     if (!(graphics && string && font && layoutRect && stringFormat && regions))
4930         return InvalidParameter;
4931
4932     if (regionCount < stringFormat->range_count)
4933         return InvalidParameter;
4934
4935     get_log_fontW(font, graphics, &lfw);
4936
4937     if(!graphics->hdc)
4938     {
4939         hdc = temp_hdc = CreateCompatibleDC(0);
4940         if (!temp_hdc) return OutOfMemory;
4941     }
4942     else
4943         hdc = graphics->hdc;
4944
4945     if (stringFormat->attr)
4946         TRACE("may be ignoring some format flags: attr %x\n", stringFormat->attr);
4947
4948     oldfont = SelectObject(hdc, CreateFontIndirectW(&lfw));
4949
4950     for (i=0; i<stringFormat->range_count; i++)
4951     {
4952         stat = GdipSetEmpty(regions[i]);
4953         if (stat != Ok)
4954             return stat;
4955     }
4956
4957     args.regions = regions;
4958
4959     stat = gdip_format_string(hdc, string, length, font, layoutRect, stringFormat,
4960         measure_ranges_callback, &args);
4961
4962     DeleteObject(SelectObject(hdc, oldfont));
4963
4964     if (temp_hdc)
4965         DeleteDC(temp_hdc);
4966
4967     return stat;
4968 }
4969
4970 struct measure_string_args {
4971     RectF *bounds;
4972     INT *codepointsfitted;
4973     INT *linesfilled;
4974     REAL rel_width, rel_height;
4975 };
4976
4977 static GpStatus measure_string_callback(HDC hdc,
4978     GDIPCONST WCHAR *string, INT index, INT length, GDIPCONST GpFont *font,
4979     GDIPCONST RectF *rect, GDIPCONST GpStringFormat *format,
4980     INT lineno, const RectF *bounds, INT *underlined_indexes,
4981     INT underlined_index_count, void *user_data)
4982 {
4983     struct measure_string_args *args = user_data;
4984     REAL new_width, new_height;
4985
4986     new_width = bounds->Width / args->rel_width;
4987     new_height = (bounds->Height + bounds->Y) / args->rel_height - args->bounds->Y;
4988
4989     if (new_width > args->bounds->Width)
4990         args->bounds->Width = new_width;
4991
4992     if (new_height > args->bounds->Height)
4993         args->bounds->Height = new_height;
4994
4995     if (args->codepointsfitted)
4996         *args->codepointsfitted = index + length;
4997
4998     if (args->linesfilled)
4999         (*args->linesfilled)++;
5000
5001     return Ok;
5002 }
5003
5004 /* Find the smallest rectangle that bounds the text when it is printed in rect
5005  * according to the format options listed in format. If rect has 0 width and
5006  * height, then just find the smallest rectangle that bounds the text when it's
5007  * printed at location (rect->X, rect-Y). */
5008 GpStatus WINGDIPAPI GdipMeasureString(GpGraphics *graphics,
5009     GDIPCONST WCHAR *string, INT length, GDIPCONST GpFont *font,
5010     GDIPCONST RectF *rect, GDIPCONST GpStringFormat *format, RectF *bounds,
5011     INT *codepointsfitted, INT *linesfilled)
5012 {
5013     HFONT oldfont, gdifont;
5014     struct measure_string_args args;
5015     HDC temp_hdc=NULL, hdc;
5016     GpPointF pt[3];
5017     RectF scaled_rect;
5018
5019     TRACE("(%p, %s, %i, %p, %s, %p, %p, %p, %p)\n", graphics,
5020         debugstr_wn(string, length), length, font, debugstr_rectf(rect), format,
5021         bounds, codepointsfitted, linesfilled);
5022
5023     if(!graphics || !string || !font || !rect || !bounds)
5024         return InvalidParameter;
5025
5026     if(!graphics->hdc)
5027     {
5028         hdc = temp_hdc = CreateCompatibleDC(0);
5029         if (!temp_hdc) return OutOfMemory;
5030     }
5031     else
5032         hdc = graphics->hdc;
5033
5034     if(linesfilled) *linesfilled = 0;
5035     if(codepointsfitted) *codepointsfitted = 0;
5036
5037     if(format)
5038         TRACE("may be ignoring some format flags: attr %x\n", format->attr);
5039
5040     pt[0].X = 0.0;
5041     pt[0].Y = 0.0;
5042     pt[1].X = 1.0;
5043     pt[1].Y = 0.0;
5044     pt[2].X = 0.0;
5045     pt[2].Y = 1.0;
5046     GdipTransformPoints(graphics, CoordinateSpaceDevice, CoordinateSpaceWorld, pt, 3);
5047     args.rel_width = sqrt((pt[1].Y-pt[0].Y)*(pt[1].Y-pt[0].Y)+
5048                      (pt[1].X-pt[0].X)*(pt[1].X-pt[0].X));
5049     args.rel_height = sqrt((pt[2].Y-pt[0].Y)*(pt[2].Y-pt[0].Y)+
5050                       (pt[2].X-pt[0].X)*(pt[2].X-pt[0].X));
5051
5052     get_font_hfont(graphics, font, &gdifont);
5053     oldfont = SelectObject(hdc, gdifont);
5054
5055     scaled_rect.X = rect->X * args.rel_width;
5056     scaled_rect.Y = rect->Y * args.rel_height;
5057     scaled_rect.Width = rect->Width * args.rel_width;
5058     scaled_rect.Height = rect->Height * args.rel_height;
5059
5060     bounds->X = rect->X;
5061     bounds->Y = rect->Y;
5062     bounds->Width = 0.0;
5063     bounds->Height = 0.0;
5064
5065     args.bounds = bounds;
5066     args.codepointsfitted = codepointsfitted;
5067     args.linesfilled = linesfilled;
5068
5069     gdip_format_string(hdc, string, length, font, &scaled_rect, format,
5070         measure_string_callback, &args);
5071
5072     SelectObject(hdc, oldfont);
5073     DeleteObject(gdifont);
5074
5075     if (temp_hdc)
5076         DeleteDC(temp_hdc);
5077
5078     return Ok;
5079 }
5080
5081 struct draw_string_args {
5082     GpGraphics *graphics;
5083     GDIPCONST GpBrush *brush;
5084     REAL x, y, rel_width, rel_height, ascent;
5085 };
5086
5087 static GpStatus draw_string_callback(HDC hdc,
5088     GDIPCONST WCHAR *string, INT index, INT length, GDIPCONST GpFont *font,
5089     GDIPCONST RectF *rect, GDIPCONST GpStringFormat *format,
5090     INT lineno, const RectF *bounds, INT *underlined_indexes,
5091     INT underlined_index_count, void *user_data)
5092 {
5093     struct draw_string_args *args = user_data;
5094     PointF position;
5095     GpStatus stat;
5096
5097     position.X = args->x + bounds->X / args->rel_width;
5098     position.Y = args->y + bounds->Y / args->rel_height + args->ascent;
5099
5100     stat = GdipDrawDriverString(args->graphics, &string[index], length, font,
5101         args->brush, &position,
5102         DriverStringOptionsCmapLookup|DriverStringOptionsRealizedAdvance, NULL);
5103
5104     if (stat == Ok && underlined_index_count)
5105     {
5106         OUTLINETEXTMETRICW otm;
5107         REAL underline_y, underline_height;
5108         int i;
5109
5110         GetOutlineTextMetricsW(hdc, sizeof(otm), &otm);
5111
5112         underline_height = otm.otmsUnderscoreSize / args->rel_height;
5113         underline_y = position.Y - otm.otmsUnderscorePosition / args->rel_height - underline_height / 2;
5114
5115         for (i=0; i<underlined_index_count; i++)
5116         {
5117             REAL start_x, end_x;
5118             SIZE text_size;
5119             INT ofs = underlined_indexes[i] - index;
5120
5121             GetTextExtentExPointW(hdc, string + index, ofs, INT_MAX, NULL, NULL, &text_size);
5122             start_x = text_size.cx / args->rel_width;
5123
5124             GetTextExtentExPointW(hdc, string + index, ofs+1, INT_MAX, NULL, NULL, &text_size);
5125             end_x = text_size.cx / args->rel_width;
5126
5127             GdipFillRectangle(args->graphics, (GpBrush*)args->brush, position.X+start_x, underline_y, end_x-start_x, underline_height);
5128         }
5129     }
5130
5131     return stat;
5132 }
5133
5134 GpStatus WINGDIPAPI GdipDrawString(GpGraphics *graphics, GDIPCONST WCHAR *string,
5135     INT length, GDIPCONST GpFont *font, GDIPCONST RectF *rect,
5136     GDIPCONST GpStringFormat *format, GDIPCONST GpBrush *brush)
5137 {
5138     HRGN rgn = NULL;
5139     HFONT gdifont;
5140     GpPointF pt[3], rectcpy[4];
5141     POINT corners[4];
5142     REAL rel_width, rel_height;
5143     INT save_state;
5144     REAL offsety = 0.0;
5145     struct draw_string_args args;
5146     RectF scaled_rect;
5147     HDC hdc, temp_hdc=NULL;
5148     TEXTMETRICW textmetric;
5149
5150     TRACE("(%p, %s, %i, %p, %s, %p, %p)\n", graphics, debugstr_wn(string, length),
5151         length, font, debugstr_rectf(rect), format, brush);
5152
5153     if(!graphics || !string || !font || !brush || !rect)
5154         return InvalidParameter;
5155
5156     if(graphics->hdc)
5157     {
5158         hdc = graphics->hdc;
5159     }
5160     else
5161     {
5162         hdc = temp_hdc = CreateCompatibleDC(0);
5163     }
5164
5165     if(format){
5166         TRACE("may be ignoring some format flags: attr %x\n", format->attr);
5167
5168         /* Should be no need to explicitly test for StringAlignmentNear as
5169          * that is default behavior if no alignment is passed. */
5170         if(format->vertalign != StringAlignmentNear){
5171             RectF bounds, in_rect = *rect;
5172             in_rect.Height = 0.0; /* avoid height clipping */
5173             GdipMeasureString(graphics, string, length, font, &in_rect, format, &bounds, 0, 0);
5174
5175             TRACE("bounds %s\n", debugstr_rectf(&bounds));
5176
5177             if(format->vertalign == StringAlignmentCenter)
5178                 offsety = (rect->Height - bounds.Height) / 2;
5179             else if(format->vertalign == StringAlignmentFar)
5180                 offsety = (rect->Height - bounds.Height);
5181         }
5182         TRACE("vertical align %d, offsety %f\n", format->vertalign, offsety);
5183     }
5184
5185     save_state = SaveDC(hdc);
5186
5187     pt[0].X = 0.0;
5188     pt[0].Y = 0.0;
5189     pt[1].X = 1.0;
5190     pt[1].Y = 0.0;
5191     pt[2].X = 0.0;
5192     pt[2].Y = 1.0;
5193     GdipTransformPoints(graphics, CoordinateSpaceDevice, CoordinateSpaceWorld, pt, 3);
5194     rel_width = sqrt((pt[1].Y-pt[0].Y)*(pt[1].Y-pt[0].Y)+
5195                      (pt[1].X-pt[0].X)*(pt[1].X-pt[0].X));
5196     rel_height = sqrt((pt[2].Y-pt[0].Y)*(pt[2].Y-pt[0].Y)+
5197                       (pt[2].X-pt[0].X)*(pt[2].X-pt[0].X));
5198
5199     rectcpy[3].X = rectcpy[0].X = rect->X;
5200     rectcpy[1].Y = rectcpy[0].Y = rect->Y;
5201     rectcpy[2].X = rectcpy[1].X = rect->X + rect->Width;
5202     rectcpy[3].Y = rectcpy[2].Y = rect->Y + rect->Height;
5203     transform_and_round_points(graphics, corners, rectcpy, 4);
5204
5205     scaled_rect.X = 0.0;
5206     scaled_rect.Y = 0.0;
5207     scaled_rect.Width = rel_width * rect->Width;
5208     scaled_rect.Height = rel_height * rect->Height;
5209
5210     if (roundr(scaled_rect.Width) != 0 && roundr(scaled_rect.Height) != 0)
5211     {
5212         /* FIXME: If only the width or only the height is 0, we should probably still clip */
5213         rgn = CreatePolygonRgn(corners, 4, ALTERNATE);
5214         SelectClipRgn(hdc, rgn);
5215     }
5216
5217     get_font_hfont(graphics, font, &gdifont);
5218     SelectObject(hdc, gdifont);
5219
5220     args.graphics = graphics;
5221     args.brush = brush;
5222
5223     args.x = rect->X;
5224     args.y = rect->Y + offsety;
5225
5226     args.rel_width = rel_width;
5227     args.rel_height = rel_height;
5228
5229     GetTextMetricsW(hdc, &textmetric);
5230     args.ascent = textmetric.tmAscent / rel_height;
5231
5232     gdip_format_string(hdc, string, length, font, &scaled_rect, format,
5233         draw_string_callback, &args);
5234
5235     DeleteObject(rgn);
5236     DeleteObject(gdifont);
5237
5238     RestoreDC(hdc, save_state);
5239
5240     DeleteDC(temp_hdc);
5241
5242     return Ok;
5243 }
5244
5245 GpStatus WINGDIPAPI GdipResetClip(GpGraphics *graphics)
5246 {
5247     TRACE("(%p)\n", graphics);
5248
5249     if(!graphics)
5250         return InvalidParameter;
5251
5252     if(graphics->busy)
5253         return ObjectBusy;
5254
5255     return GdipSetInfinite(graphics->clip);
5256 }
5257
5258 GpStatus WINGDIPAPI GdipResetWorldTransform(GpGraphics *graphics)
5259 {
5260     TRACE("(%p)\n", graphics);
5261
5262     if(!graphics)
5263         return InvalidParameter;
5264
5265     if(graphics->busy)
5266         return ObjectBusy;
5267
5268     graphics->worldtrans->matrix[0] = 1.0;
5269     graphics->worldtrans->matrix[1] = 0.0;
5270     graphics->worldtrans->matrix[2] = 0.0;
5271     graphics->worldtrans->matrix[3] = 1.0;
5272     graphics->worldtrans->matrix[4] = 0.0;
5273     graphics->worldtrans->matrix[5] = 0.0;
5274
5275     return Ok;
5276 }
5277
5278 GpStatus WINGDIPAPI GdipRestoreGraphics(GpGraphics *graphics, GraphicsState state)
5279 {
5280     return GdipEndContainer(graphics, state);
5281 }
5282
5283 GpStatus WINGDIPAPI GdipRotateWorldTransform(GpGraphics *graphics, REAL angle,
5284     GpMatrixOrder order)
5285 {
5286     TRACE("(%p, %.2f, %d)\n", graphics, angle, order);
5287
5288     if(!graphics)
5289         return InvalidParameter;
5290
5291     if(graphics->busy)
5292         return ObjectBusy;
5293
5294     return GdipRotateMatrix(graphics->worldtrans, angle, order);
5295 }
5296
5297 GpStatus WINGDIPAPI GdipSaveGraphics(GpGraphics *graphics, GraphicsState *state)
5298 {
5299     return GdipBeginContainer2(graphics, state);
5300 }
5301
5302 GpStatus WINGDIPAPI GdipBeginContainer2(GpGraphics *graphics,
5303         GraphicsContainer *state)
5304 {
5305     GraphicsContainerItem *container;
5306     GpStatus sts;
5307
5308     TRACE("(%p, %p)\n", graphics, state);
5309
5310     if(!graphics || !state)
5311         return InvalidParameter;
5312
5313     sts = init_container(&container, graphics);
5314     if(sts != Ok)
5315         return sts;
5316
5317     list_add_head(&graphics->containers, &container->entry);
5318     *state = graphics->contid = container->contid;
5319
5320     return Ok;
5321 }
5322
5323 GpStatus WINGDIPAPI GdipBeginContainer(GpGraphics *graphics, GDIPCONST GpRectF *dstrect, GDIPCONST GpRectF *srcrect, GpUnit unit, GraphicsContainer *state)
5324 {
5325     FIXME("(%p, %p, %p, %d, %p): stub\n", graphics, dstrect, srcrect, unit, state);
5326     return NotImplemented;
5327 }
5328
5329 GpStatus WINGDIPAPI GdipBeginContainerI(GpGraphics *graphics, GDIPCONST GpRect *dstrect, GDIPCONST GpRect *srcrect, GpUnit unit, GraphicsContainer *state)
5330 {
5331     FIXME("(%p, %p, %p, %d, %p): stub\n", graphics, dstrect, srcrect, unit, state);
5332     return NotImplemented;
5333 }
5334
5335 GpStatus WINGDIPAPI GdipComment(GpGraphics *graphics, UINT sizeData, GDIPCONST BYTE *data)
5336 {
5337     FIXME("(%p, %d, %p): stub\n", graphics, sizeData, data);
5338     return NotImplemented;
5339 }
5340
5341 GpStatus WINGDIPAPI GdipEndContainer(GpGraphics *graphics, GraphicsContainer state)
5342 {
5343     GpStatus sts;
5344     GraphicsContainerItem *container, *container2;
5345
5346     TRACE("(%p, %x)\n", graphics, state);
5347
5348     if(!graphics)
5349         return InvalidParameter;
5350
5351     LIST_FOR_EACH_ENTRY(container, &graphics->containers, GraphicsContainerItem, entry){
5352         if(container->contid == state)
5353             break;
5354     }
5355
5356     /* did not find a matching container */
5357     if(&container->entry == &graphics->containers)
5358         return Ok;
5359
5360     sts = restore_container(graphics, container);
5361     if(sts != Ok)
5362         return sts;
5363
5364     /* remove all of the containers on top of the found container */
5365     LIST_FOR_EACH_ENTRY_SAFE(container, container2, &graphics->containers, GraphicsContainerItem, entry){
5366         if(container->contid == state)
5367             break;
5368         list_remove(&container->entry);
5369         delete_container(container);
5370     }
5371
5372     list_remove(&container->entry);
5373     delete_container(container);
5374
5375     return Ok;
5376 }
5377
5378 GpStatus WINGDIPAPI GdipScaleWorldTransform(GpGraphics *graphics, REAL sx,
5379     REAL sy, GpMatrixOrder order)
5380 {
5381     TRACE("(%p, %.2f, %.2f, %d)\n", graphics, sx, sy, order);
5382
5383     if(!graphics)
5384         return InvalidParameter;
5385
5386     if(graphics->busy)
5387         return ObjectBusy;
5388
5389     return GdipScaleMatrix(graphics->worldtrans, sx, sy, order);
5390 }
5391
5392 GpStatus WINGDIPAPI GdipSetClipGraphics(GpGraphics *graphics, GpGraphics *srcgraphics,
5393     CombineMode mode)
5394 {
5395     TRACE("(%p, %p, %d)\n", graphics, srcgraphics, mode);
5396
5397     if(!graphics || !srcgraphics)
5398         return InvalidParameter;
5399
5400     return GdipCombineRegionRegion(graphics->clip, srcgraphics->clip, mode);
5401 }
5402
5403 GpStatus WINGDIPAPI GdipSetCompositingMode(GpGraphics *graphics,
5404     CompositingMode mode)
5405 {
5406     TRACE("(%p, %d)\n", graphics, mode);
5407
5408     if(!graphics)
5409         return InvalidParameter;
5410
5411     if(graphics->busy)
5412         return ObjectBusy;
5413
5414     graphics->compmode = mode;
5415
5416     return Ok;
5417 }
5418
5419 GpStatus WINGDIPAPI GdipSetCompositingQuality(GpGraphics *graphics,
5420     CompositingQuality quality)
5421 {
5422     TRACE("(%p, %d)\n", graphics, quality);
5423
5424     if(!graphics)
5425         return InvalidParameter;
5426
5427     if(graphics->busy)
5428         return ObjectBusy;
5429
5430     graphics->compqual = quality;
5431
5432     return Ok;
5433 }
5434
5435 GpStatus WINGDIPAPI GdipSetInterpolationMode(GpGraphics *graphics,
5436     InterpolationMode mode)
5437 {
5438     TRACE("(%p, %d)\n", graphics, mode);
5439
5440     if(!graphics || mode == InterpolationModeInvalid || mode > InterpolationModeHighQualityBicubic)
5441         return InvalidParameter;
5442
5443     if(graphics->busy)
5444         return ObjectBusy;
5445
5446     if (mode == InterpolationModeDefault || mode == InterpolationModeLowQuality)
5447         mode = InterpolationModeBilinear;
5448
5449     if (mode == InterpolationModeHighQuality)
5450         mode = InterpolationModeHighQualityBicubic;
5451
5452     graphics->interpolation = mode;
5453
5454     return Ok;
5455 }
5456
5457 GpStatus WINGDIPAPI GdipSetPageScale(GpGraphics *graphics, REAL scale)
5458 {
5459     TRACE("(%p, %.2f)\n", graphics, scale);
5460
5461     if(!graphics || (scale <= 0.0))
5462         return InvalidParameter;
5463
5464     if(graphics->busy)
5465         return ObjectBusy;
5466
5467     graphics->scale = scale;
5468
5469     return Ok;
5470 }
5471
5472 GpStatus WINGDIPAPI GdipSetPageUnit(GpGraphics *graphics, GpUnit unit)
5473 {
5474     TRACE("(%p, %d)\n", graphics, unit);
5475
5476     if(!graphics)
5477         return InvalidParameter;
5478
5479     if(graphics->busy)
5480         return ObjectBusy;
5481
5482     if(unit == UnitWorld)
5483         return InvalidParameter;
5484
5485     graphics->unit = unit;
5486
5487     return Ok;
5488 }
5489
5490 GpStatus WINGDIPAPI GdipSetPixelOffsetMode(GpGraphics *graphics, PixelOffsetMode
5491     mode)
5492 {
5493     TRACE("(%p, %d)\n", graphics, mode);
5494
5495     if(!graphics)
5496         return InvalidParameter;
5497
5498     if(graphics->busy)
5499         return ObjectBusy;
5500
5501     graphics->pixeloffset = mode;
5502
5503     return Ok;
5504 }
5505
5506 GpStatus WINGDIPAPI GdipSetRenderingOrigin(GpGraphics *graphics, INT x, INT y)
5507 {
5508     static int calls;
5509
5510     TRACE("(%p,%i,%i)\n", graphics, x, y);
5511
5512     if (!(calls++))
5513         FIXME("value is unused in rendering\n");
5514
5515     if (!graphics)
5516         return InvalidParameter;
5517
5518     graphics->origin_x = x;
5519     graphics->origin_y = y;
5520
5521     return Ok;
5522 }
5523
5524 GpStatus WINGDIPAPI GdipGetRenderingOrigin(GpGraphics *graphics, INT *x, INT *y)
5525 {
5526     TRACE("(%p,%p,%p)\n", graphics, x, y);
5527
5528     if (!graphics || !x || !y)
5529         return InvalidParameter;
5530
5531     *x = graphics->origin_x;
5532     *y = graphics->origin_y;
5533
5534     return Ok;
5535 }
5536
5537 GpStatus WINGDIPAPI GdipSetSmoothingMode(GpGraphics *graphics, SmoothingMode mode)
5538 {
5539     TRACE("(%p, %d)\n", graphics, mode);
5540
5541     if(!graphics)
5542         return InvalidParameter;
5543
5544     if(graphics->busy)
5545         return ObjectBusy;
5546
5547     graphics->smoothing = mode;
5548
5549     return Ok;
5550 }
5551
5552 GpStatus WINGDIPAPI GdipSetTextContrast(GpGraphics *graphics, UINT contrast)
5553 {
5554     TRACE("(%p, %d)\n", graphics, contrast);
5555
5556     if(!graphics)
5557         return InvalidParameter;
5558
5559     graphics->textcontrast = contrast;
5560
5561     return Ok;
5562 }
5563
5564 GpStatus WINGDIPAPI GdipSetTextRenderingHint(GpGraphics *graphics,
5565     TextRenderingHint hint)
5566 {
5567     TRACE("(%p, %d)\n", graphics, hint);
5568
5569     if(!graphics || hint > TextRenderingHintClearTypeGridFit)
5570         return InvalidParameter;
5571
5572     if(graphics->busy)
5573         return ObjectBusy;
5574
5575     graphics->texthint = hint;
5576
5577     return Ok;
5578 }
5579
5580 GpStatus WINGDIPAPI GdipSetWorldTransform(GpGraphics *graphics, GpMatrix *matrix)
5581 {
5582     TRACE("(%p, %p)\n", graphics, matrix);
5583
5584     if(!graphics || !matrix)
5585         return InvalidParameter;
5586
5587     if(graphics->busy)
5588         return ObjectBusy;
5589
5590     TRACE("%f,%f,%f,%f,%f,%f\n",
5591           matrix->matrix[0], matrix->matrix[1], matrix->matrix[2],
5592           matrix->matrix[3], matrix->matrix[4], matrix->matrix[5]);
5593
5594     GdipDeleteMatrix(graphics->worldtrans);
5595     return GdipCloneMatrix(matrix, &graphics->worldtrans);
5596 }
5597
5598 GpStatus WINGDIPAPI GdipTranslateWorldTransform(GpGraphics *graphics, REAL dx,
5599     REAL dy, GpMatrixOrder order)
5600 {
5601     TRACE("(%p, %.2f, %.2f, %d)\n", graphics, dx, dy, order);
5602
5603     if(!graphics)
5604         return InvalidParameter;
5605
5606     if(graphics->busy)
5607         return ObjectBusy;
5608
5609     return GdipTranslateMatrix(graphics->worldtrans, dx, dy, order);
5610 }
5611
5612 /*****************************************************************************
5613  * GdipSetClipHrgn [GDIPLUS.@]
5614  */
5615 GpStatus WINGDIPAPI GdipSetClipHrgn(GpGraphics *graphics, HRGN hrgn, CombineMode mode)
5616 {
5617     GpRegion *region;
5618     GpStatus status;
5619
5620     TRACE("(%p, %p, %d)\n", graphics, hrgn, mode);
5621
5622     if(!graphics)
5623         return InvalidParameter;
5624
5625     status = GdipCreateRegionHrgn(hrgn, &region);
5626     if(status != Ok)
5627         return status;
5628
5629     status = GdipSetClipRegion(graphics, region, mode);
5630
5631     GdipDeleteRegion(region);
5632     return status;
5633 }
5634
5635 GpStatus WINGDIPAPI GdipSetClipPath(GpGraphics *graphics, GpPath *path, CombineMode mode)
5636 {
5637     TRACE("(%p, %p, %d)\n", graphics, path, mode);
5638
5639     if(!graphics)
5640         return InvalidParameter;
5641
5642     if(graphics->busy)
5643         return ObjectBusy;
5644
5645     return GdipCombineRegionPath(graphics->clip, path, mode);
5646 }
5647
5648 GpStatus WINGDIPAPI GdipSetClipRect(GpGraphics *graphics, REAL x, REAL y,
5649                                     REAL width, REAL height,
5650                                     CombineMode mode)
5651 {
5652     GpRectF rect;
5653
5654     TRACE("(%p, %.2f, %.2f, %.2f, %.2f, %d)\n", graphics, x, y, width, height, mode);
5655
5656     if(!graphics)
5657         return InvalidParameter;
5658
5659     if(graphics->busy)
5660         return ObjectBusy;
5661
5662     rect.X = x;
5663     rect.Y = y;
5664     rect.Width  = width;
5665     rect.Height = height;
5666
5667     return GdipCombineRegionRect(graphics->clip, &rect, mode);
5668 }
5669
5670 GpStatus WINGDIPAPI GdipSetClipRectI(GpGraphics *graphics, INT x, INT y,
5671                                      INT width, INT height,
5672                                      CombineMode mode)
5673 {
5674     TRACE("(%p, %d, %d, %d, %d, %d)\n", graphics, x, y, width, height, mode);
5675
5676     if(!graphics)
5677         return InvalidParameter;
5678
5679     if(graphics->busy)
5680         return ObjectBusy;
5681
5682     return GdipSetClipRect(graphics, (REAL)x, (REAL)y, (REAL)width, (REAL)height, mode);
5683 }
5684
5685 GpStatus WINGDIPAPI GdipSetClipRegion(GpGraphics *graphics, GpRegion *region,
5686                                       CombineMode mode)
5687 {
5688     TRACE("(%p, %p, %d)\n", graphics, region, mode);
5689
5690     if(!graphics || !region)
5691         return InvalidParameter;
5692
5693     if(graphics->busy)
5694         return ObjectBusy;
5695
5696     return GdipCombineRegionRegion(graphics->clip, region, mode);
5697 }
5698
5699 GpStatus WINGDIPAPI GdipSetMetafileDownLevelRasterizationLimit(GpMetafile *metafile,
5700     UINT limitDpi)
5701 {
5702     static int calls;
5703
5704     TRACE("(%p,%u)\n", metafile, limitDpi);
5705
5706     if(!(calls++))
5707         FIXME("not implemented\n");
5708
5709     return NotImplemented;
5710 }
5711
5712 GpStatus WINGDIPAPI GdipDrawPolygon(GpGraphics *graphics,GpPen *pen,GDIPCONST GpPointF *points,
5713     INT count)
5714 {
5715     INT save_state;
5716     POINT *pti;
5717
5718     TRACE("(%p, %p, %d)\n", graphics, points, count);
5719
5720     if(!graphics || !pen || count<=0)
5721         return InvalidParameter;
5722
5723     if(graphics->busy)
5724         return ObjectBusy;
5725
5726     if (!graphics->hdc)
5727     {
5728         FIXME("graphics object has no HDC\n");
5729         return Ok;
5730     }
5731
5732     pti = GdipAlloc(sizeof(POINT) * count);
5733
5734     save_state = prepare_dc(graphics, pen);
5735     SelectObject(graphics->hdc, GetStockObject(NULL_BRUSH));
5736
5737     transform_and_round_points(graphics, pti, (GpPointF*)points, count);
5738     Polygon(graphics->hdc, pti, count);
5739
5740     restore_dc(graphics, save_state);
5741     GdipFree(pti);
5742
5743     return Ok;
5744 }
5745
5746 GpStatus WINGDIPAPI GdipDrawPolygonI(GpGraphics *graphics,GpPen *pen,GDIPCONST GpPoint *points,
5747     INT count)
5748 {
5749     GpStatus ret;
5750     GpPointF *ptf;
5751     INT i;
5752
5753     TRACE("(%p, %p, %p, %d)\n", graphics, pen, points, count);
5754
5755     if(count<=0)    return InvalidParameter;
5756     ptf = GdipAlloc(sizeof(GpPointF) * count);
5757
5758     for(i = 0;i < count; i++){
5759         ptf[i].X = (REAL)points[i].X;
5760         ptf[i].Y = (REAL)points[i].Y;
5761     }
5762
5763     ret = GdipDrawPolygon(graphics,pen,ptf,count);
5764     GdipFree(ptf);
5765
5766     return ret;
5767 }
5768
5769 GpStatus WINGDIPAPI GdipGetDpiX(GpGraphics *graphics, REAL* dpi)
5770 {
5771     TRACE("(%p, %p)\n", graphics, dpi);
5772
5773     if(!graphics || !dpi)
5774         return InvalidParameter;
5775
5776     if(graphics->busy)
5777         return ObjectBusy;
5778
5779     *dpi = graphics->xres;
5780     return Ok;
5781 }
5782
5783 GpStatus WINGDIPAPI GdipGetDpiY(GpGraphics *graphics, REAL* dpi)
5784 {
5785     TRACE("(%p, %p)\n", graphics, dpi);
5786
5787     if(!graphics || !dpi)
5788         return InvalidParameter;
5789
5790     if(graphics->busy)
5791         return ObjectBusy;
5792
5793     *dpi = graphics->yres;
5794     return Ok;
5795 }
5796
5797 GpStatus WINGDIPAPI GdipMultiplyWorldTransform(GpGraphics *graphics, GDIPCONST GpMatrix *matrix,
5798     GpMatrixOrder order)
5799 {
5800     GpMatrix m;
5801     GpStatus ret;
5802
5803     TRACE("(%p, %p, %d)\n", graphics, matrix, order);
5804
5805     if(!graphics || !matrix)
5806         return InvalidParameter;
5807
5808     if(graphics->busy)
5809         return ObjectBusy;
5810
5811     m = *(graphics->worldtrans);
5812
5813     ret = GdipMultiplyMatrix(&m, matrix, order);
5814     if(ret == Ok)
5815         *(graphics->worldtrans) = m;
5816
5817     return ret;
5818 }
5819
5820 /* Color used to fill bitmaps so we can tell which parts have been drawn over by gdi32. */
5821 static const COLORREF DC_BACKGROUND_KEY = 0x0c0b0d;
5822
5823 GpStatus WINGDIPAPI GdipGetDC(GpGraphics *graphics, HDC *hdc)
5824 {
5825     GpStatus stat=Ok;
5826
5827     TRACE("(%p, %p)\n", graphics, hdc);
5828
5829     if(!graphics || !hdc)
5830         return InvalidParameter;
5831
5832     if(graphics->busy)
5833         return ObjectBusy;
5834
5835     if (graphics->image && graphics->image->type == ImageTypeMetafile)
5836     {
5837         stat = METAFILE_GetDC((GpMetafile*)graphics->image, hdc);
5838     }
5839     else if (!graphics->hdc ||
5840         (graphics->image && graphics->image->type == ImageTypeBitmap && ((GpBitmap*)graphics->image)->format & PixelFormatAlpha))
5841     {
5842         /* Create a fake HDC and fill it with a constant color. */
5843         HDC temp_hdc;
5844         HBITMAP hbitmap;
5845         GpRectF bounds;
5846         BITMAPINFOHEADER bmih;
5847         int i;
5848
5849         stat = get_graphics_bounds(graphics, &bounds);
5850         if (stat != Ok)
5851             return stat;
5852
5853         graphics->temp_hbitmap_width = bounds.Width;
5854         graphics->temp_hbitmap_height = bounds.Height;
5855
5856         bmih.biSize = sizeof(bmih);
5857         bmih.biWidth = graphics->temp_hbitmap_width;
5858         bmih.biHeight = -graphics->temp_hbitmap_height;
5859         bmih.biPlanes = 1;
5860         bmih.biBitCount = 32;
5861         bmih.biCompression = BI_RGB;
5862         bmih.biSizeImage = 0;
5863         bmih.biXPelsPerMeter = 0;
5864         bmih.biYPelsPerMeter = 0;
5865         bmih.biClrUsed = 0;
5866         bmih.biClrImportant = 0;
5867
5868         hbitmap = CreateDIBSection(NULL, (BITMAPINFO*)&bmih, DIB_RGB_COLORS,
5869             (void**)&graphics->temp_bits, NULL, 0);
5870         if (!hbitmap)
5871             return GenericError;
5872
5873         temp_hdc = CreateCompatibleDC(0);
5874         if (!temp_hdc)
5875         {
5876             DeleteObject(hbitmap);
5877             return GenericError;
5878         }
5879
5880         for (i=0; i<(graphics->temp_hbitmap_width * graphics->temp_hbitmap_height); i++)
5881             ((DWORD*)graphics->temp_bits)[i] = DC_BACKGROUND_KEY;
5882
5883         SelectObject(temp_hdc, hbitmap);
5884
5885         graphics->temp_hbitmap = hbitmap;
5886         *hdc = graphics->temp_hdc = temp_hdc;
5887     }
5888     else
5889     {
5890         *hdc = graphics->hdc;
5891     }
5892
5893     if (stat == Ok)
5894         graphics->busy = TRUE;
5895
5896     return stat;
5897 }
5898
5899 GpStatus WINGDIPAPI GdipReleaseDC(GpGraphics *graphics, HDC hdc)
5900 {
5901     GpStatus stat=Ok;
5902
5903     TRACE("(%p, %p)\n", graphics, hdc);
5904
5905     if(!graphics || !hdc || !graphics->busy)
5906         return InvalidParameter;
5907
5908     if (graphics->image && graphics->image->type == ImageTypeMetafile)
5909     {
5910         stat = METAFILE_ReleaseDC((GpMetafile*)graphics->image, hdc);
5911     }
5912     else if (graphics->temp_hdc == hdc)
5913     {
5914         DWORD* pos;
5915         int i;
5916
5917         /* Find the pixels that have changed, and mark them as opaque. */
5918         pos = (DWORD*)graphics->temp_bits;
5919         for (i=0; i<(graphics->temp_hbitmap_width * graphics->temp_hbitmap_height); i++)
5920         {
5921             if (*pos != DC_BACKGROUND_KEY)
5922             {
5923                 *pos |= 0xff000000;
5924             }
5925             pos++;
5926         }
5927
5928         /* Write the changed pixels to the real target. */
5929         alpha_blend_pixels(graphics, 0, 0, graphics->temp_bits,
5930             graphics->temp_hbitmap_width, graphics->temp_hbitmap_height,
5931             graphics->temp_hbitmap_width * 4);
5932
5933         /* Clean up. */
5934         DeleteDC(graphics->temp_hdc);
5935         DeleteObject(graphics->temp_hbitmap);
5936         graphics->temp_hdc = NULL;
5937         graphics->temp_hbitmap = NULL;
5938     }
5939     else if (hdc != graphics->hdc)
5940     {
5941         stat = InvalidParameter;
5942     }
5943
5944     if (stat == Ok)
5945         graphics->busy = FALSE;
5946
5947     return stat;
5948 }
5949
5950 GpStatus WINGDIPAPI GdipGetClip(GpGraphics *graphics, GpRegion *region)
5951 {
5952     GpRegion *clip;
5953     GpStatus status;
5954
5955     TRACE("(%p, %p)\n", graphics, region);
5956
5957     if(!graphics || !region)
5958         return InvalidParameter;
5959
5960     if(graphics->busy)
5961         return ObjectBusy;
5962
5963     if((status = GdipCloneRegion(graphics->clip, &clip)) != Ok)
5964         return status;
5965
5966     /* free everything except root node and header */
5967     delete_element(&region->node);
5968     memcpy(region, clip, sizeof(GpRegion));
5969     GdipFree(clip);
5970
5971     return Ok;
5972 }
5973
5974 static GpStatus get_graphics_transform(GpGraphics *graphics, GpCoordinateSpace dst_space,
5975         GpCoordinateSpace src_space, GpMatrix **matrix)
5976 {
5977     GpStatus stat = GdipCreateMatrix(matrix);
5978     REAL scale_x, scale_y;
5979
5980     if (dst_space != src_space && stat == Ok)
5981     {
5982         scale_x = units_to_pixels(1.0, graphics->unit, graphics->xres);
5983         scale_y = units_to_pixels(1.0, graphics->unit, graphics->yres);
5984
5985         if(graphics->unit != UnitDisplay)
5986         {
5987             scale_x *= graphics->scale;
5988             scale_y *= graphics->scale;
5989         }
5990
5991         /* transform from src_space to CoordinateSpacePage */
5992         switch (src_space)
5993         {
5994         case CoordinateSpaceWorld:
5995             GdipMultiplyMatrix(*matrix, graphics->worldtrans, MatrixOrderAppend);
5996             break;
5997         case CoordinateSpacePage:
5998             break;
5999         case CoordinateSpaceDevice:
6000             GdipScaleMatrix(*matrix, 1.0/scale_x, 1.0/scale_y, MatrixOrderAppend);
6001             break;
6002         }
6003
6004         /* transform from CoordinateSpacePage to dst_space */
6005         switch (dst_space)
6006         {
6007         case CoordinateSpaceWorld:
6008             {
6009                 GpMatrix *inverted_transform;
6010                 stat = GdipCloneMatrix(graphics->worldtrans, &inverted_transform);
6011                 if (stat == Ok)
6012                 {
6013                     stat = GdipInvertMatrix(inverted_transform);
6014                     if (stat == Ok)
6015                         GdipMultiplyMatrix(*matrix, inverted_transform, MatrixOrderAppend);
6016                     GdipDeleteMatrix(inverted_transform);
6017                 }
6018                 break;
6019             }
6020         case CoordinateSpacePage:
6021             break;
6022         case CoordinateSpaceDevice:
6023             GdipScaleMatrix(*matrix, scale_x, scale_y, MatrixOrderAppend);
6024             break;
6025         }
6026     }
6027     return stat;
6028 }
6029
6030 GpStatus WINGDIPAPI GdipTransformPoints(GpGraphics *graphics, GpCoordinateSpace dst_space,
6031                                         GpCoordinateSpace src_space, GpPointF *points, INT count)
6032 {
6033     GpMatrix *matrix;
6034     GpStatus stat;
6035
6036     if(!graphics || !points || count <= 0)
6037         return InvalidParameter;
6038
6039     if(graphics->busy)
6040         return ObjectBusy;
6041
6042     TRACE("(%p, %d, %d, %p, %d)\n", graphics, dst_space, src_space, points, count);
6043
6044     if (src_space == dst_space) return Ok;
6045
6046     stat = get_graphics_transform(graphics, dst_space, src_space, &matrix);
6047
6048     if (stat == Ok)
6049     {
6050         stat = GdipTransformMatrixPoints(matrix, points, count);
6051
6052         GdipDeleteMatrix(matrix);
6053     }
6054
6055     return stat;
6056 }
6057
6058 GpStatus WINGDIPAPI GdipTransformPointsI(GpGraphics *graphics, GpCoordinateSpace dst_space,
6059                                          GpCoordinateSpace src_space, GpPoint *points, INT count)
6060 {
6061     GpPointF *pointsF;
6062     GpStatus ret;
6063     INT i;
6064
6065     TRACE("(%p, %d, %d, %p, %d)\n", graphics, dst_space, src_space, points, count);
6066
6067     if(count <= 0)
6068         return InvalidParameter;
6069
6070     pointsF = GdipAlloc(sizeof(GpPointF) * count);
6071     if(!pointsF)
6072         return OutOfMemory;
6073
6074     for(i = 0; i < count; i++){
6075         pointsF[i].X = (REAL)points[i].X;
6076         pointsF[i].Y = (REAL)points[i].Y;
6077     }
6078
6079     ret = GdipTransformPoints(graphics, dst_space, src_space, pointsF, count);
6080
6081     if(ret == Ok)
6082         for(i = 0; i < count; i++){
6083             points[i].X = roundr(pointsF[i].X);
6084             points[i].Y = roundr(pointsF[i].Y);
6085         }
6086     GdipFree(pointsF);
6087
6088     return ret;
6089 }
6090
6091 HPALETTE WINGDIPAPI GdipCreateHalftonePalette(void)
6092 {
6093     static int calls;
6094
6095     TRACE("\n");
6096
6097     if (!calls++)
6098       FIXME("stub\n");
6099
6100     return NULL;
6101 }
6102
6103 /*****************************************************************************
6104  * GdipTranslateClip [GDIPLUS.@]
6105  */
6106 GpStatus WINGDIPAPI GdipTranslateClip(GpGraphics *graphics, REAL dx, REAL dy)
6107 {
6108     TRACE("(%p, %.2f, %.2f)\n", graphics, dx, dy);
6109
6110     if(!graphics)
6111         return InvalidParameter;
6112
6113     if(graphics->busy)
6114         return ObjectBusy;
6115
6116     return GdipTranslateRegion(graphics->clip, dx, dy);
6117 }
6118
6119 /*****************************************************************************
6120  * GdipTranslateClipI [GDIPLUS.@]
6121  */
6122 GpStatus WINGDIPAPI GdipTranslateClipI(GpGraphics *graphics, INT dx, INT dy)
6123 {
6124     TRACE("(%p, %d, %d)\n", graphics, dx, dy);
6125
6126     if(!graphics)
6127         return InvalidParameter;
6128
6129     if(graphics->busy)
6130         return ObjectBusy;
6131
6132     return GdipTranslateRegion(graphics->clip, (REAL)dx, (REAL)dy);
6133 }
6134
6135
6136 /*****************************************************************************
6137  * GdipMeasureDriverString [GDIPLUS.@]
6138  */
6139 GpStatus WINGDIPAPI GdipMeasureDriverString(GpGraphics *graphics, GDIPCONST UINT16 *text, INT length,
6140                                             GDIPCONST GpFont *font, GDIPCONST PointF *positions,
6141                                             INT flags, GDIPCONST GpMatrix *matrix, RectF *boundingBox)
6142 {
6143     static const INT unsupported_flags = ~(DriverStringOptionsCmapLookup|DriverStringOptionsRealizedAdvance);
6144     HFONT hfont;
6145     HDC hdc;
6146     REAL min_x, min_y, max_x, max_y, x, y;
6147     int i;
6148     TEXTMETRICW textmetric;
6149     const WORD *glyph_indices;
6150     WORD *dynamic_glyph_indices=NULL;
6151     REAL rel_width, rel_height, ascent, descent;
6152     GpPointF pt[3];
6153
6154     TRACE("(%p %p %d %p %p %d %p %p)\n", graphics, text, length, font, positions, flags, matrix, boundingBox);
6155
6156     if (!graphics || !text || !font || !positions || !boundingBox)
6157         return InvalidParameter;
6158
6159     if (length == -1)
6160         length = strlenW(text);
6161
6162     if (length == 0)
6163     {
6164         boundingBox->X = 0.0;
6165         boundingBox->Y = 0.0;
6166         boundingBox->Width = 0.0;
6167         boundingBox->Height = 0.0;
6168     }
6169
6170     if (flags & unsupported_flags)
6171         FIXME("Ignoring flags %x\n", flags & unsupported_flags);
6172
6173     if (matrix)
6174         FIXME("Ignoring matrix\n");
6175
6176     get_font_hfont(graphics, font, &hfont);
6177
6178     hdc = CreateCompatibleDC(0);
6179     SelectObject(hdc, hfont);
6180
6181     GetTextMetricsW(hdc, &textmetric);
6182
6183     pt[0].X = 0.0;
6184     pt[0].Y = 0.0;
6185     pt[1].X = 1.0;
6186     pt[1].Y = 0.0;
6187     pt[2].X = 0.0;
6188     pt[2].Y = 1.0;
6189     GdipTransformPoints(graphics, CoordinateSpaceDevice, CoordinateSpaceWorld, pt, 3);
6190     rel_width = sqrt((pt[1].Y-pt[0].Y)*(pt[1].Y-pt[0].Y)+
6191                      (pt[1].X-pt[0].X)*(pt[1].X-pt[0].X));
6192     rel_height = sqrt((pt[2].Y-pt[0].Y)*(pt[2].Y-pt[0].Y)+
6193                       (pt[2].X-pt[0].X)*(pt[2].X-pt[0].X));
6194
6195     if (flags & DriverStringOptionsCmapLookup)
6196     {
6197         glyph_indices = dynamic_glyph_indices = GdipAlloc(sizeof(WORD) * length);
6198         if (!glyph_indices)
6199         {
6200             DeleteDC(hdc);
6201             DeleteObject(hfont);
6202             return OutOfMemory;
6203         }
6204
6205         GetGlyphIndicesW(hdc, text, length, dynamic_glyph_indices, 0);
6206     }
6207     else
6208         glyph_indices = text;
6209
6210     min_x = max_x = x = positions[0].X;
6211     min_y = max_y = y = positions[0].Y;
6212
6213     ascent = textmetric.tmAscent / rel_height;
6214     descent = textmetric.tmDescent / rel_height;
6215
6216     for (i=0; i<length; i++)
6217     {
6218         int char_width;
6219         ABC abc;
6220
6221         if (!(flags & DriverStringOptionsRealizedAdvance))
6222         {
6223             x = positions[i].X;
6224             y = positions[i].Y;
6225         }
6226
6227         GetCharABCWidthsW(hdc, glyph_indices[i], glyph_indices[i], &abc);
6228         char_width = abc.abcA + abc.abcB + abc.abcB;
6229
6230         if (min_y > y - ascent) min_y = y - ascent;
6231         if (max_y < y + descent) max_y = y + descent;
6232         if (min_x > x) min_x = x;
6233
6234         x += char_width / rel_width;
6235
6236         if (max_x < x) max_x = x;
6237     }
6238
6239     GdipFree(dynamic_glyph_indices);
6240     DeleteDC(hdc);
6241     DeleteObject(hfont);
6242
6243     boundingBox->X = min_x;
6244     boundingBox->Y = min_y;
6245     boundingBox->Width = max_x - min_x;
6246     boundingBox->Height = max_y - min_y;
6247
6248     return Ok;
6249 }
6250
6251 static GpStatus GDI32_GdipDrawDriverString(GpGraphics *graphics, GDIPCONST UINT16 *text, INT length,
6252                                      GDIPCONST GpFont *font, GDIPCONST GpBrush *brush,
6253                                      GDIPCONST PointF *positions, INT flags,
6254                                      GDIPCONST GpMatrix *matrix )
6255 {
6256     static const INT unsupported_flags = ~(DriverStringOptionsRealizedAdvance|DriverStringOptionsCmapLookup);
6257     INT save_state;
6258     GpPointF pt;
6259     HFONT hfont;
6260     UINT eto_flags=0;
6261
6262     if (flags & unsupported_flags)
6263         FIXME("Ignoring flags %x\n", flags & unsupported_flags);
6264
6265     if (matrix)
6266         FIXME("Ignoring matrix\n");
6267
6268     if (!(flags & DriverStringOptionsCmapLookup))
6269         eto_flags |= ETO_GLYPH_INDEX;
6270
6271     save_state = SaveDC(graphics->hdc);
6272     SetBkMode(graphics->hdc, TRANSPARENT);
6273     SetTextColor(graphics->hdc, get_gdi_brush_color(brush));
6274
6275     pt = positions[0];
6276     GdipTransformPoints(graphics, CoordinateSpaceDevice, CoordinateSpaceWorld, &pt, 1);
6277
6278     get_font_hfont(graphics, font, &hfont);
6279     SelectObject(graphics->hdc, hfont);
6280
6281     SetTextAlign(graphics->hdc, TA_BASELINE|TA_LEFT);
6282
6283     ExtTextOutW(graphics->hdc, roundr(pt.X), roundr(pt.Y), eto_flags, NULL, text, length, NULL);
6284
6285     RestoreDC(graphics->hdc, save_state);
6286
6287     DeleteObject(hfont);
6288
6289     return Ok;
6290 }
6291
6292 static GpStatus SOFTWARE_GdipDrawDriverString(GpGraphics *graphics, GDIPCONST UINT16 *text, INT length,
6293                                          GDIPCONST GpFont *font, GDIPCONST GpBrush *brush,
6294                                          GDIPCONST PointF *positions, INT flags,
6295                                          GDIPCONST GpMatrix *matrix )
6296 {
6297     static const INT unsupported_flags = ~(DriverStringOptionsCmapLookup|DriverStringOptionsRealizedAdvance);
6298     GpStatus stat;
6299     PointF *real_positions, real_position;
6300     POINT *pti;
6301     HFONT hfont;
6302     HDC hdc;
6303     int min_x=INT_MAX, min_y=INT_MAX, max_x=INT_MIN, max_y=INT_MIN, i, x, y;
6304     DWORD max_glyphsize=0;
6305     GLYPHMETRICS glyphmetrics;
6306     static const MAT2 identity = {{0,1}, {0,0}, {0,0}, {0,1}};
6307     BYTE *glyph_mask;
6308     BYTE *text_mask;
6309     int text_mask_stride;
6310     BYTE *pixel_data;
6311     int pixel_data_stride;
6312     GpRect pixel_area;
6313     UINT ggo_flags = GGO_GRAY8_BITMAP;
6314
6315     if (length <= 0)
6316         return Ok;
6317
6318     if (!(flags & DriverStringOptionsCmapLookup))
6319         ggo_flags |= GGO_GLYPH_INDEX;
6320
6321     if (flags & unsupported_flags)
6322         FIXME("Ignoring flags %x\n", flags & unsupported_flags);
6323
6324     if (matrix)
6325         FIXME("Ignoring matrix\n");
6326
6327     pti = GdipAlloc(sizeof(POINT) * length);
6328     if (!pti)
6329         return OutOfMemory;
6330
6331     if (flags & DriverStringOptionsRealizedAdvance)
6332     {
6333         real_position = positions[0];
6334
6335         transform_and_round_points(graphics, pti, &real_position, 1);
6336     }
6337     else
6338     {
6339         real_positions = GdipAlloc(sizeof(PointF) * length);
6340         if (!real_positions)
6341         {
6342             GdipFree(pti);
6343             return OutOfMemory;
6344         }
6345
6346         memcpy(real_positions, positions, sizeof(PointF) * length);
6347
6348         transform_and_round_points(graphics, pti, real_positions, length);
6349
6350         GdipFree(real_positions);
6351     }
6352
6353     get_font_hfont(graphics, font, &hfont);
6354
6355     hdc = CreateCompatibleDC(0);
6356     SelectObject(hdc, hfont);
6357
6358     /* Get the boundaries of the text to be drawn */
6359     for (i=0; i<length; i++)
6360     {
6361         DWORD glyphsize;
6362         int left, top, right, bottom;
6363
6364         glyphsize = GetGlyphOutlineW(hdc, text[i], ggo_flags,
6365             &glyphmetrics, 0, NULL, &identity);
6366
6367         if (glyphsize == GDI_ERROR)
6368         {
6369             ERR("GetGlyphOutlineW failed\n");
6370             GdipFree(pti);
6371             DeleteDC(hdc);
6372             DeleteObject(hfont);
6373             return GenericError;
6374         }
6375
6376         if (glyphsize > max_glyphsize)
6377             max_glyphsize = glyphsize;
6378
6379         left = pti[i].x + glyphmetrics.gmptGlyphOrigin.x;
6380         top = pti[i].y - glyphmetrics.gmptGlyphOrigin.y;
6381         right = pti[i].x + glyphmetrics.gmptGlyphOrigin.x + glyphmetrics.gmBlackBoxX;
6382         bottom = pti[i].y - glyphmetrics.gmptGlyphOrigin.y + glyphmetrics.gmBlackBoxY;
6383
6384         if (left < min_x) min_x = left;
6385         if (top < min_y) min_y = top;
6386         if (right > max_x) max_x = right;
6387         if (bottom > max_y) max_y = bottom;
6388
6389         if (i+1 < length && (flags & DriverStringOptionsRealizedAdvance) == DriverStringOptionsRealizedAdvance)
6390         {
6391             pti[i+1].x = pti[i].x + glyphmetrics.gmCellIncX;
6392             pti[i+1].y = pti[i].y + glyphmetrics.gmCellIncY;
6393         }
6394     }
6395
6396     glyph_mask = GdipAlloc(max_glyphsize);
6397     text_mask = GdipAlloc((max_x - min_x) * (max_y - min_y));
6398     text_mask_stride = max_x - min_x;
6399
6400     if (!(glyph_mask && text_mask))
6401     {
6402         GdipFree(glyph_mask);
6403         GdipFree(text_mask);
6404         GdipFree(pti);
6405         DeleteDC(hdc);
6406         DeleteObject(hfont);
6407         return OutOfMemory;
6408     }
6409
6410     /* Generate a mask for the text */
6411     for (i=0; i<length; i++)
6412     {
6413         int left, top, stride;
6414
6415         GetGlyphOutlineW(hdc, text[i], ggo_flags,
6416             &glyphmetrics, max_glyphsize, glyph_mask, &identity);
6417
6418         left = pti[i].x + glyphmetrics.gmptGlyphOrigin.x;
6419         top = pti[i].y - glyphmetrics.gmptGlyphOrigin.y;
6420         stride = (glyphmetrics.gmBlackBoxX + 3) & (~3);
6421
6422         for (y=0; y<glyphmetrics.gmBlackBoxY; y++)
6423         {
6424             BYTE *glyph_val = glyph_mask + y * stride;
6425             BYTE *text_val = text_mask + (left - min_x) + (top - min_y + y) * text_mask_stride;
6426             for (x=0; x<glyphmetrics.gmBlackBoxX; x++)
6427             {
6428                 *text_val = min(64, *text_val + *glyph_val);
6429                 glyph_val++;
6430                 text_val++;
6431             }
6432         }
6433     }
6434
6435     GdipFree(pti);
6436     DeleteDC(hdc);
6437     DeleteObject(hfont);
6438     GdipFree(glyph_mask);
6439
6440     /* get the brush data */
6441     pixel_data = GdipAlloc(4 * (max_x - min_x) * (max_y - min_y));
6442     if (!pixel_data)
6443     {
6444         GdipFree(text_mask);
6445         return OutOfMemory;
6446     }
6447
6448     pixel_area.X = min_x;
6449     pixel_area.Y = min_y;
6450     pixel_area.Width = max_x - min_x;
6451     pixel_area.Height = max_y - min_y;
6452     pixel_data_stride = pixel_area.Width * 4;
6453
6454     stat = brush_fill_pixels(graphics, (GpBrush*)brush, (DWORD*)pixel_data, &pixel_area, pixel_area.Width);
6455     if (stat != Ok)
6456     {
6457         GdipFree(text_mask);
6458         GdipFree(pixel_data);
6459         return stat;
6460     }
6461
6462     /* multiply the brush data by the mask */
6463     for (y=0; y<pixel_area.Height; y++)
6464     {
6465         BYTE *text_val = text_mask + text_mask_stride * y;
6466         BYTE *pixel_val = pixel_data + pixel_data_stride * y + 3;
6467         for (x=0; x<pixel_area.Width; x++)
6468         {
6469             *pixel_val = (*pixel_val) * (*text_val) / 64;
6470             text_val++;
6471             pixel_val+=4;
6472         }
6473     }
6474
6475     GdipFree(text_mask);
6476
6477     /* draw the result */
6478     stat = alpha_blend_pixels(graphics, min_x, min_y, pixel_data, pixel_area.Width,
6479         pixel_area.Height, pixel_data_stride);
6480
6481     GdipFree(pixel_data);
6482
6483     return stat;
6484 }
6485
6486 /*****************************************************************************
6487  * GdipDrawDriverString [GDIPLUS.@]
6488  */
6489 GpStatus WINGDIPAPI GdipDrawDriverString(GpGraphics *graphics, GDIPCONST UINT16 *text, INT length,
6490                                          GDIPCONST GpFont *font, GDIPCONST GpBrush *brush,
6491                                          GDIPCONST PointF *positions, INT flags,
6492                                          GDIPCONST GpMatrix *matrix )
6493 {
6494     GpStatus stat=NotImplemented;
6495
6496     TRACE("(%p %s %p %p %p %d %p)\n", graphics, debugstr_wn(text, length), font, brush, positions, flags, matrix);
6497
6498     if (!graphics || !text || !font || !brush || !positions)
6499         return InvalidParameter;
6500
6501     if (length == -1)
6502         length = strlenW(text);
6503
6504     if (graphics->hdc &&
6505         ((flags & DriverStringOptionsRealizedAdvance) || length <= 1) &&
6506         brush->bt == BrushTypeSolidColor &&
6507         (((GpSolidFill*)brush)->color & 0xff000000) == 0xff000000)
6508         stat = GDI32_GdipDrawDriverString(graphics, text, length, font, brush,
6509             positions, flags, matrix);
6510
6511     if (stat == NotImplemented)
6512         stat = SOFTWARE_GdipDrawDriverString(graphics, text, length, font, brush,
6513             positions, flags, matrix);
6514
6515     return stat;
6516 }
6517
6518 GpStatus WINGDIPAPI GdipRecordMetafileStream(IStream *stream, HDC hdc, EmfType type, GDIPCONST GpRect *frameRect,
6519                                         MetafileFrameUnit frameUnit, GDIPCONST WCHAR *desc, GpMetafile **metafile)
6520 {
6521     FIXME("(%p %p %d %p %d %p %p): stub\n", stream, hdc, type, frameRect, frameUnit, desc, metafile);
6522     return NotImplemented;
6523 }
6524
6525 /*****************************************************************************
6526  * GdipIsVisibleClipEmpty [GDIPLUS.@]
6527  */
6528 GpStatus WINGDIPAPI GdipIsVisibleClipEmpty(GpGraphics *graphics, BOOL *res)
6529 {
6530     GpStatus stat;
6531     GpRegion* rgn;
6532
6533     TRACE("(%p, %p)\n", graphics, res);
6534
6535     if((stat = GdipCreateRegion(&rgn)) != Ok)
6536         return stat;
6537
6538     if((stat = get_visible_clip_region(graphics, rgn)) != Ok)
6539         goto cleanup;
6540
6541     stat = GdipIsEmptyRegion(rgn, graphics, res);
6542
6543 cleanup:
6544     GdipDeleteRegion(rgn);
6545     return stat;
6546 }
6547
6548 GpStatus WINGDIPAPI GdipResetPageTransform(GpGraphics *graphics)
6549 {
6550     static int calls;
6551
6552     TRACE("(%p) stub\n", graphics);
6553
6554     if(!(calls++))
6555         FIXME("not implemented\n");
6556
6557     return NotImplemented;
6558 }