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