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 BOOL 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 = TRUE;
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             BOOL seen_start = FALSE, seen_end = FALSE, seen_center = FALSE;
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 = TRUE;
1378                     start_center_line ^= 1;
1379                 }
1380                 if (!seen_end && yf >= end_point.Y)
1381                 {
1382                     seen_end = TRUE;
1383                     end_center_line ^= 1;
1384                 }
1385                 if (!seen_center && yf >= center_point.Y)
1386                 {
1387                     seen_center = TRUE;
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
2785     /* Ensure source width/height is positive */
2786     if (srcwidth < 0)
2787     {
2788         GpPointF tmp = ptf[1];
2789         srcx = srcx + srcwidth;
2790         srcwidth = -srcwidth;
2791         ptf[2].X = ptf[2].X + ptf[1].X - ptf[0].X;
2792         ptf[2].Y = ptf[2].Y + ptf[1].Y - ptf[0].Y;
2793         ptf[1] = ptf[0];
2794         ptf[0] = tmp;
2795     }
2796
2797     if (srcheight < 0)
2798     {
2799         GpPointF tmp = ptf[2];
2800         srcy = srcy + srcheight;
2801         srcheight = -srcheight;
2802         ptf[1].X = ptf[1].X + ptf[2].X - ptf[0].X;
2803         ptf[1].Y = ptf[1].Y + ptf[2].Y - ptf[0].Y;
2804         ptf[2] = ptf[0];
2805         ptf[0] = tmp;
2806     }
2807
2808     ptf[3].X = ptf[2].X + ptf[1].X - ptf[0].X;
2809     ptf[3].Y = ptf[2].Y + ptf[1].Y - ptf[0].Y;
2810     if (!srcwidth || !srcheight || (ptf[3].X == ptf[0].X && ptf[3].Y == ptf[0].Y))
2811         return Ok;
2812     transform_and_round_points(graphics, pti, ptf, 4);
2813
2814     TRACE("%s %s %s %s\n", wine_dbgstr_point(&pti[0]), wine_dbgstr_point(&pti[1]),
2815         wine_dbgstr_point(&pti[2]), wine_dbgstr_point(&pti[3]));
2816
2817     srcx = units_to_pixels(srcx, srcUnit, image->xres);
2818     srcy = units_to_pixels(srcy, srcUnit, image->yres);
2819     srcwidth = units_to_pixels(srcwidth, srcUnit, image->xres);
2820     srcheight = units_to_pixels(srcheight, srcUnit, image->yres);
2821     TRACE("src pixels: %f,%f %fx%f\n", srcx, srcy, srcwidth, srcheight);
2822
2823     if (image->picture)
2824     {
2825         if (!graphics->hdc)
2826         {
2827             FIXME("graphics object has no HDC\n");
2828         }
2829
2830         if(IPicture_Render(image->picture, graphics->hdc,
2831             pti[0].x, pti[0].y, pti[1].x - pti[0].x, pti[2].y - pti[0].y,
2832             srcx, srcy, srcwidth, srcheight, NULL) != S_OK)
2833         {
2834             if(callback)
2835                 callback(callbackData);
2836             return GenericError;
2837         }
2838     }
2839     else if (image->type == ImageTypeBitmap)
2840     {
2841         GpBitmap* bitmap = (GpBitmap*)image;
2842         BOOL use_software = FALSE;
2843
2844         TRACE("graphics: %.2fx%.2f dpi, fmt %#x, scale %f, image: %.2fx%.2f dpi, fmt %#x, color %08x\n",
2845             graphics->xres, graphics->yres,
2846             graphics->image && graphics->image->type == ImageTypeBitmap ? ((GpBitmap *)graphics->image)->format : 0,
2847             graphics->scale, image->xres, image->yres, bitmap->format,
2848             imageAttributes ? imageAttributes->outside_color : 0);
2849
2850         if (imageAttributes || graphics->alpha_hdc ||
2851             (graphics->image && graphics->image->type == ImageTypeBitmap) ||
2852             ptf[1].Y != ptf[0].Y || ptf[2].X != ptf[0].X ||
2853             ptf[1].X - ptf[0].X != srcwidth || ptf[2].Y - ptf[0].Y != srcheight ||
2854             srcx < 0 || srcy < 0 ||
2855             srcx + srcwidth > bitmap->width || srcy + srcheight > bitmap->height)
2856             use_software = TRUE;
2857
2858         if (use_software)
2859         {
2860             RECT dst_area;
2861             GpRectF graphics_bounds;
2862             GpRect src_area;
2863             int i, x, y, src_stride, dst_stride;
2864             GpMatrix dst_to_src;
2865             REAL m11, m12, m21, m22, mdx, mdy;
2866             LPBYTE src_data, dst_data;
2867             BitmapData lockeddata;
2868             InterpolationMode interpolation = graphics->interpolation;
2869             PixelOffsetMode offset_mode = graphics->pixeloffset;
2870             GpPointF dst_to_src_points[3] = {{0.0, 0.0}, {1.0, 0.0}, {0.0, 1.0}};
2871             REAL x_dx, x_dy, y_dx, y_dy;
2872             static const GpImageAttributes defaultImageAttributes = {WrapModeClamp, 0, FALSE};
2873
2874             if (!imageAttributes)
2875                 imageAttributes = &defaultImageAttributes;
2876
2877             dst_area.left = dst_area.right = pti[0].x;
2878             dst_area.top = dst_area.bottom = pti[0].y;
2879             for (i=1; i<4; i++)
2880             {
2881                 if (dst_area.left > pti[i].x) dst_area.left = pti[i].x;
2882                 if (dst_area.right < pti[i].x) dst_area.right = pti[i].x;
2883                 if (dst_area.top > pti[i].y) dst_area.top = pti[i].y;
2884                 if (dst_area.bottom < pti[i].y) dst_area.bottom = pti[i].y;
2885             }
2886
2887             stat = get_graphics_bounds(graphics, &graphics_bounds);
2888             if (stat != Ok) return stat;
2889
2890             if (graphics_bounds.X > dst_area.left) dst_area.left = floorf(graphics_bounds.X);
2891             if (graphics_bounds.Y > dst_area.top) dst_area.top = floorf(graphics_bounds.Y);
2892             if (graphics_bounds.X + graphics_bounds.Width < dst_area.right) dst_area.right = ceilf(graphics_bounds.X + graphics_bounds.Width);
2893             if (graphics_bounds.Y + graphics_bounds.Height < dst_area.bottom) dst_area.bottom = ceilf(graphics_bounds.Y + graphics_bounds.Height);
2894
2895             TRACE("dst_area: %s\n", wine_dbgstr_rect(&dst_area));
2896
2897             if (IsRectEmpty(&dst_area)) return Ok;
2898
2899             m11 = (ptf[1].X - ptf[0].X) / srcwidth;
2900             m21 = (ptf[2].X - ptf[0].X) / srcheight;
2901             mdx = ptf[0].X - m11 * srcx - m21 * srcy;
2902             m12 = (ptf[1].Y - ptf[0].Y) / srcwidth;
2903             m22 = (ptf[2].Y - ptf[0].Y) / srcheight;
2904             mdy = ptf[0].Y - m12 * srcx - m22 * srcy;
2905
2906             GdipSetMatrixElements(&dst_to_src, m11, m12, m21, m22, mdx, mdy);
2907
2908             stat = GdipInvertMatrix(&dst_to_src);
2909             if (stat != Ok) return stat;
2910
2911             dst_data = GdipAlloc(sizeof(ARGB) * (dst_area.right - dst_area.left) * (dst_area.bottom - dst_area.top));
2912             if (!dst_data) return OutOfMemory;
2913
2914             dst_stride = sizeof(ARGB) * (dst_area.right - dst_area.left);
2915
2916             get_bitmap_sample_size(interpolation, imageAttributes->wrap,
2917                 bitmap, srcx, srcy, srcwidth, srcheight, &src_area);
2918
2919             TRACE("src_area: %d x %d\n", src_area.Width, src_area.Height);
2920
2921             src_data = GdipAlloc(sizeof(ARGB) * src_area.Width * src_area.Height);
2922             if (!src_data)
2923             {
2924                 GdipFree(dst_data);
2925                 return OutOfMemory;
2926             }
2927             src_stride = sizeof(ARGB) * src_area.Width;
2928
2929             /* Read the bits we need from the source bitmap into an ARGB buffer. */
2930             lockeddata.Width = src_area.Width;
2931             lockeddata.Height = src_area.Height;
2932             lockeddata.Stride = src_stride;
2933             lockeddata.PixelFormat = PixelFormat32bppARGB;
2934             lockeddata.Scan0 = src_data;
2935
2936             stat = GdipBitmapLockBits(bitmap, &src_area, ImageLockModeRead|ImageLockModeUserInputBuf,
2937                 PixelFormat32bppARGB, &lockeddata);
2938
2939             if (stat == Ok)
2940                 stat = GdipBitmapUnlockBits(bitmap, &lockeddata);
2941
2942             if (stat != Ok)
2943             {
2944                 GdipFree(src_data);
2945                 GdipFree(dst_data);
2946                 return stat;
2947             }
2948
2949             apply_image_attributes(imageAttributes, src_data,
2950                 src_area.Width, src_area.Height,
2951                 src_stride, ColorAdjustTypeBitmap);
2952
2953             /* Transform the bits as needed to the destination. */
2954             GdipTransformMatrixPoints(&dst_to_src, dst_to_src_points, 3);
2955
2956             x_dx = dst_to_src_points[1].X - dst_to_src_points[0].X;
2957             x_dy = dst_to_src_points[1].Y - dst_to_src_points[0].Y;
2958             y_dx = dst_to_src_points[2].X - dst_to_src_points[0].X;
2959             y_dy = dst_to_src_points[2].Y - dst_to_src_points[0].Y;
2960
2961             for (x=dst_area.left; x<dst_area.right; x++)
2962             {
2963                 for (y=dst_area.top; y<dst_area.bottom; y++)
2964                 {
2965                     GpPointF src_pointf;
2966                     ARGB *dst_color;
2967
2968                     src_pointf.X = dst_to_src_points[0].X + x * x_dx + y * y_dx;
2969                     src_pointf.Y = dst_to_src_points[0].Y + x * x_dy + y * y_dy;
2970
2971                     dst_color = (ARGB*)(dst_data + dst_stride * (y - dst_area.top) + sizeof(ARGB) * (x - dst_area.left));
2972
2973                     if (src_pointf.X >= srcx && src_pointf.X < srcx + srcwidth && src_pointf.Y >= srcy && src_pointf.Y < srcy+srcheight)
2974                         *dst_color = resample_bitmap_pixel(&src_area, src_data, bitmap->width, bitmap->height, &src_pointf,
2975                                                            imageAttributes, interpolation, offset_mode);
2976                     else
2977                         *dst_color = 0;
2978                 }
2979             }
2980
2981             GdipFree(src_data);
2982
2983             stat = alpha_blend_pixels(graphics, dst_area.left, dst_area.top,
2984                 dst_data, dst_area.right - dst_area.left, dst_area.bottom - dst_area.top, dst_stride);
2985
2986             GdipFree(dst_data);
2987
2988             return stat;
2989         }
2990         else
2991         {
2992             HDC hdc;
2993             BOOL temp_hdc = FALSE, temp_bitmap = FALSE;
2994             HBITMAP hbitmap, old_hbm=NULL;
2995
2996             if (!(bitmap->format == PixelFormat16bppRGB555 ||
2997                   bitmap->format == PixelFormat24bppRGB ||
2998                   bitmap->format == PixelFormat32bppRGB ||
2999                   bitmap->format == PixelFormat32bppPARGB))
3000             {
3001                 BITMAPINFOHEADER bih;
3002                 BYTE *temp_bits;
3003                 PixelFormat dst_format;
3004
3005                 /* we can't draw a bitmap of this format directly */
3006                 hdc = CreateCompatibleDC(0);
3007                 temp_hdc = TRUE;
3008                 temp_bitmap = TRUE;
3009
3010                 bih.biSize = sizeof(BITMAPINFOHEADER);
3011                 bih.biWidth = bitmap->width;
3012                 bih.biHeight = -bitmap->height;
3013                 bih.biPlanes = 1;
3014                 bih.biBitCount = 32;
3015                 bih.biCompression = BI_RGB;
3016                 bih.biSizeImage = 0;
3017                 bih.biXPelsPerMeter = 0;
3018                 bih.biYPelsPerMeter = 0;
3019                 bih.biClrUsed = 0;
3020                 bih.biClrImportant = 0;
3021
3022                 hbitmap = CreateDIBSection(hdc, (BITMAPINFO*)&bih, DIB_RGB_COLORS,
3023                     (void**)&temp_bits, NULL, 0);
3024
3025                 if (bitmap->format & (PixelFormatAlpha|PixelFormatPAlpha))
3026                     dst_format = PixelFormat32bppPARGB;
3027                 else
3028                     dst_format = PixelFormat32bppRGB;
3029
3030                 convert_pixels(bitmap->width, bitmap->height,
3031                     bitmap->width*4, temp_bits, dst_format,
3032                     bitmap->stride, bitmap->bits, bitmap->format,
3033                     bitmap->image.palette);
3034             }
3035             else
3036             {
3037                 if (bitmap->hbitmap)
3038                     hbitmap = bitmap->hbitmap;
3039                 else
3040                 {
3041                     GdipCreateHBITMAPFromBitmap(bitmap, &hbitmap, 0);
3042                     temp_bitmap = TRUE;
3043                 }
3044
3045                 hdc = bitmap->hdc;
3046                 temp_hdc = (hdc == 0);
3047             }
3048
3049             if (temp_hdc)
3050             {
3051                 if (!hdc) hdc = CreateCompatibleDC(0);
3052                 old_hbm = SelectObject(hdc, hbitmap);
3053             }
3054
3055             if (bitmap->format & (PixelFormatAlpha|PixelFormatPAlpha))
3056             {
3057                 gdi_alpha_blend(graphics, pti[0].x, pti[0].y, pti[1].x - pti[0].x, pti[2].y - pti[0].y,
3058                                 hdc, srcx, srcy, srcwidth, srcheight);
3059             }
3060             else
3061             {
3062                 StretchBlt(graphics->hdc, pti[0].x, pti[0].y, pti[1].x-pti[0].x, pti[2].y-pti[0].y,
3063                     hdc, srcx, srcy, srcwidth, srcheight, SRCCOPY);
3064             }
3065
3066             if (temp_hdc)
3067             {
3068                 SelectObject(hdc, old_hbm);
3069                 DeleteDC(hdc);
3070             }
3071
3072             if (temp_bitmap)
3073                 DeleteObject(hbitmap);
3074         }
3075     }
3076     else if (image->type == ImageTypeMetafile && ((GpMetafile*)image)->hemf)
3077     {
3078         GpRectF rc;
3079
3080         rc.X = srcx;
3081         rc.Y = srcy;
3082         rc.Width = srcwidth;
3083         rc.Height = srcheight;
3084
3085         return GdipEnumerateMetafileSrcRectDestPoints(graphics, (GpMetafile*)image,
3086             points, count, &rc, srcUnit, play_metafile_proc, image, imageAttributes);
3087     }
3088     else
3089     {
3090         WARN("GpImage with nothing we can draw (metafile in wrong state?)\n");
3091         return InvalidParameter;
3092     }
3093
3094     return Ok;
3095 }
3096
3097 GpStatus WINGDIPAPI GdipDrawImagePointsRectI(GpGraphics *graphics, GpImage *image,
3098      GDIPCONST GpPoint *points, INT count, INT srcx, INT srcy, INT srcwidth,
3099      INT srcheight, GpUnit srcUnit, GDIPCONST GpImageAttributes* imageAttributes,
3100      DrawImageAbort callback, VOID * callbackData)
3101 {
3102     GpPointF pointsF[3];
3103     INT i;
3104
3105     TRACE("(%p, %p, %p, %d, %d, %d, %d, %d, %d, %p, %p, %p)\n", graphics, image, points, count,
3106           srcx, srcy, srcwidth, srcheight, srcUnit, imageAttributes, callback,
3107           callbackData);
3108
3109     if(!points || count!=3)
3110         return InvalidParameter;
3111
3112     for(i = 0; i < count; i++){
3113         pointsF[i].X = (REAL)points[i].X;
3114         pointsF[i].Y = (REAL)points[i].Y;
3115     }
3116
3117     return GdipDrawImagePointsRect(graphics, image, pointsF, count, (REAL)srcx, (REAL)srcy,
3118                                    (REAL)srcwidth, (REAL)srcheight, srcUnit, imageAttributes,
3119                                    callback, callbackData);
3120 }
3121
3122 GpStatus WINGDIPAPI GdipDrawImageRectRect(GpGraphics *graphics, GpImage *image,
3123     REAL dstx, REAL dsty, REAL dstwidth, REAL dstheight, REAL srcx, REAL srcy,
3124     REAL srcwidth, REAL srcheight, GpUnit srcUnit,
3125     GDIPCONST GpImageAttributes* imageattr, DrawImageAbort callback,
3126     VOID * callbackData)
3127 {
3128     GpPointF points[3];
3129
3130     TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %d, %p, %p, %p)\n",
3131           graphics, image, dstx, dsty, dstwidth, dstheight, srcx, srcy,
3132           srcwidth, srcheight, srcUnit, imageattr, callback, callbackData);
3133
3134     points[0].X = dstx;
3135     points[0].Y = dsty;
3136     points[1].X = dstx + dstwidth;
3137     points[1].Y = dsty;
3138     points[2].X = dstx;
3139     points[2].Y = dsty + dstheight;
3140
3141     return GdipDrawImagePointsRect(graphics, image, points, 3, srcx, srcy,
3142                srcwidth, srcheight, srcUnit, imageattr, callback, callbackData);
3143 }
3144
3145 GpStatus WINGDIPAPI GdipDrawImageRectRectI(GpGraphics *graphics, GpImage *image,
3146         INT dstx, INT dsty, INT dstwidth, INT dstheight, INT srcx, INT srcy,
3147         INT srcwidth, INT srcheight, GpUnit srcUnit,
3148         GDIPCONST GpImageAttributes* imageAttributes, DrawImageAbort callback,
3149         VOID * callbackData)
3150 {
3151     GpPointF points[3];
3152
3153     TRACE("(%p, %p, %d, %d, %d, %d, %d, %d, %d, %d, %d, %p, %p, %p)\n",
3154           graphics, image, dstx, dsty, dstwidth, dstheight, srcx, srcy,
3155           srcwidth, srcheight, srcUnit, imageAttributes, callback, callbackData);
3156
3157     points[0].X = dstx;
3158     points[0].Y = dsty;
3159     points[1].X = dstx + dstwidth;
3160     points[1].Y = dsty;
3161     points[2].X = dstx;
3162     points[2].Y = dsty + dstheight;
3163
3164     return GdipDrawImagePointsRect(graphics, image, points, 3, srcx, srcy,
3165                srcwidth, srcheight, srcUnit, imageAttributes, callback, callbackData);
3166 }
3167
3168 GpStatus WINGDIPAPI GdipDrawImageRect(GpGraphics *graphics, GpImage *image,
3169     REAL x, REAL y, REAL width, REAL height)
3170 {
3171     RectF bounds;
3172     GpUnit unit;
3173     GpStatus ret;
3174
3175     TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f)\n", graphics, image, x, y, width, height);
3176
3177     if(!graphics || !image)
3178         return InvalidParameter;
3179
3180     ret = GdipGetImageBounds(image, &bounds, &unit);
3181     if(ret != Ok)
3182         return ret;
3183
3184     return GdipDrawImageRectRect(graphics, image, x, y, width, height,
3185                                  bounds.X, bounds.Y, bounds.Width, bounds.Height,
3186                                  unit, NULL, NULL, NULL);
3187 }
3188
3189 GpStatus WINGDIPAPI GdipDrawImageRectI(GpGraphics *graphics, GpImage *image,
3190     INT x, INT y, INT width, INT height)
3191 {
3192     TRACE("(%p, %p, %d, %d, %d, %d)\n", graphics, image, x, y, width, height);
3193
3194     return GdipDrawImageRect(graphics, image, (REAL)x, (REAL)y, (REAL)width, (REAL)height);
3195 }
3196
3197 GpStatus WINGDIPAPI GdipDrawLine(GpGraphics *graphics, GpPen *pen, REAL x1,
3198     REAL y1, REAL x2, REAL y2)
3199 {
3200     GpPointF pt[2];
3201
3202     TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f)\n", graphics, pen, x1, y1, x2, y2);
3203
3204     pt[0].X = x1;
3205     pt[0].Y = y1;
3206     pt[1].X = x2;
3207     pt[1].Y = y2;
3208     return GdipDrawLines(graphics, pen, pt, 2);
3209 }
3210
3211 GpStatus WINGDIPAPI GdipDrawLineI(GpGraphics *graphics, GpPen *pen, INT x1,
3212     INT y1, INT x2, INT y2)
3213 {
3214     TRACE("(%p, %p, %d, %d, %d, %d)\n", graphics, pen, x1, y1, x2, y2);
3215
3216     return GdipDrawLine(graphics, pen, (REAL)x1, (REAL)y1, (REAL)x2, (REAL)y2);
3217 }
3218
3219 GpStatus WINGDIPAPI GdipDrawLines(GpGraphics *graphics, GpPen *pen, GDIPCONST
3220     GpPointF *points, INT count)
3221 {
3222     GpStatus status;
3223     GpPath *path;
3224
3225     TRACE("(%p, %p, %p, %d)\n", graphics, pen, points, count);
3226
3227     if(!pen || !graphics || (count < 2))
3228         return InvalidParameter;
3229
3230     if(graphics->busy)
3231         return ObjectBusy;
3232
3233     status = GdipCreatePath(FillModeAlternate, &path);
3234     if (status != Ok) return status;
3235
3236     status = GdipAddPathLine2(path, points, count);
3237     if (status == Ok)
3238         status = GdipDrawPath(graphics, pen, path);
3239
3240     GdipDeletePath(path);
3241     return status;
3242 }
3243
3244 GpStatus WINGDIPAPI GdipDrawLinesI(GpGraphics *graphics, GpPen *pen, GDIPCONST
3245     GpPoint *points, INT count)
3246 {
3247     GpStatus retval;
3248     GpPointF *ptf;
3249     int i;
3250
3251     TRACE("(%p, %p, %p, %d)\n", graphics, pen, points, count);
3252
3253     ptf = GdipAlloc(count * sizeof(GpPointF));
3254     if(!ptf) return OutOfMemory;
3255
3256     for(i = 0; i < count; i ++){
3257         ptf[i].X = (REAL) points[i].X;
3258         ptf[i].Y = (REAL) points[i].Y;
3259     }
3260
3261     retval = GdipDrawLines(graphics, pen, ptf, count);
3262
3263     GdipFree(ptf);
3264     return retval;
3265 }
3266
3267 GpStatus WINGDIPAPI GdipDrawPath(GpGraphics *graphics, GpPen *pen, GpPath *path)
3268 {
3269     INT save_state;
3270     GpStatus retval;
3271     HRGN hrgn=NULL;
3272
3273     TRACE("(%p, %p, %p)\n", graphics, pen, path);
3274
3275     if(!pen || !graphics)
3276         return InvalidParameter;
3277
3278     if(graphics->busy)
3279         return ObjectBusy;
3280
3281     if (!graphics->hdc)
3282     {
3283         FIXME("graphics object has no HDC\n");
3284         return Ok;
3285     }
3286
3287     save_state = prepare_dc(graphics, pen);
3288
3289     retval = get_clip_hrgn(graphics, &hrgn);
3290
3291     if (retval != Ok)
3292         goto end;
3293
3294     if (hrgn)
3295         ExtSelectClipRgn(graphics->hdc, hrgn, RGN_AND);
3296
3297     retval = draw_poly(graphics, pen, path->pathdata.Points,
3298                        path->pathdata.Types, path->pathdata.Count, TRUE);
3299
3300 end:
3301     restore_dc(graphics, save_state);
3302     DeleteObject(hrgn);
3303
3304     return retval;
3305 }
3306
3307 GpStatus WINGDIPAPI GdipDrawPie(GpGraphics *graphics, GpPen *pen, REAL x,
3308     REAL y, REAL width, REAL height, REAL startAngle, REAL sweepAngle)
3309 {
3310     GpStatus status;
3311     GpPath *path;
3312
3313     TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f)\n", graphics, pen, x, y,
3314             width, height, startAngle, sweepAngle);
3315
3316     if(!graphics || !pen)
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 = GdipAddPathPie(path, x, y, width, height, startAngle, sweepAngle);
3326     if (status == Ok)
3327         status = GdipDrawPath(graphics, pen, path);
3328
3329     GdipDeletePath(path);
3330     return status;
3331 }
3332
3333 GpStatus WINGDIPAPI GdipDrawPieI(GpGraphics *graphics, GpPen *pen, INT x,
3334     INT y, INT width, INT height, REAL startAngle, REAL sweepAngle)
3335 {
3336     TRACE("(%p, %p, %d, %d, %d, %d, %.2f, %.2f)\n", graphics, pen, x, y,
3337             width, height, startAngle, sweepAngle);
3338
3339     return GdipDrawPie(graphics,pen,(REAL)x,(REAL)y,(REAL)width,(REAL)height,startAngle,sweepAngle);
3340 }
3341
3342 GpStatus WINGDIPAPI GdipDrawRectangle(GpGraphics *graphics, GpPen *pen, REAL x,
3343     REAL y, REAL width, REAL height)
3344 {
3345     GpStatus status;
3346     GpPath *path;
3347
3348     TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f)\n", graphics, pen, x, y, width, height);
3349
3350     if(!pen || !graphics)
3351         return InvalidParameter;
3352
3353     if(graphics->busy)
3354         return ObjectBusy;
3355
3356     status = GdipCreatePath(FillModeAlternate, &path);
3357     if (status != Ok) return status;
3358
3359     status = GdipAddPathRectangle(path, x, y, width, height);
3360     if (status == Ok)
3361         status = GdipDrawPath(graphics, pen, path);
3362
3363     GdipDeletePath(path);
3364     return status;
3365 }
3366
3367 GpStatus WINGDIPAPI GdipDrawRectangleI(GpGraphics *graphics, GpPen *pen, INT x,
3368     INT y, INT width, INT height)
3369 {
3370     TRACE("(%p, %p, %d, %d, %d, %d)\n", graphics, pen, x, y, width, height);
3371
3372     return GdipDrawRectangle(graphics,pen,(REAL)x,(REAL)y,(REAL)width,(REAL)height);
3373 }
3374
3375 GpStatus WINGDIPAPI GdipDrawRectangles(GpGraphics *graphics, GpPen *pen,
3376     GDIPCONST GpRectF* rects, INT count)
3377 {
3378     GpStatus status;
3379     GpPath *path;
3380
3381     TRACE("(%p, %p, %p, %d)\n", graphics, pen, rects, count);
3382
3383     if(!graphics || !pen || !rects || count < 1)
3384         return InvalidParameter;
3385
3386     if(graphics->busy)
3387         return ObjectBusy;
3388
3389     status = GdipCreatePath(FillModeAlternate, &path);
3390     if (status != Ok) return status;
3391
3392     status = GdipAddPathRectangles(path, rects, count);
3393     if (status == Ok)
3394         status = GdipDrawPath(graphics, pen, path);
3395
3396     GdipDeletePath(path);
3397     return status;
3398 }
3399
3400 GpStatus WINGDIPAPI GdipDrawRectanglesI(GpGraphics *graphics, GpPen *pen,
3401     GDIPCONST GpRect* rects, INT count)
3402 {
3403     GpRectF *rectsF;
3404     GpStatus ret;
3405     INT i;
3406
3407     TRACE("(%p, %p, %p, %d)\n", graphics, pen, rects, count);
3408
3409     if(!rects || count<=0)
3410         return InvalidParameter;
3411
3412     rectsF = GdipAlloc(sizeof(GpRectF) * count);
3413     if(!rectsF)
3414         return OutOfMemory;
3415
3416     for(i = 0;i < count;i++){
3417         rectsF[i].X      = (REAL)rects[i].X;
3418         rectsF[i].Y      = (REAL)rects[i].Y;
3419         rectsF[i].Width  = (REAL)rects[i].Width;
3420         rectsF[i].Height = (REAL)rects[i].Height;
3421     }
3422
3423     ret = GdipDrawRectangles(graphics, pen, rectsF, count);
3424     GdipFree(rectsF);
3425
3426     return ret;
3427 }
3428
3429 GpStatus WINGDIPAPI GdipFillClosedCurve2(GpGraphics *graphics, GpBrush *brush,
3430     GDIPCONST GpPointF *points, INT count, REAL tension, GpFillMode fill)
3431 {
3432     GpPath *path;
3433     GpStatus status;
3434
3435     TRACE("(%p, %p, %p, %d, %.2f, %d)\n", graphics, brush, points,
3436             count, tension, fill);
3437
3438     if(!graphics || !brush || !points)
3439         return InvalidParameter;
3440
3441     if(graphics->busy)
3442         return ObjectBusy;
3443
3444     if(count == 1)    /* Do nothing */
3445         return Ok;
3446
3447     status = GdipCreatePath(fill, &path);
3448     if (status != Ok) return status;
3449
3450     status = GdipAddPathClosedCurve2(path, points, count, tension);
3451     if (status == Ok)
3452         status = GdipFillPath(graphics, brush, path);
3453
3454     GdipDeletePath(path);
3455     return status;
3456 }
3457
3458 GpStatus WINGDIPAPI GdipFillClosedCurve2I(GpGraphics *graphics, GpBrush *brush,
3459     GDIPCONST GpPoint *points, INT count, REAL tension, GpFillMode fill)
3460 {
3461     GpPointF *ptf;
3462     GpStatus stat;
3463     INT i;
3464
3465     TRACE("(%p, %p, %p, %d, %.2f, %d)\n", graphics, brush, points,
3466             count, tension, fill);
3467
3468     if(!points || count == 0)
3469         return InvalidParameter;
3470
3471     if(count == 1)    /* Do nothing */
3472         return Ok;
3473
3474     ptf = GdipAlloc(sizeof(GpPointF)*count);
3475     if(!ptf)
3476         return OutOfMemory;
3477
3478     for(i = 0;i < count;i++){
3479         ptf[i].X = (REAL)points[i].X;
3480         ptf[i].Y = (REAL)points[i].Y;
3481     }
3482
3483     stat = GdipFillClosedCurve2(graphics, brush, ptf, count, tension, fill);
3484
3485     GdipFree(ptf);
3486
3487     return stat;
3488 }
3489
3490 GpStatus WINGDIPAPI GdipFillClosedCurve(GpGraphics *graphics, GpBrush *brush,
3491     GDIPCONST GpPointF *points, INT count)
3492 {
3493     TRACE("(%p, %p, %p, %d)\n", graphics, brush, points, count);
3494     return GdipFillClosedCurve2(graphics, brush, points, count,
3495                0.5f, FillModeAlternate);
3496 }
3497
3498 GpStatus WINGDIPAPI GdipFillClosedCurveI(GpGraphics *graphics, GpBrush *brush,
3499     GDIPCONST GpPoint *points, INT count)
3500 {
3501     TRACE("(%p, %p, %p, %d)\n", graphics, brush, points, count);
3502     return GdipFillClosedCurve2I(graphics, brush, points, count,
3503                0.5f, FillModeAlternate);
3504 }
3505
3506 GpStatus WINGDIPAPI GdipFillEllipse(GpGraphics *graphics, GpBrush *brush, REAL x,
3507     REAL y, REAL width, REAL height)
3508 {
3509     GpStatus stat;
3510     GpPath *path;
3511
3512     TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f)\n", graphics, brush, x, y, width, height);
3513
3514     if(!graphics || !brush)
3515         return InvalidParameter;
3516
3517     if(graphics->busy)
3518         return ObjectBusy;
3519
3520     stat = GdipCreatePath(FillModeAlternate, &path);
3521
3522     if (stat == Ok)
3523     {
3524         stat = GdipAddPathEllipse(path, x, y, width, height);
3525
3526         if (stat == Ok)
3527             stat = GdipFillPath(graphics, brush, path);
3528
3529         GdipDeletePath(path);
3530     }
3531
3532     return stat;
3533 }
3534
3535 GpStatus WINGDIPAPI GdipFillEllipseI(GpGraphics *graphics, GpBrush *brush, INT x,
3536     INT y, INT width, INT height)
3537 {
3538     TRACE("(%p, %p, %d, %d, %d, %d)\n", graphics, brush, x, y, width, height);
3539
3540     return GdipFillEllipse(graphics,brush,(REAL)x,(REAL)y,(REAL)width,(REAL)height);
3541 }
3542
3543 static GpStatus GDI32_GdipFillPath(GpGraphics *graphics, GpBrush *brush, GpPath *path)
3544 {
3545     INT save_state;
3546     GpStatus retval;
3547     HRGN hrgn=NULL;
3548
3549     if(!graphics->hdc || !brush_can_fill_path(brush))
3550         return NotImplemented;
3551
3552     save_state = SaveDC(graphics->hdc);
3553     EndPath(graphics->hdc);
3554     SetPolyFillMode(graphics->hdc, (path->fill == FillModeAlternate ? ALTERNATE
3555                                                                     : WINDING));
3556
3557     retval = get_clip_hrgn(graphics, &hrgn);
3558
3559     if (retval != Ok)
3560         goto end;
3561
3562     if (hrgn)
3563         ExtSelectClipRgn(graphics->hdc, hrgn, RGN_AND);
3564
3565     BeginPath(graphics->hdc);
3566     retval = draw_poly(graphics, NULL, path->pathdata.Points,
3567                        path->pathdata.Types, path->pathdata.Count, FALSE);
3568
3569     if(retval != Ok)
3570         goto end;
3571
3572     EndPath(graphics->hdc);
3573     brush_fill_path(graphics, brush);
3574
3575     retval = Ok;
3576
3577 end:
3578     RestoreDC(graphics->hdc, save_state);
3579     DeleteObject(hrgn);
3580
3581     return retval;
3582 }
3583
3584 static GpStatus SOFTWARE_GdipFillPath(GpGraphics *graphics, GpBrush *brush, GpPath *path)
3585 {
3586     GpStatus stat;
3587     GpRegion *rgn;
3588
3589     if (!brush_can_fill_pixels(brush))
3590         return NotImplemented;
3591
3592     /* FIXME: This could probably be done more efficiently without regions. */
3593
3594     stat = GdipCreateRegionPath(path, &rgn);
3595
3596     if (stat == Ok)
3597     {
3598         stat = GdipFillRegion(graphics, brush, rgn);
3599
3600         GdipDeleteRegion(rgn);
3601     }
3602
3603     return stat;
3604 }
3605
3606 GpStatus WINGDIPAPI GdipFillPath(GpGraphics *graphics, GpBrush *brush, GpPath *path)
3607 {
3608     GpStatus stat = NotImplemented;
3609
3610     TRACE("(%p, %p, %p)\n", graphics, brush, path);
3611
3612     if(!brush || !graphics || !path)
3613         return InvalidParameter;
3614
3615     if(graphics->busy)
3616         return ObjectBusy;
3617
3618     if (!graphics->image && !graphics->alpha_hdc)
3619         stat = GDI32_GdipFillPath(graphics, brush, path);
3620
3621     if (stat == NotImplemented)
3622         stat = SOFTWARE_GdipFillPath(graphics, brush, path);
3623
3624     if (stat == NotImplemented)
3625     {
3626         FIXME("Not implemented for brushtype %i\n", brush->bt);
3627         stat = Ok;
3628     }
3629
3630     return stat;
3631 }
3632
3633 GpStatus WINGDIPAPI GdipFillPie(GpGraphics *graphics, GpBrush *brush, REAL x,
3634     REAL y, REAL width, REAL height, REAL startAngle, REAL sweepAngle)
3635 {
3636     GpStatus stat;
3637     GpPath *path;
3638
3639     TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f)\n",
3640             graphics, brush, x, y, width, height, startAngle, sweepAngle);
3641
3642     if(!graphics || !brush)
3643         return InvalidParameter;
3644
3645     if(graphics->busy)
3646         return ObjectBusy;
3647
3648     stat = GdipCreatePath(FillModeAlternate, &path);
3649
3650     if (stat == Ok)
3651     {
3652         stat = GdipAddPathPie(path, x, y, width, height, startAngle, sweepAngle);
3653
3654         if (stat == Ok)
3655             stat = GdipFillPath(graphics, brush, path);
3656
3657         GdipDeletePath(path);
3658     }
3659
3660     return stat;
3661 }
3662
3663 GpStatus WINGDIPAPI GdipFillPieI(GpGraphics *graphics, GpBrush *brush, INT x,
3664     INT y, INT width, INT height, REAL startAngle, REAL sweepAngle)
3665 {
3666     TRACE("(%p, %p, %d, %d, %d, %d, %.2f, %.2f)\n",
3667             graphics, brush, x, y, width, height, startAngle, sweepAngle);
3668
3669     return GdipFillPie(graphics,brush,(REAL)x,(REAL)y,(REAL)width,(REAL)height,startAngle,sweepAngle);
3670 }
3671
3672 GpStatus WINGDIPAPI GdipFillPolygon(GpGraphics *graphics, GpBrush *brush,
3673     GDIPCONST GpPointF *points, INT count, GpFillMode fillMode)
3674 {
3675     GpStatus stat;
3676     GpPath *path;
3677
3678     TRACE("(%p, %p, %p, %d, %d)\n", graphics, brush, points, count, fillMode);
3679
3680     if(!graphics || !brush || !points || !count)
3681         return InvalidParameter;
3682
3683     if(graphics->busy)
3684         return ObjectBusy;
3685
3686     stat = GdipCreatePath(fillMode, &path);
3687
3688     if (stat == Ok)
3689     {
3690         stat = GdipAddPathPolygon(path, points, count);
3691
3692         if (stat == Ok)
3693             stat = GdipFillPath(graphics, brush, path);
3694
3695         GdipDeletePath(path);
3696     }
3697
3698     return stat;
3699 }
3700
3701 GpStatus WINGDIPAPI GdipFillPolygonI(GpGraphics *graphics, GpBrush *brush,
3702     GDIPCONST GpPoint *points, INT count, GpFillMode fillMode)
3703 {
3704     GpStatus stat;
3705     GpPath *path;
3706
3707     TRACE("(%p, %p, %p, %d, %d)\n", graphics, brush, points, count, fillMode);
3708
3709     if(!graphics || !brush || !points || !count)
3710         return InvalidParameter;
3711
3712     if(graphics->busy)
3713         return ObjectBusy;
3714
3715     stat = GdipCreatePath(fillMode, &path);
3716
3717     if (stat == Ok)
3718     {
3719         stat = GdipAddPathPolygonI(path, points, count);
3720
3721         if (stat == Ok)
3722             stat = GdipFillPath(graphics, brush, path);
3723
3724         GdipDeletePath(path);
3725     }
3726
3727     return stat;
3728 }
3729
3730 GpStatus WINGDIPAPI GdipFillPolygon2(GpGraphics *graphics, GpBrush *brush,
3731     GDIPCONST GpPointF *points, INT count)
3732 {
3733     TRACE("(%p, %p, %p, %d)\n", graphics, brush, points, count);
3734
3735     return GdipFillPolygon(graphics, brush, points, count, FillModeAlternate);
3736 }
3737
3738 GpStatus WINGDIPAPI GdipFillPolygon2I(GpGraphics *graphics, GpBrush *brush,
3739     GDIPCONST GpPoint *points, INT count)
3740 {
3741     TRACE("(%p, %p, %p, %d)\n", graphics, brush, points, count);
3742
3743     return GdipFillPolygonI(graphics, brush, points, count, FillModeAlternate);
3744 }
3745
3746 GpStatus WINGDIPAPI GdipFillRectangle(GpGraphics *graphics, GpBrush *brush,
3747     REAL x, REAL y, REAL width, REAL height)
3748 {
3749     GpRectF rect;
3750
3751     TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f)\n", graphics, brush, x, y, width, height);
3752
3753     rect.X = x;
3754     rect.Y = y;
3755     rect.Width = width;
3756     rect.Height = height;
3757
3758     return GdipFillRectangles(graphics, brush, &rect, 1);
3759 }
3760
3761 GpStatus WINGDIPAPI GdipFillRectangleI(GpGraphics *graphics, GpBrush *brush,
3762     INT x, INT y, INT width, INT height)
3763 {
3764     GpRectF rect;
3765
3766     TRACE("(%p, %p, %d, %d, %d, %d)\n", graphics, brush, x, y, width, height);
3767
3768     rect.X = (REAL)x;
3769     rect.Y = (REAL)y;
3770     rect.Width = (REAL)width;
3771     rect.Height = (REAL)height;
3772
3773     return GdipFillRectangles(graphics, brush, &rect, 1);
3774 }
3775
3776 GpStatus WINGDIPAPI GdipFillRectangles(GpGraphics *graphics, GpBrush *brush, GDIPCONST GpRectF *rects,
3777     INT count)
3778 {
3779     GpStatus status;
3780     GpPath *path;
3781
3782     TRACE("(%p, %p, %p, %d)\n", graphics, brush, rects, count);
3783
3784     if(!graphics || !brush || !rects || count <= 0)
3785         return InvalidParameter;
3786
3787     if (graphics->image && graphics->image->type == ImageTypeMetafile)
3788     {
3789         status = METAFILE_FillRectangles((GpMetafile*)graphics->image, brush, rects, count);
3790         /* FIXME: Add gdi32 drawing. */
3791         return status;
3792     }
3793
3794     status = GdipCreatePath(FillModeAlternate, &path);
3795     if (status != Ok) return status;
3796
3797     status = GdipAddPathRectangles(path, rects, count);
3798     if (status == Ok)
3799         status = GdipFillPath(graphics, brush, path);
3800
3801     GdipDeletePath(path);
3802     return status;
3803 }
3804
3805 GpStatus WINGDIPAPI GdipFillRectanglesI(GpGraphics *graphics, GpBrush *brush, GDIPCONST GpRect *rects,
3806     INT count)
3807 {
3808     GpRectF *rectsF;
3809     GpStatus ret;
3810     INT i;
3811
3812     TRACE("(%p, %p, %p, %d)\n", graphics, brush, rects, count);
3813
3814     if(!rects || count <= 0)
3815         return InvalidParameter;
3816
3817     rectsF = GdipAlloc(sizeof(GpRectF)*count);
3818     if(!rectsF)
3819         return OutOfMemory;
3820
3821     for(i = 0; i < count; i++){
3822         rectsF[i].X      = (REAL)rects[i].X;
3823         rectsF[i].Y      = (REAL)rects[i].Y;
3824         rectsF[i].X      = (REAL)rects[i].Width;
3825         rectsF[i].Height = (REAL)rects[i].Height;
3826     }
3827
3828     ret = GdipFillRectangles(graphics,brush,rectsF,count);
3829     GdipFree(rectsF);
3830
3831     return ret;
3832 }
3833
3834 static GpStatus GDI32_GdipFillRegion(GpGraphics* graphics, GpBrush* brush,
3835     GpRegion* region)
3836 {
3837     INT save_state;
3838     GpStatus status;
3839     HRGN hrgn;
3840     RECT rc;
3841
3842     if(!graphics->hdc || !brush_can_fill_path(brush))
3843         return NotImplemented;
3844
3845     status = GdipGetRegionHRgn(region, graphics, &hrgn);
3846     if(status != Ok)
3847         return status;
3848
3849     save_state = SaveDC(graphics->hdc);
3850     EndPath(graphics->hdc);
3851
3852     ExtSelectClipRgn(graphics->hdc, hrgn, RGN_AND);
3853
3854     if (GetClipBox(graphics->hdc, &rc) != NULLREGION)
3855     {
3856         BeginPath(graphics->hdc);
3857         Rectangle(graphics->hdc, rc.left, rc.top, rc.right, rc.bottom);
3858         EndPath(graphics->hdc);
3859
3860         brush_fill_path(graphics, brush);
3861     }
3862
3863     RestoreDC(graphics->hdc, save_state);
3864
3865     DeleteObject(hrgn);
3866
3867     return Ok;
3868 }
3869
3870 static GpStatus SOFTWARE_GdipFillRegion(GpGraphics *graphics, GpBrush *brush,
3871     GpRegion* region)
3872 {
3873     GpStatus stat;
3874     GpRegion *temp_region;
3875     GpMatrix world_to_device;
3876     GpRectF graphics_bounds;
3877     DWORD *pixel_data;
3878     HRGN hregion;
3879     RECT bound_rect;
3880     GpRect gp_bound_rect;
3881
3882     if (!brush_can_fill_pixels(brush))
3883         return NotImplemented;
3884
3885     stat = get_graphics_bounds(graphics, &graphics_bounds);
3886
3887     if (stat == Ok)
3888         stat = GdipCloneRegion(region, &temp_region);
3889
3890     if (stat == Ok)
3891     {
3892         stat = get_graphics_transform(graphics, CoordinateSpaceDevice,
3893             CoordinateSpaceWorld, &world_to_device);
3894
3895         if (stat == Ok)
3896             stat = GdipTransformRegion(temp_region, &world_to_device);
3897
3898         if (stat == Ok)
3899             stat = GdipCombineRegionRect(temp_region, &graphics_bounds, CombineModeIntersect);
3900
3901         if (stat == Ok)
3902             stat = GdipGetRegionHRgn(temp_region, NULL, &hregion);
3903
3904         GdipDeleteRegion(temp_region);
3905     }
3906
3907     if (stat == Ok && GetRgnBox(hregion, &bound_rect) == NULLREGION)
3908     {
3909         DeleteObject(hregion);
3910         return Ok;
3911     }
3912
3913     if (stat == Ok)
3914     {
3915         gp_bound_rect.X = bound_rect.left;
3916         gp_bound_rect.Y = bound_rect.top;
3917         gp_bound_rect.Width = bound_rect.right - bound_rect.left;
3918         gp_bound_rect.Height = bound_rect.bottom - bound_rect.top;
3919
3920         pixel_data = GdipAlloc(sizeof(*pixel_data) * gp_bound_rect.Width * gp_bound_rect.Height);
3921         if (!pixel_data)
3922             stat = OutOfMemory;
3923
3924         if (stat == Ok)
3925         {
3926             stat = brush_fill_pixels(graphics, brush, pixel_data,
3927                 &gp_bound_rect, gp_bound_rect.Width);
3928
3929             if (stat == Ok)
3930                 stat = alpha_blend_pixels_hrgn(graphics, gp_bound_rect.X,
3931                     gp_bound_rect.Y, (BYTE*)pixel_data, gp_bound_rect.Width,
3932                     gp_bound_rect.Height, gp_bound_rect.Width * 4, hregion);
3933
3934             GdipFree(pixel_data);
3935         }
3936
3937         DeleteObject(hregion);
3938     }
3939
3940     return stat;
3941 }
3942
3943 /*****************************************************************************
3944  * GdipFillRegion [GDIPLUS.@]
3945  */
3946 GpStatus WINGDIPAPI GdipFillRegion(GpGraphics* graphics, GpBrush* brush,
3947         GpRegion* region)
3948 {
3949     GpStatus stat = NotImplemented;
3950
3951     TRACE("(%p, %p, %p)\n", graphics, brush, region);
3952
3953     if (!(graphics && brush && region))
3954         return InvalidParameter;
3955
3956     if(graphics->busy)
3957         return ObjectBusy;
3958
3959     if (!graphics->image && !graphics->alpha_hdc)
3960         stat = GDI32_GdipFillRegion(graphics, brush, region);
3961
3962     if (stat == NotImplemented)
3963         stat = SOFTWARE_GdipFillRegion(graphics, brush, region);
3964
3965     if (stat == NotImplemented)
3966     {
3967         FIXME("not implemented for brushtype %i\n", brush->bt);
3968         stat = Ok;
3969     }
3970
3971     return stat;
3972 }
3973
3974 GpStatus WINGDIPAPI GdipFlush(GpGraphics *graphics, GpFlushIntention intention)
3975 {
3976     TRACE("(%p,%u)\n", graphics, intention);
3977
3978     if(!graphics)
3979         return InvalidParameter;
3980
3981     if(graphics->busy)
3982         return ObjectBusy;
3983
3984     /* We have no internal operation queue, so there's no need to clear it. */
3985
3986     if (graphics->hdc)
3987         GdiFlush();
3988
3989     return Ok;
3990 }
3991
3992 /*****************************************************************************
3993  * GdipGetClipBounds [GDIPLUS.@]
3994  */
3995 GpStatus WINGDIPAPI GdipGetClipBounds(GpGraphics *graphics, GpRectF *rect)
3996 {
3997     GpStatus status;
3998     GpRegion *clip;
3999
4000     TRACE("(%p, %p)\n", graphics, rect);
4001
4002     if(!graphics)
4003         return InvalidParameter;
4004
4005     if(graphics->busy)
4006         return ObjectBusy;
4007
4008     status = GdipCreateRegion(&clip);
4009     if (status != Ok) return status;
4010
4011     status = GdipGetClip(graphics, clip);
4012     if (status == Ok)
4013         status = GdipGetRegionBounds(clip, graphics, rect);
4014
4015     GdipDeleteRegion(clip);
4016     return status;
4017 }
4018
4019 /*****************************************************************************
4020  * GdipGetClipBoundsI [GDIPLUS.@]
4021  */
4022 GpStatus WINGDIPAPI GdipGetClipBoundsI(GpGraphics *graphics, GpRect *rect)
4023 {
4024     TRACE("(%p, %p)\n", graphics, rect);
4025
4026     if(!graphics)
4027         return InvalidParameter;
4028
4029     if(graphics->busy)
4030         return ObjectBusy;
4031
4032     return GdipGetRegionBoundsI(graphics->clip, graphics, rect);
4033 }
4034
4035 /* FIXME: Compositing mode is not used anywhere except the getter/setter. */
4036 GpStatus WINGDIPAPI GdipGetCompositingMode(GpGraphics *graphics,
4037     CompositingMode *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->compmode;
4048
4049     return Ok;
4050 }
4051
4052 /* FIXME: Compositing quality is not used anywhere except the getter/setter. */
4053 GpStatus WINGDIPAPI GdipGetCompositingQuality(GpGraphics *graphics,
4054     CompositingQuality *quality)
4055 {
4056     TRACE("(%p, %p)\n", graphics, quality);
4057
4058     if(!graphics || !quality)
4059         return InvalidParameter;
4060
4061     if(graphics->busy)
4062         return ObjectBusy;
4063
4064     *quality = graphics->compqual;
4065
4066     return Ok;
4067 }
4068
4069 /* FIXME: Interpolation mode is not used anywhere except the getter/setter. */
4070 GpStatus WINGDIPAPI GdipGetInterpolationMode(GpGraphics *graphics,
4071     InterpolationMode *mode)
4072 {
4073     TRACE("(%p, %p)\n", graphics, mode);
4074
4075     if(!graphics || !mode)
4076         return InvalidParameter;
4077
4078     if(graphics->busy)
4079         return ObjectBusy;
4080
4081     *mode = graphics->interpolation;
4082
4083     return Ok;
4084 }
4085
4086 /* FIXME: Need to handle color depths less than 24bpp */
4087 GpStatus WINGDIPAPI GdipGetNearestColor(GpGraphics *graphics, ARGB* argb)
4088 {
4089     FIXME("(%p, %p): Passing color unmodified\n", graphics, argb);
4090
4091     if(!graphics || !argb)
4092         return InvalidParameter;
4093
4094     if(graphics->busy)
4095         return ObjectBusy;
4096
4097     return Ok;
4098 }
4099
4100 GpStatus WINGDIPAPI GdipGetPageScale(GpGraphics *graphics, REAL *scale)
4101 {
4102     TRACE("(%p, %p)\n", graphics, scale);
4103
4104     if(!graphics || !scale)
4105         return InvalidParameter;
4106
4107     if(graphics->busy)
4108         return ObjectBusy;
4109
4110     *scale = graphics->scale;
4111
4112     return Ok;
4113 }
4114
4115 GpStatus WINGDIPAPI GdipGetPageUnit(GpGraphics *graphics, GpUnit *unit)
4116 {
4117     TRACE("(%p, %p)\n", graphics, unit);
4118
4119     if(!graphics || !unit)
4120         return InvalidParameter;
4121
4122     if(graphics->busy)
4123         return ObjectBusy;
4124
4125     *unit = graphics->unit;
4126
4127     return Ok;
4128 }
4129
4130 /* FIXME: Pixel offset mode is not used anywhere except the getter/setter. */
4131 GpStatus WINGDIPAPI GdipGetPixelOffsetMode(GpGraphics *graphics, PixelOffsetMode
4132     *mode)
4133 {
4134     TRACE("(%p, %p)\n", graphics, mode);
4135
4136     if(!graphics || !mode)
4137         return InvalidParameter;
4138
4139     if(graphics->busy)
4140         return ObjectBusy;
4141
4142     *mode = graphics->pixeloffset;
4143
4144     return Ok;
4145 }
4146
4147 /* FIXME: Smoothing mode is not used anywhere except the getter/setter. */
4148 GpStatus WINGDIPAPI GdipGetSmoothingMode(GpGraphics *graphics, SmoothingMode *mode)
4149 {
4150     TRACE("(%p, %p)\n", graphics, mode);
4151
4152     if(!graphics || !mode)
4153         return InvalidParameter;
4154
4155     if(graphics->busy)
4156         return ObjectBusy;
4157
4158     *mode = graphics->smoothing;
4159
4160     return Ok;
4161 }
4162
4163 GpStatus WINGDIPAPI GdipGetTextContrast(GpGraphics *graphics, UINT *contrast)
4164 {
4165     TRACE("(%p, %p)\n", graphics, contrast);
4166
4167     if(!graphics || !contrast)
4168         return InvalidParameter;
4169
4170     *contrast = graphics->textcontrast;
4171
4172     return Ok;
4173 }
4174
4175 /* FIXME: Text rendering hint is not used anywhere except the getter/setter. */
4176 GpStatus WINGDIPAPI GdipGetTextRenderingHint(GpGraphics *graphics,
4177     TextRenderingHint *hint)
4178 {
4179     TRACE("(%p, %p)\n", graphics, hint);
4180
4181     if(!graphics || !hint)
4182         return InvalidParameter;
4183
4184     if(graphics->busy)
4185         return ObjectBusy;
4186
4187     *hint = graphics->texthint;
4188
4189     return Ok;
4190 }
4191
4192 GpStatus WINGDIPAPI GdipGetVisibleClipBounds(GpGraphics *graphics, GpRectF *rect)
4193 {
4194     GpRegion *clip_rgn;
4195     GpStatus stat;
4196
4197     TRACE("(%p, %p)\n", graphics, rect);
4198
4199     if(!graphics || !rect)
4200         return InvalidParameter;
4201
4202     if(graphics->busy)
4203         return ObjectBusy;
4204
4205     /* intersect window and graphics clipping regions */
4206     if((stat = GdipCreateRegion(&clip_rgn)) != Ok)
4207         return stat;
4208
4209     if((stat = get_visible_clip_region(graphics, clip_rgn)) != Ok)
4210         goto cleanup;
4211
4212     /* get bounds of the region */
4213     stat = GdipGetRegionBounds(clip_rgn, graphics, rect);
4214
4215 cleanup:
4216     GdipDeleteRegion(clip_rgn);
4217
4218     return stat;
4219 }
4220
4221 GpStatus WINGDIPAPI GdipGetVisibleClipBoundsI(GpGraphics *graphics, GpRect *rect)
4222 {
4223     GpRectF rectf;
4224     GpStatus stat;
4225
4226     TRACE("(%p, %p)\n", graphics, rect);
4227
4228     if(!graphics || !rect)
4229         return InvalidParameter;
4230
4231     if((stat = GdipGetVisibleClipBounds(graphics, &rectf)) == Ok)
4232     {
4233         rect->X = gdip_round(rectf.X);
4234         rect->Y = gdip_round(rectf.Y);
4235         rect->Width  = gdip_round(rectf.Width);
4236         rect->Height = gdip_round(rectf.Height);
4237     }
4238
4239     return stat;
4240 }
4241
4242 GpStatus WINGDIPAPI GdipGetWorldTransform(GpGraphics *graphics, GpMatrix *matrix)
4243 {
4244     TRACE("(%p, %p)\n", graphics, matrix);
4245
4246     if(!graphics || !matrix)
4247         return InvalidParameter;
4248
4249     if(graphics->busy)
4250         return ObjectBusy;
4251
4252     *matrix = graphics->worldtrans;
4253     return Ok;
4254 }
4255
4256 GpStatus WINGDIPAPI GdipGraphicsClear(GpGraphics *graphics, ARGB color)
4257 {
4258     GpSolidFill *brush;
4259     GpStatus stat;
4260     GpRectF wnd_rect;
4261
4262     TRACE("(%p, %x)\n", graphics, color);
4263
4264     if(!graphics)
4265         return InvalidParameter;
4266
4267     if(graphics->busy)
4268         return ObjectBusy;
4269
4270     if((stat = GdipCreateSolidFill(color, &brush)) != Ok)
4271         return stat;
4272
4273     if((stat = get_graphics_bounds(graphics, &wnd_rect)) != Ok){
4274         GdipDeleteBrush((GpBrush*)brush);
4275         return stat;
4276     }
4277
4278     GdipFillRectangle(graphics, (GpBrush*)brush, wnd_rect.X, wnd_rect.Y,
4279                                                  wnd_rect.Width, wnd_rect.Height);
4280
4281     GdipDeleteBrush((GpBrush*)brush);
4282
4283     return Ok;
4284 }
4285
4286 GpStatus WINGDIPAPI GdipIsClipEmpty(GpGraphics *graphics, BOOL *res)
4287 {
4288     TRACE("(%p, %p)\n", graphics, res);
4289
4290     if(!graphics || !res)
4291         return InvalidParameter;
4292
4293     return GdipIsEmptyRegion(graphics->clip, graphics, res);
4294 }
4295
4296 GpStatus WINGDIPAPI GdipIsVisiblePoint(GpGraphics *graphics, REAL x, REAL y, BOOL *result)
4297 {
4298     GpStatus stat;
4299     GpRegion* rgn;
4300     GpPointF pt;
4301
4302     TRACE("(%p, %.2f, %.2f, %p)\n", graphics, x, y, result);
4303
4304     if(!graphics || !result)
4305         return InvalidParameter;
4306
4307     if(graphics->busy)
4308         return ObjectBusy;
4309
4310     pt.X = x;
4311     pt.Y = y;
4312     if((stat = GdipTransformPoints(graphics, CoordinateSpaceDevice,
4313                    CoordinateSpaceWorld, &pt, 1)) != Ok)
4314         return stat;
4315
4316     if((stat = GdipCreateRegion(&rgn)) != Ok)
4317         return stat;
4318
4319     if((stat = get_visible_clip_region(graphics, rgn)) != Ok)
4320         goto cleanup;
4321
4322     stat = GdipIsVisibleRegionPoint(rgn, pt.X, pt.Y, graphics, result);
4323
4324 cleanup:
4325     GdipDeleteRegion(rgn);
4326     return stat;
4327 }
4328
4329 GpStatus WINGDIPAPI GdipIsVisiblePointI(GpGraphics *graphics, INT x, INT y, BOOL *result)
4330 {
4331     return GdipIsVisiblePoint(graphics, (REAL)x, (REAL)y, result);
4332 }
4333
4334 GpStatus WINGDIPAPI GdipIsVisibleRect(GpGraphics *graphics, REAL x, REAL y, REAL width, REAL height, BOOL *result)
4335 {
4336     GpStatus stat;
4337     GpRegion* rgn;
4338     GpPointF pts[2];
4339
4340     TRACE("(%p %.2f %.2f %.2f %.2f %p)\n", graphics, x, y, width, height, result);
4341
4342     if(!graphics || !result)
4343         return InvalidParameter;
4344
4345     if(graphics->busy)
4346         return ObjectBusy;
4347
4348     pts[0].X = x;
4349     pts[0].Y = y;
4350     pts[1].X = x + width;
4351     pts[1].Y = y + height;
4352
4353     if((stat = GdipTransformPoints(graphics, CoordinateSpaceDevice,
4354                     CoordinateSpaceWorld, pts, 2)) != Ok)
4355         return stat;
4356
4357     pts[1].X -= pts[0].X;
4358     pts[1].Y -= pts[0].Y;
4359
4360     if((stat = GdipCreateRegion(&rgn)) != Ok)
4361         return stat;
4362
4363     if((stat = get_visible_clip_region(graphics, rgn)) != Ok)
4364         goto cleanup;
4365
4366     stat = GdipIsVisibleRegionRect(rgn, pts[0].X, pts[0].Y, pts[1].X, pts[1].Y, graphics, result);
4367
4368 cleanup:
4369     GdipDeleteRegion(rgn);
4370     return stat;
4371 }
4372
4373 GpStatus WINGDIPAPI GdipIsVisibleRectI(GpGraphics *graphics, INT x, INT y, INT width, INT height, BOOL *result)
4374 {
4375     return GdipIsVisibleRect(graphics, (REAL)x, (REAL)y, (REAL)width, (REAL)height, result);
4376 }
4377
4378 GpStatus gdip_format_string(HDC hdc,
4379     GDIPCONST WCHAR *string, INT length, GDIPCONST GpFont *font,
4380     GDIPCONST RectF *rect, GDIPCONST GpStringFormat *format, int ignore_empty_clip,
4381     gdip_format_string_callback callback, void *user_data)
4382 {
4383     WCHAR* stringdup;
4384     int sum = 0, height = 0, fit, fitcpy, i, j, lret, nwidth,
4385         nheight, lineend, lineno = 0;
4386     RectF bounds;
4387     StringAlignment halign;
4388     GpStatus stat = Ok;
4389     SIZE size;
4390     HotkeyPrefix hkprefix;
4391     INT *hotkeyprefix_offsets=NULL;
4392     INT hotkeyprefix_count=0;
4393     INT hotkeyprefix_pos=0, hotkeyprefix_end_pos=0;
4394     BOOL seen_prefix = FALSE;
4395
4396     if(length == -1) length = lstrlenW(string);
4397
4398     stringdup = GdipAlloc((length + 1) * sizeof(WCHAR));
4399     if(!stringdup) return OutOfMemory;
4400
4401     nwidth = rect->Width;
4402     nheight = rect->Height;
4403     if (ignore_empty_clip)
4404     {
4405         if (!nwidth) nwidth = INT_MAX;
4406         if (!nheight) nheight = INT_MAX;
4407     }
4408
4409     if (format)
4410         hkprefix = format->hkprefix;
4411     else
4412         hkprefix = HotkeyPrefixNone;
4413
4414     if (hkprefix == HotkeyPrefixShow)
4415     {
4416         for (i=0; i<length; i++)
4417         {
4418             if (string[i] == '&')
4419                 hotkeyprefix_count++;
4420         }
4421     }
4422
4423     if (hotkeyprefix_count)
4424         hotkeyprefix_offsets = GdipAlloc(sizeof(INT) * hotkeyprefix_count);
4425
4426     hotkeyprefix_count = 0;
4427
4428     for(i = 0, j = 0; i < length; i++){
4429         /* FIXME: This makes the indexes passed to callback inaccurate. */
4430         if(!isprintW(string[i]) && (string[i] != '\n'))
4431             continue;
4432
4433         /* FIXME: tabs should be handled using tabstops from stringformat */
4434         if (string[i] == '\t')
4435             continue;
4436
4437         if (seen_prefix && hkprefix == HotkeyPrefixShow && string[i] != '&')
4438             hotkeyprefix_offsets[hotkeyprefix_count++] = j;
4439         else if (!seen_prefix && hkprefix != HotkeyPrefixNone && string[i] == '&')
4440         {
4441             seen_prefix = TRUE;
4442             continue;
4443         }
4444
4445         seen_prefix = FALSE;
4446
4447         stringdup[j] = string[i];
4448         j++;
4449     }
4450
4451     length = j;
4452
4453     if (format) halign = format->align;
4454     else halign = StringAlignmentNear;
4455
4456     while(sum < length){
4457         GetTextExtentExPointW(hdc, stringdup + sum, length - sum,
4458                               nwidth, &fit, NULL, &size);
4459         fitcpy = fit;
4460
4461         if(fit == 0)
4462             break;
4463
4464         for(lret = 0; lret < fit; lret++)
4465             if(*(stringdup + sum + lret) == '\n')
4466                 break;
4467
4468         /* Line break code (may look strange, but it imitates windows). */
4469         if(lret < fit)
4470             lineend = fit = lret;    /* this is not an off-by-one error */
4471         else if(fit < (length - sum)){
4472             if(*(stringdup + sum + fit) == ' ')
4473                 while(*(stringdup + sum + fit) == ' ')
4474                     fit++;
4475             else
4476                 while(*(stringdup + sum + fit - 1) != ' '){
4477                     fit--;
4478
4479                     if(*(stringdup + sum + fit) == '\t')
4480                         break;
4481
4482                     if(fit == 0){
4483                         fit = fitcpy;
4484                         break;
4485                     }
4486                 }
4487             lineend = fit;
4488             while(*(stringdup + sum + lineend - 1) == ' ' ||
4489                   *(stringdup + sum + lineend - 1) == '\t')
4490                 lineend--;
4491         }
4492         else
4493             lineend = fit;
4494
4495         GetTextExtentExPointW(hdc, stringdup + sum, lineend,
4496                               nwidth, &j, NULL, &size);
4497
4498         bounds.Width = size.cx;
4499
4500         if(height + size.cy > nheight)
4501         {
4502             if (format->attr & StringFormatFlagsLineLimit)
4503                 break;
4504             bounds.Height = nheight - (height + size.cy);
4505         }
4506         else
4507             bounds.Height = size.cy;
4508
4509         bounds.Y = rect->Y + height;
4510
4511         switch (halign)
4512         {
4513         case StringAlignmentNear:
4514         default:
4515             bounds.X = rect->X;
4516             break;
4517         case StringAlignmentCenter:
4518             bounds.X = rect->X + (rect->Width/2) - (bounds.Width/2);
4519             break;
4520         case StringAlignmentFar:
4521             bounds.X = rect->X + rect->Width - bounds.Width;
4522             break;
4523         }
4524
4525         for (hotkeyprefix_end_pos=hotkeyprefix_pos; hotkeyprefix_end_pos<hotkeyprefix_count; hotkeyprefix_end_pos++)
4526             if (hotkeyprefix_offsets[hotkeyprefix_end_pos] >= sum + lineend)
4527                 break;
4528
4529         stat = callback(hdc, stringdup, sum, lineend,
4530             font, rect, format, lineno, &bounds,
4531             &hotkeyprefix_offsets[hotkeyprefix_pos],
4532             hotkeyprefix_end_pos-hotkeyprefix_pos, user_data);
4533
4534         if (stat != Ok)
4535             break;
4536
4537         sum += fit + (lret < fitcpy ? 1 : 0);
4538         height += size.cy;
4539         lineno++;
4540
4541         hotkeyprefix_pos = hotkeyprefix_end_pos;
4542
4543         if(height > nheight)
4544             break;
4545
4546         /* Stop if this was a linewrap (but not if it was a linebreak). */
4547         if ((lret == fitcpy) && format &&
4548             (format->attr & StringFormatFlagsNoWrap))
4549             break;
4550     }
4551
4552     GdipFree(stringdup);
4553     GdipFree(hotkeyprefix_offsets);
4554
4555     return stat;
4556 }
4557
4558 struct measure_ranges_args {
4559     GpRegion **regions;
4560     REAL rel_width, rel_height;
4561 };
4562
4563 static GpStatus measure_ranges_callback(HDC hdc,
4564     GDIPCONST WCHAR *string, INT index, INT length, GDIPCONST GpFont *font,
4565     GDIPCONST RectF *rect, GDIPCONST GpStringFormat *format,
4566     INT lineno, const RectF *bounds, INT *underlined_indexes,
4567     INT underlined_index_count, void *user_data)
4568 {
4569     int i;
4570     GpStatus stat = Ok;
4571     struct measure_ranges_args *args = user_data;
4572
4573     for (i=0; i<format->range_count; i++)
4574     {
4575         INT range_start = max(index, format->character_ranges[i].First);
4576         INT range_end = min(index+length, format->character_ranges[i].First+format->character_ranges[i].Length);
4577         if (range_start < range_end)
4578         {
4579             GpRectF range_rect;
4580             SIZE range_size;
4581
4582             range_rect.Y = bounds->Y / args->rel_height;
4583             range_rect.Height = bounds->Height / args->rel_height;
4584
4585             GetTextExtentExPointW(hdc, string + index, range_start - index,
4586                                   INT_MAX, NULL, NULL, &range_size);
4587             range_rect.X = (bounds->X + range_size.cx) / args->rel_width;
4588
4589             GetTextExtentExPointW(hdc, string + index, range_end - index,
4590                                   INT_MAX, NULL, NULL, &range_size);
4591             range_rect.Width = (bounds->X + range_size.cx) / args->rel_width - range_rect.X;
4592
4593             stat = GdipCombineRegionRect(args->regions[i], &range_rect, CombineModeUnion);
4594             if (stat != Ok)
4595                 break;
4596         }
4597     }
4598
4599     return stat;
4600 }
4601
4602 GpStatus WINGDIPAPI GdipMeasureCharacterRanges(GpGraphics* graphics,
4603         GDIPCONST WCHAR* string, INT length, GDIPCONST GpFont* font,
4604         GDIPCONST RectF* layoutRect, GDIPCONST GpStringFormat *stringFormat,
4605         INT regionCount, GpRegion** regions)
4606 {
4607     GpStatus stat;
4608     int i;
4609     HFONT gdifont, oldfont;
4610     struct measure_ranges_args args;
4611     HDC hdc, temp_hdc=NULL;
4612     GpPointF pt[3];
4613     RectF scaled_rect;
4614     REAL margin_x;
4615
4616     TRACE("(%p %s %d %p %s %p %d %p)\n", graphics, debugstr_w(string),
4617             length, font, debugstr_rectf(layoutRect), stringFormat, regionCount, regions);
4618
4619     if (!(graphics && string && font && layoutRect && stringFormat && regions))
4620         return InvalidParameter;
4621
4622     if (regionCount < stringFormat->range_count)
4623         return InvalidParameter;
4624
4625     if(!graphics->hdc)
4626     {
4627         hdc = temp_hdc = CreateCompatibleDC(0);
4628         if (!temp_hdc) return OutOfMemory;
4629     }
4630     else
4631         hdc = graphics->hdc;
4632
4633     if (stringFormat->attr)
4634         TRACE("may be ignoring some format flags: attr %x\n", stringFormat->attr);
4635
4636     pt[0].X = 0.0;
4637     pt[0].Y = 0.0;
4638     pt[1].X = 1.0;
4639     pt[1].Y = 0.0;
4640     pt[2].X = 0.0;
4641     pt[2].Y = 1.0;
4642     GdipTransformPoints(graphics, CoordinateSpaceDevice, CoordinateSpaceWorld, pt, 3);
4643     args.rel_width = sqrt((pt[1].Y-pt[0].Y)*(pt[1].Y-pt[0].Y)+
4644                      (pt[1].X-pt[0].X)*(pt[1].X-pt[0].X));
4645     args.rel_height = sqrt((pt[2].Y-pt[0].Y)*(pt[2].Y-pt[0].Y)+
4646                       (pt[2].X-pt[0].X)*(pt[2].X-pt[0].X));
4647
4648     margin_x = stringFormat->generic_typographic ? 0.0 : font->emSize / 6.0;
4649     margin_x *= units_scale(font->unit, graphics->unit, graphics->xres);
4650
4651     scaled_rect.X = (layoutRect->X + margin_x) * args.rel_width;
4652     scaled_rect.Y = layoutRect->Y * args.rel_height;
4653     scaled_rect.Width = layoutRect->Width * args.rel_width;
4654     scaled_rect.Height = layoutRect->Height * args.rel_height;
4655
4656     get_font_hfont(graphics, font, stringFormat, &gdifont, NULL);
4657     oldfont = SelectObject(hdc, gdifont);
4658
4659     for (i=0; i<stringFormat->range_count; i++)
4660     {
4661         stat = GdipSetEmpty(regions[i]);
4662         if (stat != Ok)
4663             return stat;
4664     }
4665
4666     args.regions = regions;
4667
4668     stat = gdip_format_string(hdc, string, length, font, &scaled_rect, stringFormat,
4669         (stringFormat->attr & StringFormatFlagsNoClip) != 0, measure_ranges_callback, &args);
4670
4671     SelectObject(hdc, oldfont);
4672     DeleteObject(gdifont);
4673
4674     if (temp_hdc)
4675         DeleteDC(temp_hdc);
4676
4677     return stat;
4678 }
4679
4680 struct measure_string_args {
4681     RectF *bounds;
4682     INT *codepointsfitted;
4683     INT *linesfilled;
4684     REAL rel_width, rel_height;
4685 };
4686
4687 static GpStatus measure_string_callback(HDC hdc,
4688     GDIPCONST WCHAR *string, INT index, INT length, GDIPCONST GpFont *font,
4689     GDIPCONST RectF *rect, GDIPCONST GpStringFormat *format,
4690     INT lineno, const RectF *bounds, INT *underlined_indexes,
4691     INT underlined_index_count, void *user_data)
4692 {
4693     struct measure_string_args *args = user_data;
4694     REAL new_width, new_height;
4695
4696     new_width = bounds->Width / args->rel_width;
4697     new_height = (bounds->Height + bounds->Y) / args->rel_height - args->bounds->Y;
4698
4699     if (new_width > args->bounds->Width)
4700         args->bounds->Width = new_width;
4701
4702     if (new_height > args->bounds->Height)
4703         args->bounds->Height = new_height;
4704
4705     if (args->codepointsfitted)
4706         *args->codepointsfitted = index + length;
4707
4708     if (args->linesfilled)
4709         (*args->linesfilled)++;
4710
4711     return Ok;
4712 }
4713
4714 /* Find the smallest rectangle that bounds the text when it is printed in rect
4715  * according to the format options listed in format. If rect has 0 width and
4716  * height, then just find the smallest rectangle that bounds the text when it's
4717  * printed at location (rect->X, rect-Y). */
4718 GpStatus WINGDIPAPI GdipMeasureString(GpGraphics *graphics,
4719     GDIPCONST WCHAR *string, INT length, GDIPCONST GpFont *font,
4720     GDIPCONST RectF *rect, GDIPCONST GpStringFormat *format, RectF *bounds,
4721     INT *codepointsfitted, INT *linesfilled)
4722 {
4723     HFONT oldfont, gdifont;
4724     struct measure_string_args args;
4725     HDC temp_hdc=NULL, hdc;
4726     GpPointF pt[3];
4727     RectF scaled_rect;
4728     REAL margin_x;
4729     INT lines, glyphs;
4730
4731     TRACE("(%p, %s, %i, %p, %s, %p, %p, %p, %p)\n", graphics,
4732         debugstr_wn(string, length), length, font, debugstr_rectf(rect), format,
4733         bounds, codepointsfitted, linesfilled);
4734
4735     if(!graphics || !string || !font || !rect || !bounds)
4736         return InvalidParameter;
4737
4738     if(!graphics->hdc)
4739     {
4740         hdc = temp_hdc = CreateCompatibleDC(0);
4741         if (!temp_hdc) return OutOfMemory;
4742     }
4743     else
4744         hdc = graphics->hdc;
4745
4746     if(linesfilled) *linesfilled = 0;
4747     if(codepointsfitted) *codepointsfitted = 0;
4748
4749     if(format)
4750         TRACE("may be ignoring some format flags: attr %x\n", format->attr);
4751
4752     pt[0].X = 0.0;
4753     pt[0].Y = 0.0;
4754     pt[1].X = 1.0;
4755     pt[1].Y = 0.0;
4756     pt[2].X = 0.0;
4757     pt[2].Y = 1.0;
4758     GdipTransformPoints(graphics, CoordinateSpaceDevice, CoordinateSpaceWorld, pt, 3);
4759     args.rel_width = sqrt((pt[1].Y-pt[0].Y)*(pt[1].Y-pt[0].Y)+
4760                      (pt[1].X-pt[0].X)*(pt[1].X-pt[0].X));
4761     args.rel_height = sqrt((pt[2].Y-pt[0].Y)*(pt[2].Y-pt[0].Y)+
4762                       (pt[2].X-pt[0].X)*(pt[2].X-pt[0].X));
4763
4764     margin_x = (format && format->generic_typographic) ? 0.0 : font->emSize / 6.0;
4765     margin_x *= units_scale(font->unit, graphics->unit, graphics->xres);
4766
4767     scaled_rect.X = (rect->X + margin_x) * args.rel_width;
4768     scaled_rect.Y = rect->Y * args.rel_height;
4769     scaled_rect.Width = rect->Width * args.rel_width;
4770     scaled_rect.Height = rect->Height * args.rel_height;
4771     if (scaled_rect.Width >= 0.5)
4772     {
4773         scaled_rect.Width -= margin_x * 2.0 * args.rel_width;
4774         if (scaled_rect.Width < 0.5) return Ok; /* doesn't fit */
4775     }
4776
4777     if (scaled_rect.Width >= 1 << 23) scaled_rect.Width = 1 << 23;
4778     if (scaled_rect.Height >= 1 << 23) scaled_rect.Height = 1 << 23;
4779
4780     get_font_hfont(graphics, font, format, &gdifont, NULL);
4781     oldfont = SelectObject(hdc, gdifont);
4782
4783     bounds->X = rect->X;
4784     bounds->Y = rect->Y;
4785     bounds->Width = 0.0;
4786     bounds->Height = 0.0;
4787
4788     args.bounds = bounds;
4789     args.codepointsfitted = &glyphs;
4790     args.linesfilled = &lines;
4791     lines = glyphs = 0;
4792
4793     gdip_format_string(hdc, string, length, font, &scaled_rect, format, TRUE,
4794         measure_string_callback, &args);
4795
4796     if (linesfilled) *linesfilled = lines;
4797     if (codepointsfitted) *codepointsfitted = glyphs;
4798
4799     if (lines)
4800         bounds->Width += margin_x * 2.0;
4801
4802     SelectObject(hdc, oldfont);
4803     DeleteObject(gdifont);
4804
4805     if (temp_hdc)
4806         DeleteDC(temp_hdc);
4807
4808     return Ok;
4809 }
4810
4811 struct draw_string_args {
4812     GpGraphics *graphics;
4813     GDIPCONST GpBrush *brush;
4814     REAL x, y, rel_width, rel_height, ascent;
4815 };
4816
4817 static GpStatus draw_string_callback(HDC hdc,
4818     GDIPCONST WCHAR *string, INT index, INT length, GDIPCONST GpFont *font,
4819     GDIPCONST RectF *rect, GDIPCONST GpStringFormat *format,
4820     INT lineno, const RectF *bounds, INT *underlined_indexes,
4821     INT underlined_index_count, void *user_data)
4822 {
4823     struct draw_string_args *args = user_data;
4824     PointF position;
4825     GpStatus stat;
4826
4827     position.X = args->x + bounds->X / args->rel_width;
4828     position.Y = args->y + bounds->Y / args->rel_height + args->ascent;
4829
4830     stat = draw_driver_string(args->graphics, &string[index], length, font, format,
4831         args->brush, &position,
4832         DriverStringOptionsCmapLookup|DriverStringOptionsRealizedAdvance, NULL);
4833
4834     if (stat == Ok && underlined_index_count)
4835     {
4836         OUTLINETEXTMETRICW otm;
4837         REAL underline_y, underline_height;
4838         int i;
4839
4840         GetOutlineTextMetricsW(hdc, sizeof(otm), &otm);
4841
4842         underline_height = otm.otmsUnderscoreSize / args->rel_height;
4843         underline_y = position.Y - otm.otmsUnderscorePosition / args->rel_height - underline_height / 2;
4844
4845         for (i=0; i<underlined_index_count; i++)
4846         {
4847             REAL start_x, end_x;
4848             SIZE text_size;
4849             INT ofs = underlined_indexes[i] - index;
4850
4851             GetTextExtentExPointW(hdc, string + index, ofs, INT_MAX, NULL, NULL, &text_size);
4852             start_x = text_size.cx / args->rel_width;
4853
4854             GetTextExtentExPointW(hdc, string + index, ofs+1, INT_MAX, NULL, NULL, &text_size);
4855             end_x = text_size.cx / args->rel_width;
4856
4857             GdipFillRectangle(args->graphics, (GpBrush*)args->brush, position.X+start_x, underline_y, end_x-start_x, underline_height);
4858         }
4859     }
4860
4861     return stat;
4862 }
4863
4864 GpStatus WINGDIPAPI GdipDrawString(GpGraphics *graphics, GDIPCONST WCHAR *string,
4865     INT length, GDIPCONST GpFont *font, GDIPCONST RectF *rect,
4866     GDIPCONST GpStringFormat *format, GDIPCONST GpBrush *brush)
4867 {
4868     HRGN rgn = NULL;
4869     HFONT gdifont;
4870     GpPointF pt[3], rectcpy[4];
4871     POINT corners[4];
4872     REAL rel_width, rel_height, margin_x;
4873     INT save_state, format_flags = 0;
4874     REAL offsety = 0.0;
4875     struct draw_string_args args;
4876     RectF scaled_rect;
4877     HDC hdc, temp_hdc=NULL;
4878     TEXTMETRICW textmetric;
4879
4880     TRACE("(%p, %s, %i, %p, %s, %p, %p)\n", graphics, debugstr_wn(string, length),
4881         length, font, debugstr_rectf(rect), format, brush);
4882
4883     if(!graphics || !string || !font || !brush || !rect)
4884         return InvalidParameter;
4885
4886     if(graphics->hdc)
4887     {
4888         hdc = graphics->hdc;
4889     }
4890     else
4891     {
4892         hdc = temp_hdc = CreateCompatibleDC(0);
4893     }
4894
4895     if(format){
4896         TRACE("may be ignoring some format flags: attr %x\n", format->attr);
4897
4898         format_flags = format->attr;
4899
4900         /* Should be no need to explicitly test for StringAlignmentNear as
4901          * that is default behavior if no alignment is passed. */
4902         if(format->vertalign != StringAlignmentNear){
4903             RectF bounds, in_rect = *rect;
4904             in_rect.Height = 0.0; /* avoid height clipping */
4905             GdipMeasureString(graphics, string, length, font, &in_rect, format, &bounds, 0, 0);
4906
4907             TRACE("bounds %s\n", debugstr_rectf(&bounds));
4908
4909             if(format->vertalign == StringAlignmentCenter)
4910                 offsety = (rect->Height - bounds.Height) / 2;
4911             else if(format->vertalign == StringAlignmentFar)
4912                 offsety = (rect->Height - bounds.Height);
4913         }
4914         TRACE("vertical align %d, offsety %f\n", format->vertalign, offsety);
4915     }
4916
4917     save_state = SaveDC(hdc);
4918
4919     pt[0].X = 0.0;
4920     pt[0].Y = 0.0;
4921     pt[1].X = 1.0;
4922     pt[1].Y = 0.0;
4923     pt[2].X = 0.0;
4924     pt[2].Y = 1.0;
4925     GdipTransformPoints(graphics, CoordinateSpaceDevice, CoordinateSpaceWorld, pt, 3);
4926     rel_width = sqrt((pt[1].Y-pt[0].Y)*(pt[1].Y-pt[0].Y)+
4927                      (pt[1].X-pt[0].X)*(pt[1].X-pt[0].X));
4928     rel_height = sqrt((pt[2].Y-pt[0].Y)*(pt[2].Y-pt[0].Y)+
4929                       (pt[2].X-pt[0].X)*(pt[2].X-pt[0].X));
4930
4931     rectcpy[3].X = rectcpy[0].X = rect->X;
4932     rectcpy[1].Y = rectcpy[0].Y = rect->Y;
4933     rectcpy[2].X = rectcpy[1].X = rect->X + rect->Width;
4934     rectcpy[3].Y = rectcpy[2].Y = rect->Y + rect->Height;
4935     transform_and_round_points(graphics, corners, rectcpy, 4);
4936
4937     margin_x = (format && format->generic_typographic) ? 0.0 : font->emSize / 6.0;
4938     margin_x *= units_scale(font->unit, graphics->unit, graphics->xres);
4939
4940     scaled_rect.X = margin_x * rel_width;
4941     scaled_rect.Y = 0.0;
4942     scaled_rect.Width = rel_width * rect->Width;
4943     scaled_rect.Height = rel_height * rect->Height;
4944     if (scaled_rect.Width >= 0.5)
4945     {
4946         scaled_rect.Width -= margin_x * 2.0 * rel_width;
4947         if (scaled_rect.Width < 0.5) return Ok; /* doesn't fit */
4948     }
4949
4950     if (scaled_rect.Width >= 1 << 23) scaled_rect.Width = 1 << 23;
4951     if (scaled_rect.Height >= 1 << 23) scaled_rect.Height = 1 << 23;
4952
4953     if (!(format_flags & StringFormatFlagsNoClip) &&
4954         scaled_rect.Width != 1 << 23 && scaled_rect.Height != 1 << 23 &&
4955         rect->Width > 0.0 && rect->Height > 0.0)
4956     {
4957         /* FIXME: If only the width or only the height is 0, we should probably still clip */
4958         rgn = CreatePolygonRgn(corners, 4, ALTERNATE);
4959         SelectClipRgn(hdc, rgn);
4960     }
4961
4962     get_font_hfont(graphics, font, format, &gdifont, NULL);
4963     SelectObject(hdc, gdifont);
4964
4965     args.graphics = graphics;
4966     args.brush = brush;
4967
4968     args.x = rect->X;
4969     args.y = rect->Y + offsety;
4970
4971     args.rel_width = rel_width;
4972     args.rel_height = rel_height;
4973
4974     GetTextMetricsW(hdc, &textmetric);
4975     args.ascent = textmetric.tmAscent / rel_height;
4976
4977     gdip_format_string(hdc, string, length, font, &scaled_rect, format, TRUE,
4978         draw_string_callback, &args);
4979
4980     DeleteObject(rgn);
4981     DeleteObject(gdifont);
4982
4983     RestoreDC(hdc, save_state);
4984
4985     DeleteDC(temp_hdc);
4986
4987     return Ok;
4988 }
4989
4990 GpStatus WINGDIPAPI GdipResetClip(GpGraphics *graphics)
4991 {
4992     TRACE("(%p)\n", graphics);
4993
4994     if(!graphics)
4995         return InvalidParameter;
4996
4997     if(graphics->busy)
4998         return ObjectBusy;
4999
5000     return GdipSetInfinite(graphics->clip);
5001 }
5002
5003 GpStatus WINGDIPAPI GdipResetWorldTransform(GpGraphics *graphics)
5004 {
5005     TRACE("(%p)\n", graphics);
5006
5007     if(!graphics)
5008         return InvalidParameter;
5009
5010     if(graphics->busy)
5011         return ObjectBusy;
5012
5013     return GdipSetMatrixElements(&graphics->worldtrans, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0);
5014 }
5015
5016 GpStatus WINGDIPAPI GdipRestoreGraphics(GpGraphics *graphics, GraphicsState state)
5017 {
5018     return GdipEndContainer(graphics, state);
5019 }
5020
5021 GpStatus WINGDIPAPI GdipRotateWorldTransform(GpGraphics *graphics, REAL angle,
5022     GpMatrixOrder order)
5023 {
5024     TRACE("(%p, %.2f, %d)\n", graphics, angle, order);
5025
5026     if(!graphics)
5027         return InvalidParameter;
5028
5029     if(graphics->busy)
5030         return ObjectBusy;
5031
5032     return GdipRotateMatrix(&graphics->worldtrans, angle, order);
5033 }
5034
5035 GpStatus WINGDIPAPI GdipSaveGraphics(GpGraphics *graphics, GraphicsState *state)
5036 {
5037     return GdipBeginContainer2(graphics, state);
5038 }
5039
5040 GpStatus WINGDIPAPI GdipBeginContainer2(GpGraphics *graphics,
5041         GraphicsContainer *state)
5042 {
5043     GraphicsContainerItem *container;
5044     GpStatus sts;
5045
5046     TRACE("(%p, %p)\n", graphics, state);
5047
5048     if(!graphics || !state)
5049         return InvalidParameter;
5050
5051     sts = init_container(&container, graphics);
5052     if(sts != Ok)
5053         return sts;
5054
5055     list_add_head(&graphics->containers, &container->entry);
5056     *state = graphics->contid = container->contid;
5057
5058     return Ok;
5059 }
5060
5061 GpStatus WINGDIPAPI GdipBeginContainer(GpGraphics *graphics, GDIPCONST GpRectF *dstrect, GDIPCONST GpRectF *srcrect, GpUnit unit, GraphicsContainer *state)
5062 {
5063     FIXME("(%p, %p, %p, %d, %p): stub\n", graphics, dstrect, srcrect, unit, state);
5064     return NotImplemented;
5065 }
5066
5067 GpStatus WINGDIPAPI GdipBeginContainerI(GpGraphics *graphics, GDIPCONST GpRect *dstrect, GDIPCONST GpRect *srcrect, GpUnit unit, GraphicsContainer *state)
5068 {
5069     FIXME("(%p, %p, %p, %d, %p): stub\n", graphics, dstrect, srcrect, unit, state);
5070     return NotImplemented;
5071 }
5072
5073 GpStatus WINGDIPAPI GdipComment(GpGraphics *graphics, UINT sizeData, GDIPCONST BYTE *data)
5074 {
5075     FIXME("(%p, %d, %p): stub\n", graphics, sizeData, data);
5076     return NotImplemented;
5077 }
5078
5079 GpStatus WINGDIPAPI GdipEndContainer(GpGraphics *graphics, GraphicsContainer state)
5080 {
5081     GpStatus sts;
5082     GraphicsContainerItem *container, *container2;
5083
5084     TRACE("(%p, %x)\n", graphics, state);
5085
5086     if(!graphics)
5087         return InvalidParameter;
5088
5089     LIST_FOR_EACH_ENTRY(container, &graphics->containers, GraphicsContainerItem, entry){
5090         if(container->contid == state)
5091             break;
5092     }
5093
5094     /* did not find a matching container */
5095     if(&container->entry == &graphics->containers)
5096         return Ok;
5097
5098     sts = restore_container(graphics, container);
5099     if(sts != Ok)
5100         return sts;
5101
5102     /* remove all of the containers on top of the found container */
5103     LIST_FOR_EACH_ENTRY_SAFE(container, container2, &graphics->containers, GraphicsContainerItem, entry){
5104         if(container->contid == state)
5105             break;
5106         list_remove(&container->entry);
5107         delete_container(container);
5108     }
5109
5110     list_remove(&container->entry);
5111     delete_container(container);
5112
5113     return Ok;
5114 }
5115
5116 GpStatus WINGDIPAPI GdipScaleWorldTransform(GpGraphics *graphics, REAL sx,
5117     REAL sy, GpMatrixOrder order)
5118 {
5119     TRACE("(%p, %.2f, %.2f, %d)\n", graphics, sx, sy, order);
5120
5121     if(!graphics)
5122         return InvalidParameter;
5123
5124     if(graphics->busy)
5125         return ObjectBusy;
5126
5127     return GdipScaleMatrix(&graphics->worldtrans, sx, sy, order);
5128 }
5129
5130 GpStatus WINGDIPAPI GdipSetClipGraphics(GpGraphics *graphics, GpGraphics *srcgraphics,
5131     CombineMode mode)
5132 {
5133     TRACE("(%p, %p, %d)\n", graphics, srcgraphics, mode);
5134
5135     if(!graphics || !srcgraphics)
5136         return InvalidParameter;
5137
5138     return GdipCombineRegionRegion(graphics->clip, srcgraphics->clip, mode);
5139 }
5140
5141 GpStatus WINGDIPAPI GdipSetCompositingMode(GpGraphics *graphics,
5142     CompositingMode mode)
5143 {
5144     TRACE("(%p, %d)\n", graphics, mode);
5145
5146     if(!graphics)
5147         return InvalidParameter;
5148
5149     if(graphics->busy)
5150         return ObjectBusy;
5151
5152     graphics->compmode = mode;
5153
5154     return Ok;
5155 }
5156
5157 GpStatus WINGDIPAPI GdipSetCompositingQuality(GpGraphics *graphics,
5158     CompositingQuality quality)
5159 {
5160     TRACE("(%p, %d)\n", graphics, quality);
5161
5162     if(!graphics)
5163         return InvalidParameter;
5164
5165     if(graphics->busy)
5166         return ObjectBusy;
5167
5168     graphics->compqual = quality;
5169
5170     return Ok;
5171 }
5172
5173 GpStatus WINGDIPAPI GdipSetInterpolationMode(GpGraphics *graphics,
5174     InterpolationMode mode)
5175 {
5176     TRACE("(%p, %d)\n", graphics, mode);
5177
5178     if(!graphics || mode == InterpolationModeInvalid || mode > InterpolationModeHighQualityBicubic)
5179         return InvalidParameter;
5180
5181     if(graphics->busy)
5182         return ObjectBusy;
5183
5184     if (mode == InterpolationModeDefault || mode == InterpolationModeLowQuality)
5185         mode = InterpolationModeBilinear;
5186
5187     if (mode == InterpolationModeHighQuality)
5188         mode = InterpolationModeHighQualityBicubic;
5189
5190     graphics->interpolation = mode;
5191
5192     return Ok;
5193 }
5194
5195 GpStatus WINGDIPAPI GdipSetPageScale(GpGraphics *graphics, REAL scale)
5196 {
5197     GpStatus stat;
5198
5199     TRACE("(%p, %.2f)\n", graphics, scale);
5200
5201     if(!graphics || (scale <= 0.0))
5202         return InvalidParameter;
5203
5204     if(graphics->busy)
5205         return ObjectBusy;
5206
5207     if (graphics->image && graphics->image->type == ImageTypeMetafile)
5208     {
5209         stat = METAFILE_SetPageTransform((GpMetafile*)graphics->image, graphics->unit, scale);
5210         if (stat != Ok)
5211             return stat;
5212     }
5213
5214     graphics->scale = scale;
5215
5216     return Ok;
5217 }
5218
5219 GpStatus WINGDIPAPI GdipSetPageUnit(GpGraphics *graphics, GpUnit unit)
5220 {
5221     GpStatus stat;
5222
5223     TRACE("(%p, %d)\n", graphics, unit);
5224
5225     if(!graphics)
5226         return InvalidParameter;
5227
5228     if(graphics->busy)
5229         return ObjectBusy;
5230
5231     if(unit == UnitWorld)
5232         return InvalidParameter;
5233
5234     if (graphics->image && graphics->image->type == ImageTypeMetafile)
5235     {
5236         stat = METAFILE_SetPageTransform((GpMetafile*)graphics->image, unit, graphics->scale);
5237         if (stat != Ok)
5238             return stat;
5239     }
5240
5241     graphics->unit = unit;
5242
5243     return Ok;
5244 }
5245
5246 GpStatus WINGDIPAPI GdipSetPixelOffsetMode(GpGraphics *graphics, PixelOffsetMode
5247     mode)
5248 {
5249     TRACE("(%p, %d)\n", graphics, mode);
5250
5251     if(!graphics)
5252         return InvalidParameter;
5253
5254     if(graphics->busy)
5255         return ObjectBusy;
5256
5257     graphics->pixeloffset = mode;
5258
5259     return Ok;
5260 }
5261
5262 GpStatus WINGDIPAPI GdipSetRenderingOrigin(GpGraphics *graphics, INT x, INT y)
5263 {
5264     static int calls;
5265
5266     TRACE("(%p,%i,%i)\n", graphics, x, y);
5267
5268     if (!(calls++))
5269         FIXME("value is unused in rendering\n");
5270
5271     if (!graphics)
5272         return InvalidParameter;
5273
5274     graphics->origin_x = x;
5275     graphics->origin_y = y;
5276
5277     return Ok;
5278 }
5279
5280 GpStatus WINGDIPAPI GdipGetRenderingOrigin(GpGraphics *graphics, INT *x, INT *y)
5281 {
5282     TRACE("(%p,%p,%p)\n", graphics, x, y);
5283
5284     if (!graphics || !x || !y)
5285         return InvalidParameter;
5286
5287     *x = graphics->origin_x;
5288     *y = graphics->origin_y;
5289
5290     return Ok;
5291 }
5292
5293 GpStatus WINGDIPAPI GdipSetSmoothingMode(GpGraphics *graphics, SmoothingMode mode)
5294 {
5295     TRACE("(%p, %d)\n", graphics, mode);
5296
5297     if(!graphics)
5298         return InvalidParameter;
5299
5300     if(graphics->busy)
5301         return ObjectBusy;
5302
5303     graphics->smoothing = mode;
5304
5305     return Ok;
5306 }
5307
5308 GpStatus WINGDIPAPI GdipSetTextContrast(GpGraphics *graphics, UINT contrast)
5309 {
5310     TRACE("(%p, %d)\n", graphics, contrast);
5311
5312     if(!graphics)
5313         return InvalidParameter;
5314
5315     graphics->textcontrast = contrast;
5316
5317     return Ok;
5318 }
5319
5320 GpStatus WINGDIPAPI GdipSetTextRenderingHint(GpGraphics *graphics,
5321     TextRenderingHint hint)
5322 {
5323     TRACE("(%p, %d)\n", graphics, hint);
5324
5325     if(!graphics || hint > TextRenderingHintClearTypeGridFit)
5326         return InvalidParameter;
5327
5328     if(graphics->busy)
5329         return ObjectBusy;
5330
5331     graphics->texthint = hint;
5332
5333     return Ok;
5334 }
5335
5336 GpStatus WINGDIPAPI GdipSetWorldTransform(GpGraphics *graphics, GpMatrix *matrix)
5337 {
5338     TRACE("(%p, %p)\n", graphics, matrix);
5339
5340     if(!graphics || !matrix)
5341         return InvalidParameter;
5342
5343     if(graphics->busy)
5344         return ObjectBusy;
5345
5346     TRACE("%f,%f,%f,%f,%f,%f\n",
5347           matrix->matrix[0], matrix->matrix[1], matrix->matrix[2],
5348           matrix->matrix[3], matrix->matrix[4], matrix->matrix[5]);
5349
5350     graphics->worldtrans = *matrix;
5351
5352     return Ok;
5353 }
5354
5355 GpStatus WINGDIPAPI GdipTranslateWorldTransform(GpGraphics *graphics, REAL dx,
5356     REAL dy, GpMatrixOrder order)
5357 {
5358     TRACE("(%p, %.2f, %.2f, %d)\n", graphics, dx, dy, order);
5359
5360     if(!graphics)
5361         return InvalidParameter;
5362
5363     if(graphics->busy)
5364         return ObjectBusy;
5365
5366     return GdipTranslateMatrix(&graphics->worldtrans, dx, dy, order);
5367 }
5368
5369 /*****************************************************************************
5370  * GdipSetClipHrgn [GDIPLUS.@]
5371  */
5372 GpStatus WINGDIPAPI GdipSetClipHrgn(GpGraphics *graphics, HRGN hrgn, CombineMode mode)
5373 {
5374     GpRegion *region;
5375     GpStatus status;
5376
5377     TRACE("(%p, %p, %d)\n", graphics, hrgn, mode);
5378
5379     if(!graphics)
5380         return InvalidParameter;
5381
5382     if(graphics->busy)
5383         return ObjectBusy;
5384
5385     /* hrgn is already in device units */
5386     status = GdipCreateRegionHrgn(hrgn, &region);
5387     if(status != Ok)
5388         return status;
5389
5390     status = GdipCombineRegionRegion(graphics->clip, region, mode);
5391
5392     GdipDeleteRegion(region);
5393     return status;
5394 }
5395
5396 GpStatus WINGDIPAPI GdipSetClipPath(GpGraphics *graphics, GpPath *path, CombineMode mode)
5397 {
5398     GpStatus status;
5399     GpPath *clip_path;
5400
5401     TRACE("(%p, %p, %d)\n", graphics, path, mode);
5402
5403     if(!graphics)
5404         return InvalidParameter;
5405
5406     if(graphics->busy)
5407         return ObjectBusy;
5408
5409     status = GdipClonePath(path, &clip_path);
5410     if (status == Ok)
5411     {
5412         GpMatrix world_to_device;
5413
5414         get_graphics_transform(graphics, CoordinateSpaceDevice,
5415                                CoordinateSpaceWorld, &world_to_device);
5416         status = GdipTransformPath(clip_path, &world_to_device);
5417         if (status == Ok)
5418             GdipCombineRegionPath(graphics->clip, clip_path, mode);
5419
5420         GdipDeletePath(clip_path);
5421     }
5422     return status;
5423 }
5424
5425 GpStatus WINGDIPAPI GdipSetClipRect(GpGraphics *graphics, REAL x, REAL y,
5426                                     REAL width, REAL height,
5427                                     CombineMode mode)
5428 {
5429     GpStatus status;
5430     GpRectF rect;
5431     GpRegion *region;
5432
5433     TRACE("(%p, %.2f, %.2f, %.2f, %.2f, %d)\n", graphics, x, y, width, height, mode);
5434
5435     if(!graphics)
5436         return InvalidParameter;
5437
5438     if(graphics->busy)
5439         return ObjectBusy;
5440
5441     rect.X = x;
5442     rect.Y = y;
5443     rect.Width  = width;
5444     rect.Height = height;
5445     status = GdipCreateRegionRect(&rect, &region);
5446     if (status == Ok)
5447     {
5448         GpMatrix world_to_device;
5449
5450         get_graphics_transform(graphics, CoordinateSpaceDevice, CoordinateSpaceWorld, &world_to_device);
5451         status = GdipTransformRegion(region, &world_to_device);
5452         if (status == Ok)
5453             status = GdipCombineRegionRegion(graphics->clip, region, mode);
5454
5455         GdipDeleteRegion(region);
5456     }
5457     return status;
5458 }
5459
5460 GpStatus WINGDIPAPI GdipSetClipRectI(GpGraphics *graphics, INT x, INT y,
5461                                      INT width, INT height,
5462                                      CombineMode mode)
5463 {
5464     TRACE("(%p, %d, %d, %d, %d, %d)\n", graphics, x, y, width, height, mode);
5465
5466     if(!graphics)
5467         return InvalidParameter;
5468
5469     if(graphics->busy)
5470         return ObjectBusy;
5471
5472     return GdipSetClipRect(graphics, (REAL)x, (REAL)y, (REAL)width, (REAL)height, mode);
5473 }
5474
5475 GpStatus WINGDIPAPI GdipSetClipRegion(GpGraphics *graphics, GpRegion *region,
5476                                       CombineMode mode)
5477 {
5478     GpStatus status;
5479     GpRegion *clip;
5480
5481     TRACE("(%p, %p, %d)\n", graphics, region, mode);
5482
5483     if(!graphics || !region)
5484         return InvalidParameter;
5485
5486     if(graphics->busy)
5487         return ObjectBusy;
5488
5489     status = GdipCloneRegion(region, &clip);
5490     if (status == Ok)
5491     {
5492         GpMatrix world_to_device;
5493
5494         get_graphics_transform(graphics, CoordinateSpaceDevice, CoordinateSpaceWorld, &world_to_device);
5495         status = GdipTransformRegion(clip, &world_to_device);
5496         if (status == Ok)
5497             status = GdipCombineRegionRegion(graphics->clip, clip, mode);
5498
5499         GdipDeleteRegion(clip);
5500     }
5501     return status;
5502 }
5503
5504 GpStatus WINGDIPAPI GdipDrawPolygon(GpGraphics *graphics,GpPen *pen,GDIPCONST GpPointF *points,
5505     INT count)
5506 {
5507     INT save_state;
5508     POINT *pti;
5509
5510     TRACE("(%p, %p, %d)\n", graphics, points, count);
5511
5512     if(!graphics || !pen || count<=0)
5513         return InvalidParameter;
5514
5515     if(graphics->busy)
5516         return ObjectBusy;
5517
5518     if (!graphics->hdc)
5519     {
5520         FIXME("graphics object has no HDC\n");
5521         return Ok;
5522     }
5523
5524     pti = GdipAlloc(sizeof(POINT) * count);
5525
5526     save_state = prepare_dc(graphics, pen);
5527     SelectObject(graphics->hdc, GetStockObject(NULL_BRUSH));
5528
5529     transform_and_round_points(graphics, pti, (GpPointF*)points, count);
5530     Polygon(graphics->hdc, pti, count);
5531
5532     restore_dc(graphics, save_state);
5533     GdipFree(pti);
5534
5535     return Ok;
5536 }
5537
5538 GpStatus WINGDIPAPI GdipDrawPolygonI(GpGraphics *graphics,GpPen *pen,GDIPCONST GpPoint *points,
5539     INT count)
5540 {
5541     GpStatus ret;
5542     GpPointF *ptf;
5543     INT i;
5544
5545     TRACE("(%p, %p, %p, %d)\n", graphics, pen, points, count);
5546
5547     if(count<=0)    return InvalidParameter;
5548     ptf = GdipAlloc(sizeof(GpPointF) * count);
5549
5550     for(i = 0;i < count; i++){
5551         ptf[i].X = (REAL)points[i].X;
5552         ptf[i].Y = (REAL)points[i].Y;
5553     }
5554
5555     ret = GdipDrawPolygon(graphics,pen,ptf,count);
5556     GdipFree(ptf);
5557
5558     return ret;
5559 }
5560
5561 GpStatus WINGDIPAPI GdipGetDpiX(GpGraphics *graphics, REAL* dpi)
5562 {
5563     TRACE("(%p, %p)\n", graphics, dpi);
5564
5565     if(!graphics || !dpi)
5566         return InvalidParameter;
5567
5568     if(graphics->busy)
5569         return ObjectBusy;
5570
5571     *dpi = graphics->xres;
5572     return Ok;
5573 }
5574
5575 GpStatus WINGDIPAPI GdipGetDpiY(GpGraphics *graphics, REAL* dpi)
5576 {
5577     TRACE("(%p, %p)\n", graphics, dpi);
5578
5579     if(!graphics || !dpi)
5580         return InvalidParameter;
5581
5582     if(graphics->busy)
5583         return ObjectBusy;
5584
5585     *dpi = graphics->yres;
5586     return Ok;
5587 }
5588
5589 GpStatus WINGDIPAPI GdipMultiplyWorldTransform(GpGraphics *graphics, GDIPCONST GpMatrix *matrix,
5590     GpMatrixOrder order)
5591 {
5592     GpMatrix m;
5593     GpStatus ret;
5594
5595     TRACE("(%p, %p, %d)\n", graphics, matrix, order);
5596
5597     if(!graphics || !matrix)
5598         return InvalidParameter;
5599
5600     if(graphics->busy)
5601         return ObjectBusy;
5602
5603     m = graphics->worldtrans;
5604
5605     ret = GdipMultiplyMatrix(&m, matrix, order);
5606     if(ret == Ok)
5607         graphics->worldtrans = m;
5608
5609     return ret;
5610 }
5611
5612 /* Color used to fill bitmaps so we can tell which parts have been drawn over by gdi32. */
5613 static const COLORREF DC_BACKGROUND_KEY = 0x0c0b0d;
5614
5615 GpStatus WINGDIPAPI GdipGetDC(GpGraphics *graphics, HDC *hdc)
5616 {
5617     GpStatus stat=Ok;
5618
5619     TRACE("(%p, %p)\n", graphics, hdc);
5620
5621     if(!graphics || !hdc)
5622         return InvalidParameter;
5623
5624     if(graphics->busy)
5625         return ObjectBusy;
5626
5627     if (graphics->image && graphics->image->type == ImageTypeMetafile)
5628     {
5629         stat = METAFILE_GetDC((GpMetafile*)graphics->image, hdc);
5630     }
5631     else if (!graphics->hdc || graphics->alpha_hdc ||
5632         (graphics->image && graphics->image->type == ImageTypeBitmap && ((GpBitmap*)graphics->image)->format & PixelFormatAlpha))
5633     {
5634         /* Create a fake HDC and fill it with a constant color. */
5635         HDC temp_hdc;
5636         HBITMAP hbitmap;
5637         GpRectF bounds;
5638         BITMAPINFOHEADER bmih;
5639         int i;
5640
5641         stat = get_graphics_bounds(graphics, &bounds);
5642         if (stat != Ok)
5643             return stat;
5644
5645         graphics->temp_hbitmap_width = bounds.Width;
5646         graphics->temp_hbitmap_height = bounds.Height;
5647
5648         bmih.biSize = sizeof(bmih);
5649         bmih.biWidth = graphics->temp_hbitmap_width;
5650         bmih.biHeight = -graphics->temp_hbitmap_height;
5651         bmih.biPlanes = 1;
5652         bmih.biBitCount = 32;
5653         bmih.biCompression = BI_RGB;
5654         bmih.biSizeImage = 0;
5655         bmih.biXPelsPerMeter = 0;
5656         bmih.biYPelsPerMeter = 0;
5657         bmih.biClrUsed = 0;
5658         bmih.biClrImportant = 0;
5659
5660         hbitmap = CreateDIBSection(NULL, (BITMAPINFO*)&bmih, DIB_RGB_COLORS,
5661             (void**)&graphics->temp_bits, NULL, 0);
5662         if (!hbitmap)
5663             return GenericError;
5664
5665         temp_hdc = CreateCompatibleDC(0);
5666         if (!temp_hdc)
5667         {
5668             DeleteObject(hbitmap);
5669             return GenericError;
5670         }
5671
5672         for (i=0; i<(graphics->temp_hbitmap_width * graphics->temp_hbitmap_height); i++)
5673             ((DWORD*)graphics->temp_bits)[i] = DC_BACKGROUND_KEY;
5674
5675         SelectObject(temp_hdc, hbitmap);
5676
5677         graphics->temp_hbitmap = hbitmap;
5678         *hdc = graphics->temp_hdc = temp_hdc;
5679     }
5680     else
5681     {
5682         *hdc = graphics->hdc;
5683     }
5684
5685     if (stat == Ok)
5686         graphics->busy = TRUE;
5687
5688     return stat;
5689 }
5690
5691 GpStatus WINGDIPAPI GdipReleaseDC(GpGraphics *graphics, HDC hdc)
5692 {
5693     GpStatus stat=Ok;
5694
5695     TRACE("(%p, %p)\n", graphics, hdc);
5696
5697     if(!graphics || !hdc || !graphics->busy)
5698         return InvalidParameter;
5699
5700     if (graphics->image && graphics->image->type == ImageTypeMetafile)
5701     {
5702         stat = METAFILE_ReleaseDC((GpMetafile*)graphics->image, hdc);
5703     }
5704     else if (graphics->temp_hdc == hdc)
5705     {
5706         DWORD* pos;
5707         int i;
5708
5709         /* Find the pixels that have changed, and mark them as opaque. */
5710         pos = (DWORD*)graphics->temp_bits;
5711         for (i=0; i<(graphics->temp_hbitmap_width * graphics->temp_hbitmap_height); i++)
5712         {
5713             if (*pos != DC_BACKGROUND_KEY)
5714             {
5715                 *pos |= 0xff000000;
5716             }
5717             pos++;
5718         }
5719
5720         /* Write the changed pixels to the real target. */
5721         alpha_blend_pixels(graphics, 0, 0, graphics->temp_bits,
5722             graphics->temp_hbitmap_width, graphics->temp_hbitmap_height,
5723             graphics->temp_hbitmap_width * 4);
5724
5725         /* Clean up. */
5726         DeleteDC(graphics->temp_hdc);
5727         DeleteObject(graphics->temp_hbitmap);
5728         graphics->temp_hdc = NULL;
5729         graphics->temp_hbitmap = NULL;
5730     }
5731     else if (hdc != graphics->hdc)
5732     {
5733         stat = InvalidParameter;
5734     }
5735
5736     if (stat == Ok)
5737         graphics->busy = FALSE;
5738
5739     return stat;
5740 }
5741
5742 GpStatus WINGDIPAPI GdipGetClip(GpGraphics *graphics, GpRegion *region)
5743 {
5744     GpRegion *clip;
5745     GpStatus status;
5746     GpMatrix device_to_world;
5747
5748     TRACE("(%p, %p)\n", graphics, region);
5749
5750     if(!graphics || !region)
5751         return InvalidParameter;
5752
5753     if(graphics->busy)
5754         return ObjectBusy;
5755
5756     if((status = GdipCloneRegion(graphics->clip, &clip)) != Ok)
5757         return status;
5758
5759     get_graphics_transform(graphics, CoordinateSpaceWorld, CoordinateSpaceDevice, &device_to_world);
5760     status = GdipTransformRegion(clip, &device_to_world);
5761     if (status != Ok)
5762     {
5763         GdipDeleteRegion(clip);
5764         return status;
5765     }
5766
5767     /* free everything except root node and header */
5768     delete_element(&region->node);
5769     memcpy(region, clip, sizeof(GpRegion));
5770     GdipFree(clip);
5771
5772     return Ok;
5773 }
5774
5775 static GpStatus get_graphics_transform(GpGraphics *graphics, GpCoordinateSpace dst_space,
5776         GpCoordinateSpace src_space, GpMatrix *matrix)
5777 {
5778     GpStatus stat = Ok;
5779     REAL scale_x, scale_y;
5780
5781     GdipSetMatrixElements(matrix, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0);
5782
5783     if (dst_space != src_space)
5784     {
5785         scale_x = units_to_pixels(1.0, graphics->unit, graphics->xres);
5786         scale_y = units_to_pixels(1.0, graphics->unit, graphics->yres);
5787
5788         if(graphics->unit != UnitDisplay)
5789         {
5790             scale_x *= graphics->scale;
5791             scale_y *= graphics->scale;
5792         }
5793
5794         /* transform from src_space to CoordinateSpacePage */
5795         switch (src_space)
5796         {
5797         case CoordinateSpaceWorld:
5798             GdipMultiplyMatrix(matrix, &graphics->worldtrans, MatrixOrderAppend);
5799             break;
5800         case CoordinateSpacePage:
5801             break;
5802         case CoordinateSpaceDevice:
5803             GdipScaleMatrix(matrix, 1.0/scale_x, 1.0/scale_y, MatrixOrderAppend);
5804             break;
5805         }
5806
5807         /* transform from CoordinateSpacePage to dst_space */
5808         switch (dst_space)
5809         {
5810         case CoordinateSpaceWorld:
5811             {
5812                 GpMatrix inverted_transform = graphics->worldtrans;
5813                 stat = GdipInvertMatrix(&inverted_transform);
5814                 if (stat == Ok)
5815                     GdipMultiplyMatrix(matrix, &inverted_transform, MatrixOrderAppend);
5816                 break;
5817             }
5818         case CoordinateSpacePage:
5819             break;
5820         case CoordinateSpaceDevice:
5821             GdipScaleMatrix(matrix, scale_x, scale_y, MatrixOrderAppend);
5822             break;
5823         }
5824     }
5825     return stat;
5826 }
5827
5828 GpStatus WINGDIPAPI GdipTransformPoints(GpGraphics *graphics, GpCoordinateSpace dst_space,
5829                                         GpCoordinateSpace src_space, GpPointF *points, INT count)
5830 {
5831     GpMatrix matrix;
5832     GpStatus stat;
5833
5834     if(!graphics || !points || count <= 0)
5835         return InvalidParameter;
5836
5837     if(graphics->busy)
5838         return ObjectBusy;
5839
5840     TRACE("(%p, %d, %d, %p, %d)\n", graphics, dst_space, src_space, points, count);
5841
5842     if (src_space == dst_space) return Ok;
5843
5844     stat = get_graphics_transform(graphics, dst_space, src_space, &matrix);
5845     if (stat != Ok) return stat;
5846
5847     return GdipTransformMatrixPoints(&matrix, points, count);
5848 }
5849
5850 GpStatus WINGDIPAPI GdipTransformPointsI(GpGraphics *graphics, GpCoordinateSpace dst_space,
5851                                          GpCoordinateSpace src_space, GpPoint *points, INT count)
5852 {
5853     GpPointF *pointsF;
5854     GpStatus ret;
5855     INT i;
5856
5857     TRACE("(%p, %d, %d, %p, %d)\n", graphics, dst_space, src_space, points, count);
5858
5859     if(count <= 0)
5860         return InvalidParameter;
5861
5862     pointsF = GdipAlloc(sizeof(GpPointF) * count);
5863     if(!pointsF)
5864         return OutOfMemory;
5865
5866     for(i = 0; i < count; i++){
5867         pointsF[i].X = (REAL)points[i].X;
5868         pointsF[i].Y = (REAL)points[i].Y;
5869     }
5870
5871     ret = GdipTransformPoints(graphics, dst_space, src_space, pointsF, count);
5872
5873     if(ret == Ok)
5874         for(i = 0; i < count; i++){
5875             points[i].X = gdip_round(pointsF[i].X);
5876             points[i].Y = gdip_round(pointsF[i].Y);
5877         }
5878     GdipFree(pointsF);
5879
5880     return ret;
5881 }
5882
5883 HPALETTE WINGDIPAPI GdipCreateHalftonePalette(void)
5884 {
5885     static int calls;
5886
5887     TRACE("\n");
5888
5889     if (!calls++)
5890       FIXME("stub\n");
5891
5892     return NULL;
5893 }
5894
5895 /*****************************************************************************
5896  * GdipTranslateClip [GDIPLUS.@]
5897  */
5898 GpStatus WINGDIPAPI GdipTranslateClip(GpGraphics *graphics, REAL dx, REAL dy)
5899 {
5900     TRACE("(%p, %.2f, %.2f)\n", graphics, dx, dy);
5901
5902     if(!graphics)
5903         return InvalidParameter;
5904
5905     if(graphics->busy)
5906         return ObjectBusy;
5907
5908     return GdipTranslateRegion(graphics->clip, dx, dy);
5909 }
5910
5911 /*****************************************************************************
5912  * GdipTranslateClipI [GDIPLUS.@]
5913  */
5914 GpStatus WINGDIPAPI GdipTranslateClipI(GpGraphics *graphics, INT dx, INT dy)
5915 {
5916     TRACE("(%p, %d, %d)\n", graphics, dx, dy);
5917
5918     if(!graphics)
5919         return InvalidParameter;
5920
5921     if(graphics->busy)
5922         return ObjectBusy;
5923
5924     return GdipTranslateRegion(graphics->clip, (REAL)dx, (REAL)dy);
5925 }
5926
5927
5928 /*****************************************************************************
5929  * GdipMeasureDriverString [GDIPLUS.@]
5930  */
5931 GpStatus WINGDIPAPI GdipMeasureDriverString(GpGraphics *graphics, GDIPCONST UINT16 *text, INT length,
5932                                             GDIPCONST GpFont *font, GDIPCONST PointF *positions,
5933                                             INT flags, GDIPCONST GpMatrix *matrix, RectF *boundingBox)
5934 {
5935     static const INT unsupported_flags = ~(DriverStringOptionsCmapLookup|DriverStringOptionsRealizedAdvance);
5936     HFONT hfont;
5937     HDC hdc;
5938     REAL min_x, min_y, max_x, max_y, x, y;
5939     int i;
5940     TEXTMETRICW textmetric;
5941     const WORD *glyph_indices;
5942     WORD *dynamic_glyph_indices=NULL;
5943     REAL rel_width, rel_height, ascent, descent;
5944     GpPointF pt[3];
5945
5946     TRACE("(%p %p %d %p %p %d %p %p)\n", graphics, text, length, font, positions, flags, matrix, boundingBox);
5947
5948     if (!graphics || !text || !font || !positions || !boundingBox)
5949         return InvalidParameter;
5950
5951     if (length == -1)
5952         length = strlenW(text);
5953
5954     if (length == 0)
5955     {
5956         boundingBox->X = 0.0;
5957         boundingBox->Y = 0.0;
5958         boundingBox->Width = 0.0;
5959         boundingBox->Height = 0.0;
5960     }
5961
5962     if (flags & unsupported_flags)
5963         FIXME("Ignoring flags %x\n", flags & unsupported_flags);
5964
5965     get_font_hfont(graphics, font, NULL, &hfont, matrix);
5966
5967     hdc = CreateCompatibleDC(0);
5968     SelectObject(hdc, hfont);
5969
5970     GetTextMetricsW(hdc, &textmetric);
5971
5972     pt[0].X = 0.0;
5973     pt[0].Y = 0.0;
5974     pt[1].X = 1.0;
5975     pt[1].Y = 0.0;
5976     pt[2].X = 0.0;
5977     pt[2].Y = 1.0;
5978     if (matrix)
5979     {
5980         GpMatrix xform = *matrix;
5981         GdipTransformMatrixPoints(&xform, pt, 3);
5982     }
5983     GdipTransformPoints(graphics, CoordinateSpaceDevice, CoordinateSpaceWorld, pt, 3);
5984     rel_width = sqrt((pt[1].Y-pt[0].Y)*(pt[1].Y-pt[0].Y)+
5985                      (pt[1].X-pt[0].X)*(pt[1].X-pt[0].X));
5986     rel_height = sqrt((pt[2].Y-pt[0].Y)*(pt[2].Y-pt[0].Y)+
5987                       (pt[2].X-pt[0].X)*(pt[2].X-pt[0].X));
5988
5989     if (flags & DriverStringOptionsCmapLookup)
5990     {
5991         glyph_indices = dynamic_glyph_indices = GdipAlloc(sizeof(WORD) * length);
5992         if (!glyph_indices)
5993         {
5994             DeleteDC(hdc);
5995             DeleteObject(hfont);
5996             return OutOfMemory;
5997         }
5998
5999         GetGlyphIndicesW(hdc, text, length, dynamic_glyph_indices, 0);
6000     }
6001     else
6002         glyph_indices = text;
6003
6004     min_x = max_x = x = positions[0].X;
6005     min_y = max_y = y = positions[0].Y;
6006
6007     ascent = textmetric.tmAscent / rel_height;
6008     descent = textmetric.tmDescent / rel_height;
6009
6010     for (i=0; i<length; i++)
6011     {
6012         int char_width;
6013         ABC abc;
6014
6015         if (!(flags & DriverStringOptionsRealizedAdvance))
6016         {
6017             x = positions[i].X;
6018             y = positions[i].Y;
6019         }
6020
6021         GetCharABCWidthsW(hdc, glyph_indices[i], glyph_indices[i], &abc);
6022         char_width = abc.abcA + abc.abcB + abc.abcC;
6023
6024         if (min_y > y - ascent) min_y = y - ascent;
6025         if (max_y < y + descent) max_y = y + descent;
6026         if (min_x > x) min_x = x;
6027
6028         x += char_width / rel_width;
6029
6030         if (max_x < x) max_x = x;
6031     }
6032
6033     GdipFree(dynamic_glyph_indices);
6034     DeleteDC(hdc);
6035     DeleteObject(hfont);
6036
6037     boundingBox->X = min_x;
6038     boundingBox->Y = min_y;
6039     boundingBox->Width = max_x - min_x;
6040     boundingBox->Height = max_y - min_y;
6041
6042     return Ok;
6043 }
6044
6045 static GpStatus GDI32_GdipDrawDriverString(GpGraphics *graphics, GDIPCONST UINT16 *text, INT length,
6046                                            GDIPCONST GpFont *font, GDIPCONST GpStringFormat *format,
6047                                            GDIPCONST GpBrush *brush, GDIPCONST PointF *positions,
6048                                            INT flags, GDIPCONST GpMatrix *matrix)
6049 {
6050     static const INT unsupported_flags = ~(DriverStringOptionsRealizedAdvance|DriverStringOptionsCmapLookup);
6051     INT save_state;
6052     GpPointF pt;
6053     HFONT hfont;
6054     UINT eto_flags=0;
6055
6056     if (flags & unsupported_flags)
6057         FIXME("Ignoring flags %x\n", flags & unsupported_flags);
6058
6059     if (!(flags & DriverStringOptionsCmapLookup))
6060         eto_flags |= ETO_GLYPH_INDEX;
6061
6062     save_state = SaveDC(graphics->hdc);
6063     SetBkMode(graphics->hdc, TRANSPARENT);
6064     SetTextColor(graphics->hdc, get_gdi_brush_color(brush));
6065
6066     pt = positions[0];
6067     GdipTransformPoints(graphics, CoordinateSpaceDevice, CoordinateSpaceWorld, &pt, 1);
6068
6069     get_font_hfont(graphics, font, format, &hfont, matrix);
6070     SelectObject(graphics->hdc, hfont);
6071
6072     SetTextAlign(graphics->hdc, TA_BASELINE|TA_LEFT);
6073
6074     ExtTextOutW(graphics->hdc, gdip_round(pt.X), gdip_round(pt.Y), eto_flags, NULL, text, length, NULL);
6075
6076     RestoreDC(graphics->hdc, save_state);
6077
6078     DeleteObject(hfont);
6079
6080     return Ok;
6081 }
6082
6083 static GpStatus SOFTWARE_GdipDrawDriverString(GpGraphics *graphics, GDIPCONST UINT16 *text, INT length,
6084                                         GDIPCONST GpFont *font, GDIPCONST GpStringFormat *format,
6085                                         GDIPCONST GpBrush *brush, GDIPCONST PointF *positions,
6086                                         INT flags, GDIPCONST GpMatrix *matrix)
6087 {
6088     static const INT unsupported_flags = ~(DriverStringOptionsCmapLookup|DriverStringOptionsRealizedAdvance);
6089     GpStatus stat;
6090     PointF *real_positions, real_position;
6091     POINT *pti;
6092     HFONT hfont;
6093     HDC hdc;
6094     int min_x=INT_MAX, min_y=INT_MAX, max_x=INT_MIN, max_y=INT_MIN, i, x, y;
6095     DWORD max_glyphsize=0;
6096     GLYPHMETRICS glyphmetrics;
6097     static const MAT2 identity = {{0,1}, {0,0}, {0,0}, {0,1}};
6098     BYTE *glyph_mask;
6099     BYTE *text_mask;
6100     int text_mask_stride;
6101     BYTE *pixel_data;
6102     int pixel_data_stride;
6103     GpRect pixel_area;
6104     UINT ggo_flags = GGO_GRAY8_BITMAP;
6105
6106     if (length <= 0)
6107         return Ok;
6108
6109     if (!(flags & DriverStringOptionsCmapLookup))
6110         ggo_flags |= GGO_GLYPH_INDEX;
6111
6112     if (flags & unsupported_flags)
6113         FIXME("Ignoring flags %x\n", flags & unsupported_flags);
6114
6115     pti = GdipAlloc(sizeof(POINT) * length);
6116     if (!pti)
6117         return OutOfMemory;
6118
6119     if (flags & DriverStringOptionsRealizedAdvance)
6120     {
6121         real_position = positions[0];
6122
6123         transform_and_round_points(graphics, pti, &real_position, 1);
6124     }
6125     else
6126     {
6127         real_positions = GdipAlloc(sizeof(PointF) * length);
6128         if (!real_positions)
6129         {
6130             GdipFree(pti);
6131             return OutOfMemory;
6132         }
6133
6134         memcpy(real_positions, positions, sizeof(PointF) * length);
6135
6136         transform_and_round_points(graphics, pti, real_positions, length);
6137
6138         GdipFree(real_positions);
6139     }
6140
6141     get_font_hfont(graphics, font, format, &hfont, matrix);
6142
6143     hdc = CreateCompatibleDC(0);
6144     SelectObject(hdc, hfont);
6145
6146     /* Get the boundaries of the text to be drawn */
6147     for (i=0; i<length; i++)
6148     {
6149         DWORD glyphsize;
6150         int left, top, right, bottom;
6151
6152         glyphsize = GetGlyphOutlineW(hdc, text[i], ggo_flags,
6153             &glyphmetrics, 0, NULL, &identity);
6154
6155         if (glyphsize == GDI_ERROR)
6156         {
6157             ERR("GetGlyphOutlineW failed\n");
6158             GdipFree(pti);
6159             DeleteDC(hdc);
6160             DeleteObject(hfont);
6161             return GenericError;
6162         }
6163
6164         if (glyphsize > max_glyphsize)
6165             max_glyphsize = glyphsize;
6166
6167         if (glyphsize != 0)
6168         {
6169             left = pti[i].x + glyphmetrics.gmptGlyphOrigin.x;
6170             top = pti[i].y - glyphmetrics.gmptGlyphOrigin.y;
6171             right = pti[i].x + glyphmetrics.gmptGlyphOrigin.x + glyphmetrics.gmBlackBoxX;
6172             bottom = pti[i].y - glyphmetrics.gmptGlyphOrigin.y + glyphmetrics.gmBlackBoxY;
6173
6174             if (left < min_x) min_x = left;
6175             if (top < min_y) min_y = top;
6176             if (right > max_x) max_x = right;
6177             if (bottom > max_y) max_y = bottom;
6178         }
6179
6180         if (i+1 < length && (flags & DriverStringOptionsRealizedAdvance) == DriverStringOptionsRealizedAdvance)
6181         {
6182             pti[i+1].x = pti[i].x + glyphmetrics.gmCellIncX;
6183             pti[i+1].y = pti[i].y + glyphmetrics.gmCellIncY;
6184         }
6185     }
6186
6187     if (max_glyphsize == 0)
6188         /* Nothing to draw. */
6189         return Ok;
6190
6191     glyph_mask = GdipAlloc(max_glyphsize);
6192     text_mask = GdipAlloc((max_x - min_x) * (max_y - min_y));
6193     text_mask_stride = max_x - min_x;
6194
6195     if (!(glyph_mask && text_mask))
6196     {
6197         GdipFree(glyph_mask);
6198         GdipFree(text_mask);
6199         GdipFree(pti);
6200         DeleteDC(hdc);
6201         DeleteObject(hfont);
6202         return OutOfMemory;
6203     }
6204
6205     /* Generate a mask for the text */
6206     for (i=0; i<length; i++)
6207     {
6208         DWORD ret;
6209         int left, top, stride;
6210
6211         ret = GetGlyphOutlineW(hdc, text[i], ggo_flags,
6212             &glyphmetrics, max_glyphsize, glyph_mask, &identity);
6213
6214         if (ret == GDI_ERROR || ret == 0)
6215             continue; /* empty glyph */
6216
6217         left = pti[i].x + glyphmetrics.gmptGlyphOrigin.x;
6218         top = pti[i].y - glyphmetrics.gmptGlyphOrigin.y;
6219         stride = (glyphmetrics.gmBlackBoxX + 3) & (~3);
6220
6221         for (y=0; y<glyphmetrics.gmBlackBoxY; y++)
6222         {
6223             BYTE *glyph_val = glyph_mask + y * stride;
6224             BYTE *text_val = text_mask + (left - min_x) + (top - min_y + y) * text_mask_stride;
6225             for (x=0; x<glyphmetrics.gmBlackBoxX; x++)
6226             {
6227                 *text_val = min(64, *text_val + *glyph_val);
6228                 glyph_val++;
6229                 text_val++;
6230             }
6231         }
6232     }
6233
6234     GdipFree(pti);
6235     DeleteDC(hdc);
6236     DeleteObject(hfont);
6237     GdipFree(glyph_mask);
6238
6239     /* get the brush data */
6240     pixel_data = GdipAlloc(4 * (max_x - min_x) * (max_y - min_y));
6241     if (!pixel_data)
6242     {
6243         GdipFree(text_mask);
6244         return OutOfMemory;
6245     }
6246
6247     pixel_area.X = min_x;
6248     pixel_area.Y = min_y;
6249     pixel_area.Width = max_x - min_x;
6250     pixel_area.Height = max_y - min_y;
6251     pixel_data_stride = pixel_area.Width * 4;
6252
6253     stat = brush_fill_pixels(graphics, (GpBrush*)brush, (DWORD*)pixel_data, &pixel_area, pixel_area.Width);
6254     if (stat != Ok)
6255     {
6256         GdipFree(text_mask);
6257         GdipFree(pixel_data);
6258         return stat;
6259     }
6260
6261     /* multiply the brush data by the mask */
6262     for (y=0; y<pixel_area.Height; y++)
6263     {
6264         BYTE *text_val = text_mask + text_mask_stride * y;
6265         BYTE *pixel_val = pixel_data + pixel_data_stride * y + 3;
6266         for (x=0; x<pixel_area.Width; x++)
6267         {
6268             *pixel_val = (*pixel_val) * (*text_val) / 64;
6269             text_val++;
6270             pixel_val+=4;
6271         }
6272     }
6273
6274     GdipFree(text_mask);
6275
6276     /* draw the result */
6277     stat = alpha_blend_pixels(graphics, min_x, min_y, pixel_data, pixel_area.Width,
6278         pixel_area.Height, pixel_data_stride);
6279
6280     GdipFree(pixel_data);
6281
6282     return stat;
6283 }
6284
6285 static GpStatus draw_driver_string(GpGraphics *graphics, GDIPCONST UINT16 *text, INT length,
6286                                    GDIPCONST GpFont *font, GDIPCONST GpStringFormat *format,
6287                                    GDIPCONST GpBrush *brush, GDIPCONST PointF *positions,
6288                                    INT flags, GDIPCONST GpMatrix *matrix)
6289 {
6290     GpStatus stat = NotImplemented;
6291
6292     if (length == -1)
6293         length = strlenW(text);
6294
6295     if (graphics->hdc && !graphics->alpha_hdc &&
6296         ((flags & DriverStringOptionsRealizedAdvance) || length <= 1) &&
6297         brush->bt == BrushTypeSolidColor &&
6298         (((GpSolidFill*)brush)->color & 0xff000000) == 0xff000000)
6299         stat = GDI32_GdipDrawDriverString(graphics, text, length, font, format,
6300                                           brush, positions, flags, matrix);
6301     if (stat == NotImplemented)
6302         stat = SOFTWARE_GdipDrawDriverString(graphics, text, length, font, format,
6303                                              brush, positions, flags, matrix);
6304     return stat;
6305 }
6306
6307 /*****************************************************************************
6308  * GdipDrawDriverString [GDIPLUS.@]
6309  */
6310 GpStatus WINGDIPAPI GdipDrawDriverString(GpGraphics *graphics, GDIPCONST UINT16 *text, INT length,
6311                                          GDIPCONST GpFont *font, GDIPCONST GpBrush *brush,
6312                                          GDIPCONST PointF *positions, INT flags,
6313                                          GDIPCONST GpMatrix *matrix )
6314 {
6315     TRACE("(%p %s %p %p %p %d %p)\n", graphics, debugstr_wn(text, length), font, brush, positions, flags, matrix);
6316
6317     if (!graphics || !text || !font || !brush || !positions)
6318         return InvalidParameter;
6319
6320     return draw_driver_string(graphics, text, length, font, NULL,
6321                               brush, positions, flags, matrix);
6322 }
6323
6324 GpStatus WINGDIPAPI GdipRecordMetafileStream(IStream *stream, HDC hdc, EmfType type, GDIPCONST GpRect *frameRect,
6325                                         MetafileFrameUnit frameUnit, GDIPCONST WCHAR *desc, GpMetafile **metafile)
6326 {
6327     FIXME("(%p %p %d %p %d %p %p): stub\n", stream, hdc, type, frameRect, frameUnit, desc, metafile);
6328     return NotImplemented;
6329 }
6330
6331 /*****************************************************************************
6332  * GdipIsVisibleClipEmpty [GDIPLUS.@]
6333  */
6334 GpStatus WINGDIPAPI GdipIsVisibleClipEmpty(GpGraphics *graphics, BOOL *res)
6335 {
6336     GpStatus stat;
6337     GpRegion* rgn;
6338
6339     TRACE("(%p, %p)\n", graphics, res);
6340
6341     if((stat = GdipCreateRegion(&rgn)) != Ok)
6342         return stat;
6343
6344     if((stat = get_visible_clip_region(graphics, rgn)) != Ok)
6345         goto cleanup;
6346
6347     stat = GdipIsEmptyRegion(rgn, graphics, res);
6348
6349 cleanup:
6350     GdipDeleteRegion(rgn);
6351     return stat;
6352 }
6353
6354 GpStatus WINGDIPAPI GdipResetPageTransform(GpGraphics *graphics)
6355 {
6356     static int calls;
6357
6358     TRACE("(%p) stub\n", graphics);
6359
6360     if(!(calls++))
6361         FIXME("not implemented\n");
6362
6363     return NotImplemented;
6364 }