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