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