git.oblomov.eu Git - wine/blob - dlls/gdiplus/graphics.c

   1 /*
   2  * Copyright (C) 2007 Google (Evan Stade)
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include <stdarg.h>
  20 #include <math.h>
  21 #include <limits.h>
  22
  23 #include "windef.h"
  24 #include "winbase.h"
  25 #include "winuser.h"
  26 #include "wingdi.h"
  27 #include "wine/unicode.h"
  28
  29 #define COBJMACROS
  30 #include "objbase.h"
  31 #include "ocidl.h"
  32 #include "olectl.h"
  33 #include "ole2.h"
  34
  35 #include "winreg.h"
  36 #include "shlwapi.h"
  37
  38 #include "gdiplus.h"
  39 #include "gdiplus_private.h"
  40 #include "wine/debug.h"
  41 #include "wine/list.h"
  42
  43 WINE_DEFAULT_DEBUG_CHANNEL(gdiplus);
  44
  45 /* looks-right constants */
  46 #define ANCHOR_WIDTH (2.0)
  47 #define MAX_ITERS (50)
  48
  49 /* Converts angle (in degrees) to x/y coordinates */
  50 static void deg2xy(REAL angle, REAL x_0, REAL y_0, REAL *x, REAL *y)
  51 {
  52     REAL radAngle, hypotenuse;
  53
  54     radAngle = deg2rad(angle);
  55     hypotenuse = 50.0; /* arbitrary */
  56
  57     *x = x_0 + cos(radAngle) * hypotenuse;
  58     *y = y_0 + sin(radAngle) * hypotenuse;
  59 }
  60
  61 /* Converts from gdiplus path point type to gdi path point type. */
  62 static BYTE convert_path_point_type(BYTE type)
  63 {
  64     BYTE ret;
  65
  66     switch(type & PathPointTypePathTypeMask){
  67         case PathPointTypeBezier:
  68             ret = PT_BEZIERTO;
  69             break;
  70         case PathPointTypeLine:
  71             ret = PT_LINETO;
  72             break;
  73         case PathPointTypeStart:
  74             ret = PT_MOVETO;
  75             break;
  76         default:
  77             ERR("Bad point type\n");
  78             return 0;
  79     }
  80
  81     if(type & PathPointTypeCloseSubpath)
  82         ret |= PT_CLOSEFIGURE;
  83
  84     return ret;
  85 }
  86
  87 static REAL graphics_res(GpGraphics *graphics)
  88 {
  89     if (graphics->image) return graphics->image->xres;
  90     else return (REAL)GetDeviceCaps(graphics->hdc, LOGPIXELSX);
  91 }
  92
  93 static INT prepare_dc(GpGraphics *graphics, GpPen *pen)
  94 {
  95     HPEN gdipen;
  96     REAL width;
  97     INT save_state, i, numdashes;
  98     GpPointF pt[2];
  99     DWORD dash_array[MAX_DASHLEN];
 100
 101     if (!graphics->hdc)
 102     {
 103         FIXME("graphics object has no HDC\n");
 104     }
 105
 106     save_state = SaveDC(graphics->hdc);
 107
 108     EndPath(graphics->hdc);
 109
 110     if(pen->unit == UnitPixel){
 111         width = pen->width;
 112     }
 113     else{
 114         /* Get an estimate for the amount the pen width is affected by the world
 115          * transform. (This is similar to what some of the wine drivers do.) */
 116         pt[0].X = 0.0;
 117         pt[0].Y = 0.0;
 118         pt[1].X = 1.0;
 119         pt[1].Y = 1.0;
 120         GdipTransformMatrixPoints(graphics->worldtrans, pt, 2);
 121         width = sqrt((pt[1].X - pt[0].X) * (pt[1].X - pt[0].X) +
 122                      (pt[1].Y - pt[0].Y) * (pt[1].Y - pt[0].Y)) / sqrt(2.0);
 123
 124         width *= pen->width * convert_unit(graphics_res(graphics),
 125                               pen->unit == UnitWorld ? graphics->unit : pen->unit);
 126     }
 127
 128     if(pen->dash == DashStyleCustom){
 129         numdashes = min(pen->numdashes, MAX_DASHLEN);
 130
 131         TRACE("dashes are: ");
 132         for(i = 0; i < numdashes; i++){
 133             dash_array[i] = roundr(width * pen->dashes[i]);
 134             TRACE("%d, ", dash_array[i]);
 135         }
 136         TRACE("\n and the pen style is %x\n", pen->style);
 137
 138         gdipen = ExtCreatePen(pen->style, roundr(width), &pen->brush->lb,
 139                               numdashes, dash_array);
 140     }
 141     else
 142         gdipen = ExtCreatePen(pen->style, roundr(width), &pen->brush->lb, 0, NULL);
 143
 144     SelectObject(graphics->hdc, gdipen);
 145
 146     return save_state;
 147 }
 148
 149 static void restore_dc(GpGraphics *graphics, INT state)
 150 {
 151     DeleteObject(SelectObject(graphics->hdc, GetStockObject(NULL_PEN)));
 152     RestoreDC(graphics->hdc, state);
 153 }
 154
 155 /* This helper applies all the changes that the points listed in ptf need in
 156  * order to be drawn on the device context.  In the end, this should include at
 157  * least:
 158  *  -scaling by page unit
 159  *  -applying world transformation
 160  *  -converting from float to int
 161  * Native gdiplus uses gdi32 to do all this (via SetMapMode, SetViewportExtEx,
 162  * SetWindowExtEx, SetWorldTransform, etc.) but we cannot because we are using
 163  * gdi to draw, and these functions would irreparably mess with line widths.
 164  */
 165 static void transform_and_round_points(GpGraphics *graphics, POINT *pti,
 166     GpPointF *ptf, INT count)
 167 {
 168     REAL unitscale;
 169     GpMatrix *matrix;
 170     int i;
 171
 172     unitscale = convert_unit(graphics_res(graphics), graphics->unit);
 173
 174     /* apply page scale */
 175     if(graphics->unit != UnitDisplay)
 176         unitscale *= graphics->scale;
 177
 178     GdipCloneMatrix(graphics->worldtrans, &matrix);
 179     GdipScaleMatrix(matrix, unitscale, unitscale, MatrixOrderAppend);
 180     GdipTransformMatrixPoints(matrix, ptf, count);
 181     GdipDeleteMatrix(matrix);
 182
 183     for(i = 0; i < count; i++){
 184         pti[i].x = roundr(ptf[i].X);
 185         pti[i].y = roundr(ptf[i].Y);
 186     }
 187 }
 188
 189 /* Draw non-premultiplied ARGB data to the given graphics object */
 190 static GpStatus alpha_blend_pixels(GpGraphics *graphics, INT dst_x, INT dst_y,
 191     const BYTE *src, INT src_width, INT src_height, INT src_stride)
 192 {
 193     if (graphics->image && graphics->image->type == ImageTypeBitmap)
 194     {
 195         GpBitmap *dst_bitmap = (GpBitmap*)graphics->image;
 196         INT x, y;
 197
 198         for (x=0; x<src_width; x++)
 199         {
 200             for (y=0; y<src_height; y++)
 201             {
 202                 ARGB dst_color, src_color;
 203                 GdipBitmapGetPixel(dst_bitmap, x+dst_x, y+dst_y, &dst_color);
 204                 src_color = ((ARGB*)(src + src_stride * y))[x];
 205                 GdipBitmapSetPixel(dst_bitmap, x+dst_x, y+dst_y, color_over(dst_color, src_color));
 206             }
 207         }
 208
 209         return Ok;
 210     }
 211     else
 212     {
 213         HDC hdc;
 214         HBITMAP hbitmap, old_hbm=NULL;
 215         BITMAPINFOHEADER bih;
 216         BYTE *temp_bits;
 217         BLENDFUNCTION bf;
 218
 219         hdc = CreateCompatibleDC(0);
 220
 221         bih.biSize = sizeof(BITMAPINFOHEADER);
 222         bih.biWidth = src_width;
 223         bih.biHeight = -src_height;
 224         bih.biPlanes = 1;
 225         bih.biBitCount = 32;
 226         bih.biCompression = BI_RGB;
 227         bih.biSizeImage = 0;
 228         bih.biXPelsPerMeter = 0;
 229         bih.biYPelsPerMeter = 0;
 230         bih.biClrUsed = 0;
 231         bih.biClrImportant = 0;
 232
 233         hbitmap = CreateDIBSection(hdc, (BITMAPINFO*)&bih, DIB_RGB_COLORS,
 234             (void**)&temp_bits, NULL, 0);
 235
 236         convert_32bppARGB_to_32bppPARGB(src_width, src_height, temp_bits,
 237             4 * src_width, src, src_stride);
 238
 239         old_hbm = SelectObject(hdc, hbitmap);
 240
 241         bf.BlendOp = AC_SRC_OVER;
 242         bf.BlendFlags = 0;
 243         bf.SourceConstantAlpha = 255;
 244         bf.AlphaFormat = AC_SRC_ALPHA;
 245
 246         GdiAlphaBlend(graphics->hdc, dst_x, dst_y, src_width, src_height,
 247             hdc, 0, 0, src_width, src_height, bf);
 248
 249         SelectObject(hdc, old_hbm);
 250         DeleteDC(hdc);
 251         DeleteObject(hbitmap);
 252
 253         return Ok;
 254     }
 255 }
 256
 257 static ARGB blend_colors(ARGB start, ARGB end, REAL position)
 258 {
 259     ARGB result=0;
 260     ARGB i;
 261     for (i=0xff; i<=0xff0000; i = i << 8)
 262         result |= (int)((start&i)*(1.0f - position)+(end&i)*(position))&i;
 263     return result;
 264 }
 265
 266 static ARGB blend_line_gradient(GpLineGradient* brush, REAL position)
 267 {
 268     REAL blendfac;
 269
 270     /* clamp to between 0.0 and 1.0, using the wrap mode */
 271     if (brush->wrap == WrapModeTile)
 272     {
 273         position = fmodf(position, 1.0f);
 274         if (position < 0.0f) position += 1.0f;
 275     }
 276     else /* WrapModeFlip* */
 277     {
 278         position = fmodf(position, 2.0f);
 279         if (position < 0.0f) position += 2.0f;
 280         if (position > 1.0f) position = 2.0f - position;
 281     }
 282
 283     if (brush->blendcount == 1)
 284         blendfac = position;
 285     else
 286     {
 287         int i=1;
 288         REAL left_blendpos, left_blendfac, right_blendpos, right_blendfac;
 289         REAL range;
 290
 291         /* locate the blend positions surrounding this position */
 292         while (position > brush->blendpos[i])
 293             i++;
 294
 295         /* interpolate between the blend positions */
 296         left_blendpos = brush->blendpos[i-1];
 297         left_blendfac = brush->blendfac[i-1];
 298         right_blendpos = brush->blendpos[i];
 299         right_blendfac = brush->blendfac[i];
 300         range = right_blendpos - left_blendpos;
 301         blendfac = (left_blendfac * (right_blendpos - position) +
 302                     right_blendfac * (position - left_blendpos)) / range;
 303     }
 304
 305     if (brush->pblendcount == 0)
 306         return blend_colors(brush->startcolor, brush->endcolor, blendfac);
 307     else
 308     {
 309         int i=1;
 310         ARGB left_blendcolor, right_blendcolor;
 311         REAL left_blendpos, right_blendpos;
 312
 313         /* locate the blend colors surrounding this position */
 314         while (blendfac > brush->pblendpos[i])
 315             i++;
 316
 317         /* interpolate between the blend colors */
 318         left_blendpos = brush->pblendpos[i-1];
 319         left_blendcolor = brush->pblendcolor[i-1];
 320         right_blendpos = brush->pblendpos[i];
 321         right_blendcolor = brush->pblendcolor[i];
 322         blendfac = (blendfac - left_blendpos) / (right_blendpos - left_blendpos);
 323         return blend_colors(left_blendcolor, right_blendcolor, blendfac);
 324     }
 325 }
 326
 327 static void brush_fill_path(GpGraphics *graphics, GpBrush* brush)
 328 {
 329     switch (brush->bt)
 330     {
 331     case BrushTypeLinearGradient:
 332     {
 333         GpLineGradient *line = (GpLineGradient*)brush;
 334         RECT rc;
 335
 336         SelectClipPath(graphics->hdc, RGN_AND);
 337         if (GetClipBox(graphics->hdc, &rc) != NULLREGION)
 338         {
 339             GpPointF endpointsf[2];
 340             POINT endpointsi[2];
 341             POINT poly[4];
 342
 343             SelectObject(graphics->hdc, GetStockObject(NULL_PEN));
 344
 345             endpointsf[0] = line->startpoint;
 346             endpointsf[1] = line->endpoint;
 347             transform_and_round_points(graphics, endpointsi, endpointsf, 2);
 348
 349             if (abs(endpointsi[0].x-endpointsi[1].x) > abs(endpointsi[0].y-endpointsi[1].y))
 350             {
 351                 /* vertical-ish gradient */
 352                 int startx, endx; /* x co-ordinates of endpoints shifted to intersect the top of the visible rectangle */
 353                 int startbottomx; /* x co-ordinate of start point shifted to intersect the bottom of the visible rectangle */
 354                 int width;
 355                 COLORREF col;
 356                 HBRUSH hbrush, hprevbrush;
 357                 int leftx, rightx; /* x co-ordinates where the leftmost and rightmost gradient lines hit the top of the visible rectangle */
 358                 int x;
 359                 int tilt; /* horizontal distance covered by a gradient line */
 360
 361                 startx = roundr((rc.top - endpointsf[0].Y) * (endpointsf[1].Y - endpointsf[0].Y) / (endpointsf[0].X - endpointsf[1].X) + endpointsf[0].X);
 362                 endx = roundr((rc.top - endpointsf[1].Y) * (endpointsf[1].Y - endpointsf[0].Y) / (endpointsf[0].X - endpointsf[1].X) + endpointsf[1].X);
 363                 width = endx - startx;
 364                 startbottomx = roundr((rc.bottom - endpointsf[0].Y) * (endpointsf[1].Y - endpointsf[0].Y) / (endpointsf[0].X - endpointsf[1].X) + endpointsf[0].X);
 365                 tilt = startx - startbottomx;
 366
 367                 if (startx >= startbottomx)
 368                 {
 369                     leftx = rc.left;
 370                     rightx = rc.right + tilt;
 371                 }
 372                 else
 373                 {
 374                     leftx = rc.left + tilt;
 375                     rightx = rc.right;
 376                 }
 377
 378                 poly[0].y = rc.bottom;
 379                 poly[1].y = rc.top;
 380                 poly[2].y = rc.top;
 381                 poly[3].y = rc.bottom;
 382
 383                 for (x=leftx; x<=rightx; x++)
 384                 {
 385                     ARGB argb = blend_line_gradient(line, (x-startx)/(REAL)width);
 386                     col = ARGB2COLORREF(argb);
 387                     hbrush = CreateSolidBrush(col);
 388                     hprevbrush = SelectObject(graphics->hdc, hbrush);
 389                     poly[0].x = x - tilt - 1;
 390                     poly[1].x = x - 1;
 391                     poly[2].x = x;
 392                     poly[3].x = x - tilt;
 393                     Polygon(graphics->hdc, poly, 4);
 394                     SelectObject(graphics->hdc, hprevbrush);
 395                     DeleteObject(hbrush);
 396                 }
 397             }
 398             else if (endpointsi[0].y != endpointsi[1].y)
 399             {
 400                 /* horizontal-ish gradient */
 401                 int starty, endy; /* y co-ordinates of endpoints shifted to intersect the left of the visible rectangle */
 402                 int startrighty; /* y co-ordinate of start point shifted to intersect the right of the visible rectangle */
 403                 int height;
 404                 COLORREF col;
 405                 HBRUSH hbrush, hprevbrush;
 406                 int topy, bottomy; /* y co-ordinates where the topmost and bottommost gradient lines hit the left of the visible rectangle */
 407                 int y;
 408                 int tilt; /* vertical distance covered by a gradient line */
 409
 410                 starty = roundr((rc.left - endpointsf[0].X) * (endpointsf[0].X - endpointsf[1].X) / (endpointsf[1].Y - endpointsf[0].Y) + endpointsf[0].Y);
 411                 endy = roundr((rc.left - endpointsf[1].X) * (endpointsf[0].X - endpointsf[1].X) / (endpointsf[1].Y - endpointsf[0].Y) + endpointsf[1].Y);
 412                 height = endy - starty;
 413                 startrighty = roundr((rc.right - endpointsf[0].X) * (endpointsf[0].X - endpointsf[1].X) / (endpointsf[1].Y - endpointsf[0].Y) + endpointsf[0].Y);
 414                 tilt = starty - startrighty;
 415
 416                 if (starty >= startrighty)
 417                 {
 418                     topy = rc.top;
 419                     bottomy = rc.bottom + tilt;
 420                 }
 421                 else
 422                 {
 423                     topy = rc.top + tilt;
 424                     bottomy = rc.bottom;
 425                 }
 426
 427                 poly[0].x = rc.right;
 428                 poly[1].x = rc.left;
 429                 poly[2].x = rc.left;
 430                 poly[3].x = rc.right;
 431
 432                 for (y=topy; y<=bottomy; y++)
 433                 {
 434                     ARGB argb = blend_line_gradient(line, (y-starty)/(REAL)height);
 435                     col = ARGB2COLORREF(argb);
 436                     hbrush = CreateSolidBrush(col);
 437                     hprevbrush = SelectObject(graphics->hdc, hbrush);
 438                     poly[0].y = y - tilt - 1;
 439                     poly[1].y = y - 1;
 440                     poly[2].y = y;
 441                     poly[3].y = y - tilt;
 442                     Polygon(graphics->hdc, poly, 4);
 443                     SelectObject(graphics->hdc, hprevbrush);
 444                     DeleteObject(hbrush);
 445                 }
 446             }
 447             /* else startpoint == endpoint */
 448         }
 449         break;
 450     }
 451     case BrushTypeSolidColor:
 452     {
 453         GpSolidFill *fill = (GpSolidFill*)brush;
 454         if (fill->bmp)
 455         {
 456             RECT rc;
 457             /* partially transparent fill */
 458
 459             SelectClipPath(graphics->hdc, RGN_AND);
 460             if (GetClipBox(graphics->hdc, &rc) != NULLREGION)
 461             {
 462                 HDC hdc = CreateCompatibleDC(NULL);
 463                 HBITMAP oldbmp;
 464                 BLENDFUNCTION bf;
 465
 466                 if (!hdc) break;
 467
 468                 oldbmp = SelectObject(hdc, fill->bmp);
 469
 470                 bf.BlendOp = AC_SRC_OVER;
 471                 bf.BlendFlags = 0;
 472                 bf.SourceConstantAlpha = 255;
 473                 bf.AlphaFormat = AC_SRC_ALPHA;
 474
 475                 GdiAlphaBlend(graphics->hdc, rc.left, rc.top, rc.right-rc.left, rc.bottom-rc.top, hdc, 0, 0, 1, 1, bf);
 476
 477                 SelectObject(hdc, oldbmp);
 478                 DeleteDC(hdc);
 479             }
 480
 481             break;
 482         }
 483         /* else fall through */
 484     }
 485     default:
 486         SelectObject(graphics->hdc, brush->gdibrush);
 487         FillPath(graphics->hdc);
 488         break;
 489     }
 490 }
 491
 492 /* GdipDrawPie/GdipFillPie helper function */
 493 static void draw_pie(GpGraphics *graphics, REAL x, REAL y, REAL width,
 494     REAL height, REAL startAngle, REAL sweepAngle)
 495 {
 496     GpPointF ptf[4];
 497     POINT pti[4];
 498
 499     ptf[0].X = x;
 500     ptf[0].Y = y;
 501     ptf[1].X = x + width;
 502     ptf[1].Y = y + height;
 503
 504     deg2xy(startAngle+sweepAngle, x + width / 2.0, y + width / 2.0, &ptf[2].X, &ptf[2].Y);
 505     deg2xy(startAngle, x + width / 2.0, y + width / 2.0, &ptf[3].X, &ptf[3].Y);
 506
 507     transform_and_round_points(graphics, pti, ptf, 4);
 508
 509     Pie(graphics->hdc, pti[0].x, pti[0].y, pti[1].x, pti[1].y, pti[2].x,
 510         pti[2].y, pti[3].x, pti[3].y);
 511 }
 512
 513 /* Draws the linecap the specified color and size on the hdc.  The linecap is in
 514  * direction of the line from x1, y1 to x2, y2 and is anchored on x2, y2. Probably
 515  * should not be called on an hdc that has a path you care about. */
 516 static void draw_cap(GpGraphics *graphics, COLORREF color, GpLineCap cap, REAL size,
 517     const GpCustomLineCap *custom, REAL x1, REAL y1, REAL x2, REAL y2)
 518 {
 519     HGDIOBJ oldbrush = NULL, oldpen = NULL;
 520     GpMatrix *matrix = NULL;
 521     HBRUSH brush = NULL;
 522     HPEN pen = NULL;
 523     PointF ptf[4], *custptf = NULL;
 524     POINT pt[4], *custpt = NULL;
 525     BYTE *tp = NULL;
 526     REAL theta, dsmall, dbig, dx, dy = 0.0;
 527     INT i, count;
 528     LOGBRUSH lb;
 529     BOOL customstroke;
 530
 531     if((x1 == x2) && (y1 == y2))
 532         return;
 533
 534     theta = gdiplus_atan2(y2 - y1, x2 - x1);
 535
 536     customstroke = (cap == LineCapCustom) && custom && (!custom->fill);
 537     if(!customstroke){
 538         brush = CreateSolidBrush(color);
 539         lb.lbStyle = BS_SOLID;
 540         lb.lbColor = color;
 541         lb.lbHatch = 0;
 542         pen = ExtCreatePen(PS_GEOMETRIC | PS_SOLID | PS_ENDCAP_FLAT |
 543                            PS_JOIN_MITER, 1, &lb, 0,
 544                            NULL);
 545         oldbrush = SelectObject(graphics->hdc, brush);
 546         oldpen = SelectObject(graphics->hdc, pen);
 547     }
 548
 549     switch(cap){
 550         case LineCapFlat:
 551             break;
 552         case LineCapSquare:
 553         case LineCapSquareAnchor:
 554         case LineCapDiamondAnchor:
 555             size = size * (cap & LineCapNoAnchor ? ANCHOR_WIDTH : 1.0) / 2.0;
 556             if(cap == LineCapDiamondAnchor){
 557                 dsmall = cos(theta + M_PI_2) * size;
 558                 dbig = sin(theta + M_PI_2) * size;
 559             }
 560             else{
 561                 dsmall = cos(theta + M_PI_4) * size;
 562                 dbig = sin(theta + M_PI_4) * size;
 563             }
 564
 565             ptf[0].X = x2 - dsmall;
 566             ptf[1].X = x2 + dbig;
 567
 568             ptf[0].Y = y2 - dbig;
 569             ptf[3].Y = y2 + dsmall;
 570
 571             ptf[1].Y = y2 - dsmall;
 572             ptf[2].Y = y2 + dbig;
 573
 574             ptf[3].X = x2 - dbig;
 575             ptf[2].X = x2 + dsmall;
 576
 577             transform_and_round_points(graphics, pt, ptf, 4);
 578             Polygon(graphics->hdc, pt, 4);
 579
 580             break;
 581         case LineCapArrowAnchor:
 582             size = size * 4.0 / sqrt(3.0);
 583
 584             dx = cos(M_PI / 6.0 + theta) * size;
 585             dy = sin(M_PI / 6.0 + theta) * size;
 586
 587             ptf[0].X = x2 - dx;
 588             ptf[0].Y = y2 - dy;
 589
 590             dx = cos(- M_PI / 6.0 + theta) * size;
 591             dy = sin(- M_PI / 6.0 + theta) * size;
 592
 593             ptf[1].X = x2 - dx;
 594             ptf[1].Y = y2 - dy;
 595
 596             ptf[2].X = x2;
 597             ptf[2].Y = y2;
 598
 599             transform_and_round_points(graphics, pt, ptf, 3);
 600             Polygon(graphics->hdc, pt, 3);
 601
 602             break;
 603         case LineCapRoundAnchor:
 604             dx = dy = ANCHOR_WIDTH * size / 2.0;
 605
 606             ptf[0].X = x2 - dx;
 607             ptf[0].Y = y2 - dy;
 608             ptf[1].X = x2 + dx;
 609             ptf[1].Y = y2 + dy;
 610
 611             transform_and_round_points(graphics, pt, ptf, 2);
 612             Ellipse(graphics->hdc, pt[0].x, pt[0].y, pt[1].x, pt[1].y);
 613
 614             break;
 615         case LineCapTriangle:
 616             size = size / 2.0;
 617             dx = cos(M_PI_2 + theta) * size;
 618             dy = sin(M_PI_2 + theta) * size;
 619
 620             ptf[0].X = x2 - dx;
 621             ptf[0].Y = y2 - dy;
 622             ptf[1].X = x2 + dx;
 623             ptf[1].Y = y2 + dy;
 624
 625             dx = cos(theta) * size;
 626             dy = sin(theta) * size;
 627
 628             ptf[2].X = x2 + dx;
 629             ptf[2].Y = y2 + dy;
 630
 631             transform_and_round_points(graphics, pt, ptf, 3);
 632             Polygon(graphics->hdc, pt, 3);
 633
 634             break;
 635         case LineCapRound:
 636             dx = dy = size / 2.0;
 637
 638             ptf[0].X = x2 - dx;
 639             ptf[0].Y = y2 - dy;
 640             ptf[1].X = x2 + dx;
 641             ptf[1].Y = y2 + dy;
 642
 643             dx = -cos(M_PI_2 + theta) * size;
 644             dy = -sin(M_PI_2 + theta) * size;
 645
 646             ptf[2].X = x2 - dx;
 647             ptf[2].Y = y2 - dy;
 648             ptf[3].X = x2 + dx;
 649             ptf[3].Y = y2 + dy;
 650
 651             transform_and_round_points(graphics, pt, ptf, 4);
 652             Pie(graphics->hdc, pt[0].x, pt[0].y, pt[1].x, pt[1].y, pt[2].x,
 653                 pt[2].y, pt[3].x, pt[3].y);
 654
 655             break;
 656         case LineCapCustom:
 657             if(!custom)
 658                 break;
 659
 660             count = custom->pathdata.Count;
 661             custptf = GdipAlloc(count * sizeof(PointF));
 662             custpt = GdipAlloc(count * sizeof(POINT));
 663             tp = GdipAlloc(count);
 664
 665             if(!custptf || !custpt || !tp || (GdipCreateMatrix(&matrix) != Ok))
 666                 goto custend;
 667
 668             memcpy(custptf, custom->pathdata.Points, count * sizeof(PointF));
 669
 670             GdipScaleMatrix(matrix, size, size, MatrixOrderAppend);
 671             GdipRotateMatrix(matrix, (180.0 / M_PI) * (theta - M_PI_2),
 672                              MatrixOrderAppend);
 673             GdipTranslateMatrix(matrix, x2, y2, MatrixOrderAppend);
 674             GdipTransformMatrixPoints(matrix, custptf, count);
 675
 676             transform_and_round_points(graphics, custpt, custptf, count);
 677
 678             for(i = 0; i < count; i++)
 679                 tp[i] = convert_path_point_type(custom->pathdata.Types[i]);
 680
 681             if(custom->fill){
 682                 BeginPath(graphics->hdc);
 683                 PolyDraw(graphics->hdc, custpt, tp, count);
 684                 EndPath(graphics->hdc);
 685                 StrokeAndFillPath(graphics->hdc);
 686             }
 687             else
 688                 PolyDraw(graphics->hdc, custpt, tp, count);
 689
 690 custend:
 691             GdipFree(custptf);
 692             GdipFree(custpt);
 693             GdipFree(tp);
 694             GdipDeleteMatrix(matrix);
 695             break;
 696         default:
 697             break;
 698     }
 699
 700     if(!customstroke){
 701         SelectObject(graphics->hdc, oldbrush);
 702         SelectObject(graphics->hdc, oldpen);
 703         DeleteObject(brush);
 704         DeleteObject(pen);
 705     }
 706 }
 707
 708 /* Shortens the line by the given percent by changing x2, y2.
 709  * If percent is > 1.0 then the line will change direction.
 710  * If percent is negative it can lengthen the line. */
 711 static void shorten_line_percent(REAL x1, REAL  y1, REAL *x2, REAL *y2, REAL percent)
 712 {
 713     REAL dist, theta, dx, dy;
 714
 715     if((y1 == *y2) && (x1 == *x2))
 716         return;
 717
 718     dist = sqrt((*x2 - x1) * (*x2 - x1) + (*y2 - y1) * (*y2 - y1)) * -percent;
 719     theta = gdiplus_atan2((*y2 - y1), (*x2 - x1));
 720     dx = cos(theta) * dist;
 721     dy = sin(theta) * dist;
 722
 723     *x2 = *x2 + dx;
 724     *y2 = *y2 + dy;
 725 }
 726
 727 /* Shortens the line by the given amount by changing x2, y2.
 728  * If the amount is greater than the distance, the line will become length 0.
 729  * If the amount is negative, it can lengthen the line. */
 730 static void shorten_line_amt(REAL x1, REAL y1, REAL *x2, REAL *y2, REAL amt)
 731 {
 732     REAL dx, dy, percent;
 733
 734     dx = *x2 - x1;
 735     dy = *y2 - y1;
 736     if(dx == 0 && dy == 0)
 737         return;
 738
 739     percent = amt / sqrt(dx * dx + dy * dy);
 740     if(percent >= 1.0){
 741         *x2 = x1;
 742         *y2 = y1;
 743         return;
 744     }
 745
 746     shorten_line_percent(x1, y1, x2, y2, percent);
 747 }
 748
 749 /* Draws lines between the given points, and if caps is true then draws an endcap
 750  * at the end of the last line. */
 751 static GpStatus draw_polyline(GpGraphics *graphics, GpPen *pen,
 752     GDIPCONST GpPointF * pt, INT count, BOOL caps)
 753 {
 754     POINT *pti = NULL;
 755     GpPointF *ptcopy = NULL;
 756     GpStatus status = GenericError;
 757
 758     if(!count)
 759         return Ok;
 760
 761     pti = GdipAlloc(count * sizeof(POINT));
 762     ptcopy = GdipAlloc(count * sizeof(GpPointF));
 763
 764     if(!pti || !ptcopy){
 765         status = OutOfMemory;
 766         goto end;
 767     }
 768
 769     memcpy(ptcopy, pt, count * sizeof(GpPointF));
 770
 771     if(caps){
 772         if(pen->endcap == LineCapArrowAnchor)
 773             shorten_line_amt(ptcopy[count-2].X, ptcopy[count-2].Y,
 774                              &ptcopy[count-1].X, &ptcopy[count-1].Y, pen->width);
 775         else if((pen->endcap == LineCapCustom) && pen->customend)
 776             shorten_line_amt(ptcopy[count-2].X, ptcopy[count-2].Y,
 777                              &ptcopy[count-1].X, &ptcopy[count-1].Y,
 778                              pen->customend->inset * pen->width);
 779
 780         if(pen->startcap == LineCapArrowAnchor)
 781             shorten_line_amt(ptcopy[1].X, ptcopy[1].Y,
 782                              &ptcopy[0].X, &ptcopy[0].Y, pen->width);
 783         else if((pen->startcap == LineCapCustom) && pen->customstart)
 784             shorten_line_amt(ptcopy[1].X, ptcopy[1].Y,
 785                              &ptcopy[0].X, &ptcopy[0].Y,
 786                              pen->customstart->inset * pen->width);
 787
 788         draw_cap(graphics, pen->brush->lb.lbColor, pen->endcap, pen->width, pen->customend,
 789                  pt[count - 2].X, pt[count - 2].Y, pt[count - 1].X, pt[count - 1].Y);
 790         draw_cap(graphics, pen->brush->lb.lbColor, pen->startcap, pen->width, pen->customstart,
 791                          pt[1].X, pt[1].Y, pt[0].X, pt[0].Y);
 792     }
 793
 794     transform_and_round_points(graphics, pti, ptcopy, count);
 795
 796     if(Polyline(graphics->hdc, pti, count))
 797         status = Ok;
 798
 799 end:
 800     GdipFree(pti);
 801     GdipFree(ptcopy);
 802
 803     return status;
 804 }
 805
 806 /* Conducts a linear search to find the bezier points that will back off
 807  * the endpoint of the curve by a distance of amt. Linear search works
 808  * better than binary in this case because there are multiple solutions,
 809  * and binary searches often find a bad one. I don't think this is what
 810  * Windows does but short of rendering the bezier without GDI's help it's
 811  * the best we can do. If rev then work from the start of the passed points
 812  * instead of the end. */
 813 static void shorten_bezier_amt(GpPointF * pt, REAL amt, BOOL rev)
 814 {
 815     GpPointF origpt[4];
 816     REAL percent = 0.00, dx, dy, origx, origy, diff = -1.0;
 817     INT i, first = 0, second = 1, third = 2, fourth = 3;
 818
 819     if(rev){
 820         first = 3;
 821         second = 2;
 822         third = 1;
 823         fourth = 0;
 824     }
 825
 826     origx = pt[fourth].X;
 827     origy = pt[fourth].Y;
 828     memcpy(origpt, pt, sizeof(GpPointF) * 4);
 829
 830     for(i = 0; (i < MAX_ITERS) && (diff < amt); i++){
 831         /* reset bezier points to original values */
 832         memcpy(pt, origpt, sizeof(GpPointF) * 4);
 833         /* Perform magic on bezier points. Order is important here.*/
 834         shorten_line_percent(pt[third].X, pt[third].Y, &pt[fourth].X, &pt[fourth].Y, percent);
 835         shorten_line_percent(pt[second].X, pt[second].Y, &pt[third].X, &pt[third].Y, percent);
 836         shorten_line_percent(pt[third].X, pt[third].Y, &pt[fourth].X, &pt[fourth].Y, percent);
 837         shorten_line_percent(pt[first].X, pt[first].Y, &pt[second].X, &pt[second].Y, percent);
 838         shorten_line_percent(pt[second].X, pt[second].Y, &pt[third].X, &pt[third].Y, percent);
 839         shorten_line_percent(pt[third].X, pt[third].Y, &pt[fourth].X, &pt[fourth].Y, percent);
 840
 841         dx = pt[fourth].X - origx;
 842         dy = pt[fourth].Y - origy;
 843
 844         diff = sqrt(dx * dx + dy * dy);
 845         percent += 0.0005 * amt;
 846     }
 847 }
 848
 849 /* Draws bezier curves between given points, and if caps is true then draws an
 850  * endcap at the end of the last line. */
 851 static GpStatus draw_polybezier(GpGraphics *graphics, GpPen *pen,
 852     GDIPCONST GpPointF * pt, INT count, BOOL caps)
 853 {
 854     POINT *pti;
 855     GpPointF *ptcopy;
 856     GpStatus status = GenericError;
 857
 858     if(!count)
 859         return Ok;
 860
 861     pti = GdipAlloc(count * sizeof(POINT));
 862     ptcopy = GdipAlloc(count * sizeof(GpPointF));
 863
 864     if(!pti || !ptcopy){
 865         status = OutOfMemory;
 866         goto end;
 867     }
 868
 869     memcpy(ptcopy, pt, count * sizeof(GpPointF));
 870
 871     if(caps){
 872         if(pen->endcap == LineCapArrowAnchor)
 873             shorten_bezier_amt(&ptcopy[count-4], pen->width, FALSE);
 874         else if((pen->endcap == LineCapCustom) && pen->customend)
 875             shorten_bezier_amt(&ptcopy[count-4], pen->width * pen->customend->inset,
 876                                FALSE);
 877
 878         if(pen->startcap == LineCapArrowAnchor)
 879             shorten_bezier_amt(ptcopy, pen->width, TRUE);
 880         else if((pen->startcap == LineCapCustom) && pen->customstart)
 881             shorten_bezier_amt(ptcopy, pen->width * pen->customstart->inset, TRUE);
 882
 883         /* the direction of the line cap is parallel to the direction at the
 884          * end of the bezier (which, if it has been shortened, is not the same
 885          * as the direction from pt[count-2] to pt[count-1]) */
 886         draw_cap(graphics, pen->brush->lb.lbColor, pen->endcap, pen->width, pen->customend,
 887             pt[count - 1].X - (ptcopy[count - 1].X - ptcopy[count - 2].X),
 888             pt[count - 1].Y - (ptcopy[count - 1].Y - ptcopy[count - 2].Y),
 889             pt[count - 1].X, pt[count - 1].Y);
 890
 891         draw_cap(graphics, pen->brush->lb.lbColor, pen->startcap, pen->width, pen->customstart,
 892             pt[0].X - (ptcopy[0].X - ptcopy[1].X),
 893             pt[0].Y - (ptcopy[0].Y - ptcopy[1].Y), pt[0].X, pt[0].Y);
 894     }
 895
 896     transform_and_round_points(graphics, pti, ptcopy, count);
 897
 898     PolyBezier(graphics->hdc, pti, count);
 899
 900     status = Ok;
 901
 902 end:
 903     GdipFree(pti);
 904     GdipFree(ptcopy);
 905
 906     return status;
 907 }
 908
 909 /* Draws a combination of bezier curves and lines between points. */
 910 static GpStatus draw_poly(GpGraphics *graphics, GpPen *pen, GDIPCONST GpPointF * pt,
 911     GDIPCONST BYTE * types, INT count, BOOL caps)
 912 {
 913     POINT *pti = GdipAlloc(count * sizeof(POINT));
 914     BYTE *tp = GdipAlloc(count);
 915     GpPointF *ptcopy = GdipAlloc(count * sizeof(GpPointF));
 916     INT i, j;
 917     GpStatus status = GenericError;
 918
 919     if(!count){
 920         status = Ok;
 921         goto end;
 922     }
 923     if(!pti || !tp || !ptcopy){
 924         status = OutOfMemory;
 925         goto end;
 926     }
 927
 928     for(i = 1; i < count; i++){
 929         if((types[i] & PathPointTypePathTypeMask) == PathPointTypeBezier){
 930             if((i + 2 >= count) || !(types[i + 1] & PathPointTypeBezier)
 931                 || !(types[i + 1] & PathPointTypeBezier)){
 932                 ERR("Bad bezier points\n");
 933                 goto end;
 934             }
 935             i += 2;
 936         }
 937     }
 938
 939     memcpy(ptcopy, pt, count * sizeof(GpPointF));
 940
 941     /* If we are drawing caps, go through the points and adjust them accordingly,
 942      * and draw the caps. */
 943     if(caps){
 944         switch(types[count - 1] & PathPointTypePathTypeMask){
 945             case PathPointTypeBezier:
 946                 if(pen->endcap == LineCapArrowAnchor)
 947                     shorten_bezier_amt(&ptcopy[count - 4], pen->width, FALSE);
 948                 else if((pen->endcap == LineCapCustom) && pen->customend)
 949                     shorten_bezier_amt(&ptcopy[count - 4],
 950                                        pen->width * pen->customend->inset, FALSE);
 951
 952                 draw_cap(graphics, pen->brush->lb.lbColor, pen->endcap, pen->width, pen->customend,
 953                     pt[count - 1].X - (ptcopy[count - 1].X - ptcopy[count - 2].X),
 954                     pt[count - 1].Y - (ptcopy[count - 1].Y - ptcopy[count - 2].Y),
 955                     pt[count - 1].X, pt[count - 1].Y);
 956
 957                 break;
 958             case PathPointTypeLine:
 959                 if(pen->endcap == LineCapArrowAnchor)
 960                     shorten_line_amt(ptcopy[count - 2].X, ptcopy[count - 2].Y,
 961                                      &ptcopy[count - 1].X, &ptcopy[count - 1].Y,
 962                                      pen->width);
 963                 else if((pen->endcap == LineCapCustom) && pen->customend)
 964                     shorten_line_amt(ptcopy[count - 2].X, ptcopy[count - 2].Y,
 965                                      &ptcopy[count - 1].X, &ptcopy[count - 1].Y,
 966                                      pen->customend->inset * pen->width);
 967
 968                 draw_cap(graphics, pen->brush->lb.lbColor, pen->endcap, pen->width, pen->customend,
 969                          pt[count - 2].X, pt[count - 2].Y, pt[count - 1].X,
 970                          pt[count - 1].Y);
 971
 972                 break;
 973             default:
 974                 ERR("Bad path last point\n");
 975                 goto end;
 976         }
 977
 978         /* Find start of points */
 979         for(j = 1; j < count && ((types[j] & PathPointTypePathTypeMask)
 980             == PathPointTypeStart); j++);
 981
 982         switch(types[j] & PathPointTypePathTypeMask){
 983             case PathPointTypeBezier:
 984                 if(pen->startcap == LineCapArrowAnchor)
 985                     shorten_bezier_amt(&ptcopy[j - 1], pen->width, TRUE);
 986                 else if((pen->startcap == LineCapCustom) && pen->customstart)
 987                     shorten_bezier_amt(&ptcopy[j - 1],
 988                                        pen->width * pen->customstart->inset, TRUE);
 989
 990                 draw_cap(graphics, pen->brush->lb.lbColor, pen->startcap, pen->width, pen->customstart,
 991                     pt[j - 1].X - (ptcopy[j - 1].X - ptcopy[j].X),
 992                     pt[j - 1].Y - (ptcopy[j - 1].Y - ptcopy[j].Y),
 993                     pt[j - 1].X, pt[j - 1].Y);
 994
 995                 break;
 996             case PathPointTypeLine:
 997                 if(pen->startcap == LineCapArrowAnchor)
 998                     shorten_line_amt(ptcopy[j].X, ptcopy[j].Y,
 999                                      &ptcopy[j - 1].X, &ptcopy[j - 1].Y,
1000                                      pen->width);
1001                 else if((pen->startcap == LineCapCustom) && pen->customstart)
1002                     shorten_line_amt(ptcopy[j].X, ptcopy[j].Y,
1003                                      &ptcopy[j - 1].X, &ptcopy[j - 1].Y,
1004                                      pen->customstart->inset * pen->width);
1005
1006                 draw_cap(graphics, pen->brush->lb.lbColor, pen->startcap, pen->width, pen->customstart,
1007                          pt[j].X, pt[j].Y, pt[j - 1].X,
1008                          pt[j - 1].Y);
1009
1010                 break;
1011             default:
1012                 ERR("Bad path points\n");
1013                 goto end;
1014         }
1015     }
1016
1017     transform_and_round_points(graphics, pti, ptcopy, count);
1018
1019     for(i = 0; i < count; i++){
1020         tp[i] = convert_path_point_type(types[i]);
1021     }
1022
1023     PolyDraw(graphics->hdc, pti, tp, count);
1024
1025     status = Ok;
1026
1027 end:
1028     GdipFree(pti);
1029     GdipFree(ptcopy);
1030     GdipFree(tp);
1031
1032     return status;
1033 }
1034
1035 GpStatus trace_path(GpGraphics *graphics, GpPath *path)
1036 {
1037     GpStatus result;
1038
1039     BeginPath(graphics->hdc);
1040     result = draw_poly(graphics, NULL, path->pathdata.Points,
1041                        path->pathdata.Types, path->pathdata.Count, FALSE);
1042     EndPath(graphics->hdc);
1043     return result;
1044 }
1045
1046 typedef struct _GraphicsContainerItem {
1047     struct list entry;
1048     GraphicsContainer contid;
1049
1050     SmoothingMode smoothing;
1051     CompositingQuality compqual;
1052     InterpolationMode interpolation;
1053     CompositingMode compmode;
1054     TextRenderingHint texthint;
1055     REAL scale;
1056     GpUnit unit;
1057     PixelOffsetMode pixeloffset;
1058     UINT textcontrast;
1059     GpMatrix* worldtrans;
1060     GpRegion* clip;
1061 } GraphicsContainerItem;
1062
1063 static GpStatus init_container(GraphicsContainerItem** container,
1064         GDIPCONST GpGraphics* graphics){
1065     GpStatus sts;
1066
1067     *container = GdipAlloc(sizeof(GraphicsContainerItem));
1068     if(!(*container))
1069         return OutOfMemory;
1070
1071     (*container)->contid = graphics->contid + 1;
1072
1073     (*container)->smoothing = graphics->smoothing;
1074     (*container)->compqual = graphics->compqual;
1075     (*container)->interpolation = graphics->interpolation;
1076     (*container)->compmode = graphics->compmode;
1077     (*container)->texthint = graphics->texthint;
1078     (*container)->scale = graphics->scale;
1079     (*container)->unit = graphics->unit;
1080     (*container)->textcontrast = graphics->textcontrast;
1081     (*container)->pixeloffset = graphics->pixeloffset;
1082
1083     sts = GdipCloneMatrix(graphics->worldtrans, &(*container)->worldtrans);
1084     if(sts != Ok){
1085         GdipFree(*container);
1086         *container = NULL;
1087         return sts;
1088     }
1089
1090     sts = GdipCloneRegion(graphics->clip, &(*container)->clip);
1091     if(sts != Ok){
1092         GdipDeleteMatrix((*container)->worldtrans);
1093         GdipFree(*container);
1094         *container = NULL;
1095         return sts;
1096     }
1097
1098     return Ok;
1099 }
1100
1101 static void delete_container(GraphicsContainerItem* container){
1102     GdipDeleteMatrix(container->worldtrans);
1103     GdipDeleteRegion(container->clip);
1104     GdipFree(container);
1105 }
1106
1107 static GpStatus restore_container(GpGraphics* graphics,
1108         GDIPCONST GraphicsContainerItem* container){
1109     GpStatus sts;
1110     GpMatrix *newTrans;
1111     GpRegion *newClip;
1112
1113     sts = GdipCloneMatrix(container->worldtrans, &newTrans);
1114     if(sts != Ok)
1115         return sts;
1116
1117     sts = GdipCloneRegion(container->clip, &newClip);
1118     if(sts != Ok){
1119         GdipDeleteMatrix(newTrans);
1120         return sts;
1121     }
1122
1123     GdipDeleteMatrix(graphics->worldtrans);
1124     graphics->worldtrans = newTrans;
1125
1126     GdipDeleteRegion(graphics->clip);
1127     graphics->clip = newClip;
1128
1129     graphics->contid = container->contid - 1;
1130
1131     graphics->smoothing = container->smoothing;
1132     graphics->compqual = container->compqual;
1133     graphics->interpolation = container->interpolation;
1134     graphics->compmode = container->compmode;
1135     graphics->texthint = container->texthint;
1136     graphics->scale = container->scale;
1137     graphics->unit = container->unit;
1138     graphics->textcontrast = container->textcontrast;
1139     graphics->pixeloffset = container->pixeloffset;
1140
1141     return Ok;
1142 }
1143
1144 static GpStatus get_graphics_bounds(GpGraphics* graphics, GpRectF* rect)
1145 {
1146     RECT wnd_rect;
1147     GpStatus stat=Ok;
1148     GpUnit unit;
1149
1150     if(graphics->hwnd) {
1151         if(!GetClientRect(graphics->hwnd, &wnd_rect))
1152             return GenericError;
1153
1154         rect->X = wnd_rect.left;
1155         rect->Y = wnd_rect.top;
1156         rect->Width = wnd_rect.right - wnd_rect.left;
1157         rect->Height = wnd_rect.bottom - wnd_rect.top;
1158     }else if (graphics->image){
1159         stat = GdipGetImageBounds(graphics->image, rect, &unit);
1160         if (stat == Ok && unit != UnitPixel)
1161             FIXME("need to convert from unit %i\n", unit);
1162     }else{
1163         rect->X = 0;
1164         rect->Y = 0;
1165         rect->Width = GetDeviceCaps(graphics->hdc, HORZRES);
1166         rect->Height = GetDeviceCaps(graphics->hdc, VERTRES);
1167     }
1168
1169     return stat;
1170 }
1171
1172 /* on success, rgn will contain the region of the graphics object which
1173  * is visible after clipping has been applied */
1174 static GpStatus get_visible_clip_region(GpGraphics *graphics, GpRegion *rgn)
1175 {
1176     GpStatus stat;
1177     GpRectF rectf;
1178     GpRegion* tmp;
1179
1180     if((stat = get_graphics_bounds(graphics, &rectf)) != Ok)
1181         return stat;
1182
1183     if((stat = GdipCreateRegion(&tmp)) != Ok)
1184         return stat;
1185
1186     if((stat = GdipCombineRegionRect(tmp, &rectf, CombineModeReplace)) != Ok)
1187         goto end;
1188
1189     if((stat = GdipCombineRegionRegion(tmp, graphics->clip, CombineModeIntersect)) != Ok)
1190         goto end;
1191
1192     stat = GdipCombineRegionRegion(rgn, tmp, CombineModeReplace);
1193
1194 end:
1195     GdipDeleteRegion(tmp);
1196     return stat;
1197 }
1198
1199 GpStatus WINGDIPAPI GdipCreateFromHDC(HDC hdc, GpGraphics **graphics)
1200 {
1201     TRACE("(%p, %p)\n", hdc, graphics);
1202
1203     return GdipCreateFromHDC2(hdc, NULL, graphics);
1204 }
1205
1206 GpStatus WINGDIPAPI GdipCreateFromHDC2(HDC hdc, HANDLE hDevice, GpGraphics **graphics)
1207 {
1208     GpStatus retval;
1209
1210     TRACE("(%p, %p, %p)\n", hdc, hDevice, graphics);
1211
1212     if(hDevice != NULL) {
1213         FIXME("Don't know how to handle parameter hDevice\n");
1214         return NotImplemented;
1215     }
1216
1217     if(hdc == NULL)
1218         return OutOfMemory;
1219
1220     if(graphics == NULL)
1221         return InvalidParameter;
1222
1223     *graphics = GdipAlloc(sizeof(GpGraphics));
1224     if(!*graphics)  return OutOfMemory;
1225
1226     if((retval = GdipCreateMatrix(&(*graphics)->worldtrans)) != Ok){
1227         GdipFree(*graphics);
1228         return retval;
1229     }
1230
1231     if((retval = GdipCreateRegion(&(*graphics)->clip)) != Ok){
1232         GdipFree((*graphics)->worldtrans);
1233         GdipFree(*graphics);
1234         return retval;
1235     }
1236
1237     (*graphics)->hdc = hdc;
1238     (*graphics)->hwnd = WindowFromDC(hdc);
1239     (*graphics)->owndc = FALSE;
1240     (*graphics)->smoothing = SmoothingModeDefault;
1241     (*graphics)->compqual = CompositingQualityDefault;
1242     (*graphics)->interpolation = InterpolationModeDefault;
1243     (*graphics)->pixeloffset = PixelOffsetModeDefault;
1244     (*graphics)->compmode = CompositingModeSourceOver;
1245     (*graphics)->unit = UnitDisplay;
1246     (*graphics)->scale = 1.0;
1247     (*graphics)->busy = FALSE;
1248     (*graphics)->textcontrast = 4;
1249     list_init(&(*graphics)->containers);
1250     (*graphics)->contid = 0;
1251
1252     TRACE("<-- %p\n", *graphics);
1253
1254     return Ok;
1255 }
1256
1257 GpStatus graphics_from_image(GpImage *image, GpGraphics **graphics)
1258 {
1259     GpStatus retval;
1260
1261     *graphics = GdipAlloc(sizeof(GpGraphics));
1262     if(!*graphics)  return OutOfMemory;
1263
1264     if((retval = GdipCreateMatrix(&(*graphics)->worldtrans)) != Ok){
1265         GdipFree(*graphics);
1266         return retval;
1267     }
1268
1269     if((retval = GdipCreateRegion(&(*graphics)->clip)) != Ok){
1270         GdipFree((*graphics)->worldtrans);
1271         GdipFree(*graphics);
1272         return retval;
1273     }
1274
1275     (*graphics)->hdc = NULL;
1276     (*graphics)->hwnd = NULL;
1277     (*graphics)->owndc = FALSE;
1278     (*graphics)->image = image;
1279     (*graphics)->smoothing = SmoothingModeDefault;
1280     (*graphics)->compqual = CompositingQualityDefault;
1281     (*graphics)->interpolation = InterpolationModeDefault;
1282     (*graphics)->pixeloffset = PixelOffsetModeDefault;
1283     (*graphics)->compmode = CompositingModeSourceOver;
1284     (*graphics)->unit = UnitDisplay;
1285     (*graphics)->scale = 1.0;
1286     (*graphics)->busy = FALSE;
1287     (*graphics)->textcontrast = 4;
1288     list_init(&(*graphics)->containers);
1289     (*graphics)->contid = 0;
1290
1291     TRACE("<-- %p\n", *graphics);
1292
1293     return Ok;
1294 }
1295
1296 GpStatus WINGDIPAPI GdipCreateFromHWND(HWND hwnd, GpGraphics **graphics)
1297 {
1298     GpStatus ret;
1299     HDC hdc;
1300
1301     TRACE("(%p, %p)\n", hwnd, graphics);
1302
1303     hdc = GetDC(hwnd);
1304
1305     if((ret = GdipCreateFromHDC(hdc, graphics)) != Ok)
1306     {
1307         ReleaseDC(hwnd, hdc);
1308         return ret;
1309     }
1310
1311     (*graphics)->hwnd = hwnd;
1312     (*graphics)->owndc = TRUE;
1313
1314     return Ok;
1315 }
1316
1317 /* FIXME: no icm handling */
1318 GpStatus WINGDIPAPI GdipCreateFromHWNDICM(HWND hwnd, GpGraphics **graphics)
1319 {
1320     TRACE("(%p, %p)\n", hwnd, graphics);
1321
1322     return GdipCreateFromHWND(hwnd, graphics);
1323 }
1324
1325 GpStatus WINGDIPAPI GdipCreateMetafileFromEmf(HENHMETAFILE hemf, BOOL delete,
1326     GpMetafile **metafile)
1327 {
1328     static int calls;
1329
1330     TRACE("(%p,%i,%p)\n", hemf, delete, metafile);
1331
1332     if(!hemf || !metafile)
1333         return InvalidParameter;
1334
1335     if(!(calls++))
1336         FIXME("not implemented\n");
1337
1338     return NotImplemented;
1339 }
1340
1341 GpStatus WINGDIPAPI GdipCreateMetafileFromWmf(HMETAFILE hwmf, BOOL delete,
1342     GDIPCONST WmfPlaceableFileHeader * placeable, GpMetafile **metafile)
1343 {
1344     IStream *stream = NULL;
1345     UINT read;
1346     BYTE* copy;
1347     HENHMETAFILE hemf;
1348     GpStatus retval = Ok;
1349
1350     TRACE("(%p, %d, %p, %p)\n", hwmf, delete, placeable, metafile);
1351
1352     if(!hwmf || !metafile || !placeable)
1353         return InvalidParameter;
1354
1355     *metafile = NULL;
1356     read = GetMetaFileBitsEx(hwmf, 0, NULL);
1357     if(!read)
1358         return GenericError;
1359     copy = GdipAlloc(read);
1360     GetMetaFileBitsEx(hwmf, read, copy);
1361
1362     hemf = SetWinMetaFileBits(read, copy, NULL, NULL);
1363     GdipFree(copy);
1364
1365     read = GetEnhMetaFileBits(hemf, 0, NULL);
1366     copy = GdipAlloc(read);
1367     GetEnhMetaFileBits(hemf, read, copy);
1368     DeleteEnhMetaFile(hemf);
1369
1370     if(CreateStreamOnHGlobal(copy, TRUE, &stream) != S_OK){
1371         ERR("could not make stream\n");
1372         GdipFree(copy);
1373         retval = GenericError;
1374         goto err;
1375     }
1376
1377     *metafile = GdipAlloc(sizeof(GpMetafile));
1378     if(!*metafile){
1379         retval = OutOfMemory;
1380         goto err;
1381     }
1382
1383     if(OleLoadPicture(stream, 0, FALSE, &IID_IPicture,
1384         (LPVOID*) &((*metafile)->image.picture)) != S_OK)
1385     {
1386         retval = GenericError;
1387         goto err;
1388     }
1389
1390
1391     (*metafile)->image.type = ImageTypeMetafile;
1392     memcpy(&(*metafile)->image.format, &ImageFormatWMF, sizeof(GUID));
1393     (*metafile)->image.palette_flags = 0;
1394     (*metafile)->image.palette_count = 0;
1395     (*metafile)->image.palette_size = 0;
1396     (*metafile)->image.palette_entries = NULL;
1397     (*metafile)->image.xres = (REAL)placeable->Inch;
1398     (*metafile)->image.yres = (REAL)placeable->Inch;
1399     (*metafile)->bounds.X = ((REAL) placeable->BoundingBox.Left) / ((REAL) placeable->Inch);
1400     (*metafile)->bounds.Y = ((REAL) placeable->BoundingBox.Top) / ((REAL) placeable->Inch);
1401     (*metafile)->bounds.Width = ((REAL) (placeable->BoundingBox.Right
1402                     - placeable->BoundingBox.Left));
1403     (*metafile)->bounds.Height = ((REAL) (placeable->BoundingBox.Bottom
1404                    - placeable->BoundingBox.Top));
1405     (*metafile)->unit = UnitPixel;
1406
1407     if(delete)
1408         DeleteMetaFile(hwmf);
1409
1410     TRACE("<-- %p\n", *metafile);
1411
1412 err:
1413     if (retval != Ok)
1414         GdipFree(*metafile);
1415     IStream_Release(stream);
1416     return retval;
1417 }
1418
1419 GpStatus WINGDIPAPI GdipCreateMetafileFromWmfFile(GDIPCONST WCHAR *file,
1420     GDIPCONST WmfPlaceableFileHeader * placeable, GpMetafile **metafile)
1421 {
1422     HMETAFILE hmf = GetMetaFileW(file);
1423
1424     TRACE("(%s, %p, %p)\n", debugstr_w(file), placeable, metafile);
1425
1426     if(!hmf) return InvalidParameter;
1427
1428     return GdipCreateMetafileFromWmf(hmf, TRUE, placeable, metafile);
1429 }
1430
1431 GpStatus WINGDIPAPI GdipCreateMetafileFromFile(GDIPCONST WCHAR *file,
1432     GpMetafile **metafile)
1433 {
1434     FIXME("(%p, %p): stub\n", file, metafile);
1435     return NotImplemented;
1436 }
1437
1438 GpStatus WINGDIPAPI GdipCreateMetafileFromStream(IStream *stream,
1439     GpMetafile **metafile)
1440 {
1441     FIXME("(%p, %p): stub\n", stream, metafile);
1442     return NotImplemented;
1443 }
1444
1445 GpStatus WINGDIPAPI GdipCreateStreamOnFile(GDIPCONST WCHAR * filename,
1446     UINT access, IStream **stream)
1447 {
1448     DWORD dwMode;
1449     HRESULT ret;
1450
1451     TRACE("(%s, %u, %p)\n", debugstr_w(filename), access, stream);
1452
1453     if(!stream || !filename)
1454         return InvalidParameter;
1455
1456     if(access & GENERIC_WRITE)
1457         dwMode = STGM_SHARE_DENY_WRITE | STGM_WRITE | STGM_CREATE;
1458     else if(access & GENERIC_READ)
1459         dwMode = STGM_SHARE_DENY_WRITE | STGM_READ | STGM_FAILIFTHERE;
1460     else
1461         return InvalidParameter;
1462
1463     ret = SHCreateStreamOnFileW(filename, dwMode, stream);
1464
1465     return hresult_to_status(ret);
1466 }
1467
1468 GpStatus WINGDIPAPI GdipDeleteGraphics(GpGraphics *graphics)
1469 {
1470     GraphicsContainerItem *cont, *next;
1471     TRACE("(%p)\n", graphics);
1472
1473     if(!graphics) return InvalidParameter;
1474     if(graphics->busy) return ObjectBusy;
1475
1476     if(graphics->owndc)
1477         ReleaseDC(graphics->hwnd, graphics->hdc);
1478
1479     LIST_FOR_EACH_ENTRY_SAFE(cont, next, &graphics->containers, GraphicsContainerItem, entry){
1480         list_remove(&cont->entry);
1481         delete_container(cont);
1482     }
1483
1484     GdipDeleteRegion(graphics->clip);
1485     GdipDeleteMatrix(graphics->worldtrans);
1486     GdipFree(graphics);
1487
1488     return Ok;
1489 }
1490
1491 GpStatus WINGDIPAPI GdipDrawArc(GpGraphics *graphics, GpPen *pen, REAL x,
1492     REAL y, REAL width, REAL height, REAL startAngle, REAL sweepAngle)
1493 {
1494     INT save_state, num_pts;
1495     GpPointF points[MAX_ARC_PTS];
1496     GpStatus retval;
1497
1498     TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f)\n", graphics, pen, x, y,
1499           width, height, startAngle, sweepAngle);
1500
1501     if(!graphics || !pen || width <= 0 || height <= 0)
1502         return InvalidParameter;
1503
1504     if(graphics->busy)
1505         return ObjectBusy;
1506
1507     num_pts = arc2polybezier(points, x, y, width, height, startAngle, sweepAngle);
1508
1509     save_state = prepare_dc(graphics, pen);
1510
1511     retval = draw_polybezier(graphics, pen, points, num_pts, TRUE);
1512
1513     restore_dc(graphics, save_state);
1514
1515     return retval;
1516 }
1517
1518 GpStatus WINGDIPAPI GdipDrawArcI(GpGraphics *graphics, GpPen *pen, INT x,
1519     INT y, INT width, INT height, REAL startAngle, REAL sweepAngle)
1520 {
1521     TRACE("(%p, %p, %d, %d, %d, %d, %.2f, %.2f)\n", graphics, pen, x, y,
1522           width, height, startAngle, sweepAngle);
1523
1524     return GdipDrawArc(graphics,pen,(REAL)x,(REAL)y,(REAL)width,(REAL)height,startAngle,sweepAngle);
1525 }
1526
1527 GpStatus WINGDIPAPI GdipDrawBezier(GpGraphics *graphics, GpPen *pen, REAL x1,
1528     REAL y1, REAL x2, REAL y2, REAL x3, REAL y3, REAL x4, REAL y4)
1529 {
1530     INT save_state;
1531     GpPointF pt[4];
1532     GpStatus retval;
1533
1534     TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f)\n", graphics, pen, x1, y1,
1535           x2, y2, x3, y3, x4, y4);
1536
1537     if(!graphics || !pen)
1538         return InvalidParameter;
1539
1540     if(graphics->busy)
1541         return ObjectBusy;
1542
1543     pt[0].X = x1;
1544     pt[0].Y = y1;
1545     pt[1].X = x2;
1546     pt[1].Y = y2;
1547     pt[2].X = x3;
1548     pt[2].Y = y3;
1549     pt[3].X = x4;
1550     pt[3].Y = y4;
1551
1552     save_state = prepare_dc(graphics, pen);
1553
1554     retval = draw_polybezier(graphics, pen, pt, 4, TRUE);
1555
1556     restore_dc(graphics, save_state);
1557
1558     return retval;
1559 }
1560
1561 GpStatus WINGDIPAPI GdipDrawBezierI(GpGraphics *graphics, GpPen *pen, INT x1,
1562     INT y1, INT x2, INT y2, INT x3, INT y3, INT x4, INT y4)
1563 {
1564     INT save_state;
1565     GpPointF pt[4];
1566     GpStatus retval;
1567
1568     TRACE("(%p, %p, %d, %d, %d, %d, %d, %d, %d, %d)\n", graphics, pen, x1, y1,
1569           x2, y2, x3, y3, x4, y4);
1570
1571     if(!graphics || !pen)
1572         return InvalidParameter;
1573
1574     if(graphics->busy)
1575         return ObjectBusy;
1576
1577     pt[0].X = x1;
1578     pt[0].Y = y1;
1579     pt[1].X = x2;
1580     pt[1].Y = y2;
1581     pt[2].X = x3;
1582     pt[2].Y = y3;
1583     pt[3].X = x4;
1584     pt[3].Y = y4;
1585
1586     save_state = prepare_dc(graphics, pen);
1587
1588     retval = draw_polybezier(graphics, pen, pt, 4, TRUE);
1589
1590     restore_dc(graphics, save_state);
1591
1592     return retval;
1593 }
1594
1595 GpStatus WINGDIPAPI GdipDrawBeziers(GpGraphics *graphics, GpPen *pen,
1596     GDIPCONST GpPointF *points, INT count)
1597 {
1598     INT i;
1599     GpStatus ret;
1600
1601     TRACE("(%p, %p, %p, %d)\n", graphics, pen, points, count);
1602
1603     if(!graphics || !pen || !points || (count <= 0))
1604         return InvalidParameter;
1605
1606     if(graphics->busy)
1607         return ObjectBusy;
1608
1609     for(i = 0; i < floor(count / 4); i++){
1610         ret = GdipDrawBezier(graphics, pen,
1611                              points[4*i].X, points[4*i].Y,
1612                              points[4*i + 1].X, points[4*i + 1].Y,
1613                              points[4*i + 2].X, points[4*i + 2].Y,
1614                              points[4*i + 3].X, points[4*i + 3].Y);
1615         if(ret != Ok)
1616             return ret;
1617     }
1618
1619     return Ok;
1620 }
1621
1622 GpStatus WINGDIPAPI GdipDrawBeziersI(GpGraphics *graphics, GpPen *pen,
1623     GDIPCONST GpPoint *points, INT count)
1624 {
1625     GpPointF *pts;
1626     GpStatus ret;
1627     INT i;
1628
1629     TRACE("(%p, %p, %p, %d)\n", graphics, pen, points, count);
1630
1631     if(!graphics || !pen || !points || (count <= 0))
1632         return InvalidParameter;
1633
1634     if(graphics->busy)
1635         return ObjectBusy;
1636
1637     pts = GdipAlloc(sizeof(GpPointF) * count);
1638     if(!pts)
1639         return OutOfMemory;
1640
1641     for(i = 0; i < count; i++){
1642         pts[i].X = (REAL)points[i].X;
1643         pts[i].Y = (REAL)points[i].Y;
1644     }
1645
1646     ret = GdipDrawBeziers(graphics,pen,pts,count);
1647
1648     GdipFree(pts);
1649
1650     return ret;
1651 }
1652
1653 GpStatus WINGDIPAPI GdipDrawClosedCurve(GpGraphics *graphics, GpPen *pen,
1654     GDIPCONST GpPointF *points, INT count)
1655 {
1656     TRACE("(%p, %p, %p, %d)\n", graphics, pen, points, count);
1657
1658     return GdipDrawClosedCurve2(graphics, pen, points, count, 1.0);
1659 }
1660
1661 GpStatus WINGDIPAPI GdipDrawClosedCurveI(GpGraphics *graphics, GpPen *pen,
1662     GDIPCONST GpPoint *points, INT count)
1663 {
1664     TRACE("(%p, %p, %p, %d)\n", graphics, pen, points, count);
1665
1666     return GdipDrawClosedCurve2I(graphics, pen, points, count, 1.0);
1667 }
1668
1669 GpStatus WINGDIPAPI GdipDrawClosedCurve2(GpGraphics *graphics, GpPen *pen,
1670     GDIPCONST GpPointF *points, INT count, REAL tension)
1671 {
1672     GpPath *path;
1673     GpStatus stat;
1674
1675     TRACE("(%p, %p, %p, %d, %.2f)\n", graphics, pen, points, count, tension);
1676
1677     if(!graphics || !pen || !points || count <= 0)
1678         return InvalidParameter;
1679
1680     if(graphics->busy)
1681         return ObjectBusy;
1682
1683     if((stat = GdipCreatePath(FillModeAlternate, &path)) != Ok)
1684         return stat;
1685
1686     stat = GdipAddPathClosedCurve2(path, points, count, tension);
1687     if(stat != Ok){
1688         GdipDeletePath(path);
1689         return stat;
1690     }
1691
1692     stat = GdipDrawPath(graphics, pen, path);
1693
1694     GdipDeletePath(path);
1695
1696     return stat;
1697 }
1698
1699 GpStatus WINGDIPAPI GdipDrawClosedCurve2I(GpGraphics *graphics, GpPen *pen,
1700     GDIPCONST GpPoint *points, INT count, REAL tension)
1701 {
1702     GpPointF *ptf;
1703     GpStatus stat;
1704     INT i;
1705
1706     TRACE("(%p, %p, %p, %d, %.2f)\n", graphics, pen, points, count, tension);
1707
1708     if(!points || count <= 0)
1709         return InvalidParameter;
1710
1711     ptf = GdipAlloc(sizeof(GpPointF)*count);
1712     if(!ptf)
1713         return OutOfMemory;
1714
1715     for(i = 0; i < count; i++){
1716         ptf[i].X = (REAL)points[i].X;
1717         ptf[i].Y = (REAL)points[i].Y;
1718     }
1719
1720     stat = GdipDrawClosedCurve2(graphics, pen, ptf, count, tension);
1721
1722     GdipFree(ptf);
1723
1724     return stat;
1725 }
1726
1727 GpStatus WINGDIPAPI GdipDrawCurve(GpGraphics *graphics, GpPen *pen,
1728     GDIPCONST GpPointF *points, INT count)
1729 {
1730     TRACE("(%p, %p, %p, %d)\n", graphics, pen, points, count);
1731
1732     return GdipDrawCurve2(graphics,pen,points,count,1.0);
1733 }
1734
1735 GpStatus WINGDIPAPI GdipDrawCurveI(GpGraphics *graphics, GpPen *pen,
1736     GDIPCONST GpPoint *points, INT count)
1737 {
1738     GpPointF *pointsF;
1739     GpStatus ret;
1740     INT i;
1741
1742     TRACE("(%p, %p, %p, %d)\n", graphics, pen, points, count);
1743
1744     if(!points)
1745         return InvalidParameter;
1746
1747     pointsF = GdipAlloc(sizeof(GpPointF)*count);
1748     if(!pointsF)
1749         return OutOfMemory;
1750
1751     for(i = 0; i < count; i++){
1752         pointsF[i].X = (REAL)points[i].X;
1753         pointsF[i].Y = (REAL)points[i].Y;
1754     }
1755
1756     ret = GdipDrawCurve(graphics,pen,pointsF,count);
1757     GdipFree(pointsF);
1758
1759     return ret;
1760 }
1761
1762 /* Approximates cardinal spline with Bezier curves. */
1763 GpStatus WINGDIPAPI GdipDrawCurve2(GpGraphics *graphics, GpPen *pen,
1764     GDIPCONST GpPointF *points, INT count, REAL tension)
1765 {
1766     /* PolyBezier expects count*3-2 points. */
1767     INT i, len_pt = count*3-2, save_state;
1768     GpPointF *pt;
1769     REAL x1, x2, y1, y2;
1770     GpStatus retval;
1771
1772     TRACE("(%p, %p, %p, %d, %.2f)\n", graphics, pen, points, count, tension);
1773
1774     if(!graphics || !pen)
1775         return InvalidParameter;
1776
1777     if(graphics->busy)
1778         return ObjectBusy;
1779
1780     if(count < 2)
1781         return InvalidParameter;
1782
1783     pt = GdipAlloc(len_pt * sizeof(GpPointF));
1784     if(!pt)
1785         return OutOfMemory;
1786
1787     tension = tension * TENSION_CONST;
1788
1789     calc_curve_bezier_endp(points[0].X, points[0].Y, points[1].X, points[1].Y,
1790         tension, &x1, &y1);
1791
1792     pt[0].X = points[0].X;
1793     pt[0].Y = points[0].Y;
1794     pt[1].X = x1;
1795     pt[1].Y = y1;
1796
1797     for(i = 0; i < count-2; i++){
1798         calc_curve_bezier(&(points[i]), tension, &x1, &y1, &x2, &y2);
1799
1800         pt[3*i+2].X = x1;
1801         pt[3*i+2].Y = y1;
1802         pt[3*i+3].X = points[i+1].X;
1803         pt[3*i+3].Y = points[i+1].Y;
1804         pt[3*i+4].X = x2;
1805         pt[3*i+4].Y = y2;
1806     }
1807
1808     calc_curve_bezier_endp(points[count-1].X, points[count-1].Y,
1809         points[count-2].X, points[count-2].Y, tension, &x1, &y1);
1810
1811     pt[len_pt-2].X = x1;
1812     pt[len_pt-2].Y = y1;
1813     pt[len_pt-1].X = points[count-1].X;
1814     pt[len_pt-1].Y = points[count-1].Y;
1815
1816     save_state = prepare_dc(graphics, pen);
1817
1818     retval = draw_polybezier(graphics, pen, pt, len_pt, TRUE);
1819
1820     GdipFree(pt);
1821     restore_dc(graphics, save_state);
1822
1823     return retval;
1824 }
1825
1826 GpStatus WINGDIPAPI GdipDrawCurve2I(GpGraphics *graphics, GpPen *pen,
1827     GDIPCONST GpPoint *points, INT count, REAL tension)
1828 {
1829     GpPointF *pointsF;
1830     GpStatus ret;
1831     INT i;
1832
1833     TRACE("(%p, %p, %p, %d, %.2f)\n", graphics, pen, points, count, tension);
1834
1835     if(!points)
1836         return InvalidParameter;
1837
1838     pointsF = GdipAlloc(sizeof(GpPointF)*count);
1839     if(!pointsF)
1840         return OutOfMemory;
1841
1842     for(i = 0; i < count; i++){
1843         pointsF[i].X = (REAL)points[i].X;
1844         pointsF[i].Y = (REAL)points[i].Y;
1845     }
1846
1847     ret = GdipDrawCurve2(graphics,pen,pointsF,count,tension);
1848     GdipFree(pointsF);
1849
1850     return ret;
1851 }
1852
1853 GpStatus WINGDIPAPI GdipDrawCurve3(GpGraphics *graphics, GpPen *pen,
1854     GDIPCONST GpPointF *points, INT count, INT offset, INT numberOfSegments,
1855     REAL tension)
1856 {
1857     TRACE("(%p, %p, %p, %d, %d, %d, %.2f)\n", graphics, pen, points, count, offset, numberOfSegments, tension);
1858
1859     if(offset >= count || numberOfSegments > count - offset - 1 || numberOfSegments <= 0){
1860         return InvalidParameter;
1861     }
1862
1863     return GdipDrawCurve2(graphics, pen, points + offset, numberOfSegments + 1, tension);
1864 }
1865
1866 GpStatus WINGDIPAPI GdipDrawCurve3I(GpGraphics *graphics, GpPen *pen,
1867     GDIPCONST GpPoint *points, INT count, INT offset, INT numberOfSegments,
1868     REAL tension)
1869 {
1870     TRACE("(%p, %p, %p, %d, %d, %d, %.2f)\n", graphics, pen, points, count, offset, numberOfSegments, tension);
1871
1872     if(count < 0){
1873         return OutOfMemory;
1874     }
1875
1876     if(offset >= count || numberOfSegments > count - offset - 1 || numberOfSegments <= 0){
1877         return InvalidParameter;
1878     }
1879
1880     return GdipDrawCurve2I(graphics, pen, points + offset, numberOfSegments + 1, tension);
1881 }
1882
1883 GpStatus WINGDIPAPI GdipDrawEllipse(GpGraphics *graphics, GpPen *pen, REAL x,
1884     REAL y, REAL width, REAL height)
1885 {
1886     INT save_state;
1887     GpPointF ptf[2];
1888     POINT pti[2];
1889
1890     TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f)\n", graphics, pen, x, y, width, height);
1891
1892     if(!graphics || !pen)
1893         return InvalidParameter;
1894
1895     if(graphics->busy)
1896         return ObjectBusy;
1897
1898     ptf[0].X = x;
1899     ptf[0].Y = y;
1900     ptf[1].X = x + width;
1901     ptf[1].Y = y + height;
1902
1903     save_state = prepare_dc(graphics, pen);
1904     SelectObject(graphics->hdc, GetStockObject(NULL_BRUSH));
1905
1906     transform_and_round_points(graphics, pti, ptf, 2);
1907
1908     Ellipse(graphics->hdc, pti[0].x, pti[0].y, pti[1].x, pti[1].y);
1909
1910     restore_dc(graphics, save_state);
1911
1912     return Ok;
1913 }
1914
1915 GpStatus WINGDIPAPI GdipDrawEllipseI(GpGraphics *graphics, GpPen *pen, INT x,
1916     INT y, INT width, INT height)
1917 {
1918     TRACE("(%p, %p, %d, %d, %d, %d)\n", graphics, pen, x, y, width, height);
1919
1920     return GdipDrawEllipse(graphics,pen,(REAL)x,(REAL)y,(REAL)width,(REAL)height);
1921 }
1922
1923
1924 GpStatus WINGDIPAPI GdipDrawImage(GpGraphics *graphics, GpImage *image, REAL x, REAL y)
1925 {
1926     UINT width, height;
1927     GpPointF points[3];
1928
1929     TRACE("(%p, %p, %.2f, %.2f)\n", graphics, image, x, y);
1930
1931     if(!graphics || !image)
1932         return InvalidParameter;
1933
1934     GdipGetImageWidth(image, &width);
1935     GdipGetImageHeight(image, &height);
1936
1937     /* FIXME: we should use the graphics and image dpi, somehow */
1938
1939     points[0].X = points[2].X = x;
1940     points[0].Y = points[1].Y = y;
1941     points[1].X = x + width;
1942     points[2].Y = y + height;
1943
1944     return GdipDrawImagePointsRect(graphics, image, points, 3, 0, 0, width, height,
1945         UnitPixel, NULL, NULL, NULL);
1946 }
1947
1948 GpStatus WINGDIPAPI GdipDrawImageI(GpGraphics *graphics, GpImage *image, INT x,
1949     INT y)
1950 {
1951     TRACE("(%p, %p, %d, %d)\n", graphics, image, x, y);
1952
1953     return GdipDrawImage(graphics, image, (REAL)x, (REAL)y);
1954 }
1955
1956 GpStatus WINGDIPAPI GdipDrawImagePointRect(GpGraphics *graphics, GpImage *image,
1957     REAL x, REAL y, REAL srcx, REAL srcy, REAL srcwidth, REAL srcheight,
1958     GpUnit srcUnit)
1959 {
1960     GpPointF points[3];
1961     TRACE("(%p, %p, %f, %f, %f, %f, %f, %f, %d)\n", graphics, image, x, y, srcx, srcy, srcwidth, srcheight, srcUnit);
1962
1963     points[0].X = points[2].X = x;
1964     points[0].Y = points[1].Y = y;
1965
1966     /* FIXME: convert image coordinates to Graphics coordinates? */
1967     points[1].X = x + srcwidth;
1968     points[2].Y = y + srcheight;
1969
1970     return GdipDrawImagePointsRect(graphics, image, points, 3, srcx, srcy,
1971         srcwidth, srcheight, srcUnit, NULL, NULL, NULL);
1972 }
1973
1974 GpStatus WINGDIPAPI GdipDrawImagePointRectI(GpGraphics *graphics, GpImage *image,
1975     INT x, INT y, INT srcx, INT srcy, INT srcwidth, INT srcheight,
1976     GpUnit srcUnit)
1977 {
1978     return GdipDrawImagePointRect(graphics, image, x, y, srcx, srcy, srcwidth, srcheight, srcUnit);
1979 }
1980
1981 GpStatus WINGDIPAPI GdipDrawImagePoints(GpGraphics *graphics, GpImage *image,
1982     GDIPCONST GpPointF *dstpoints, INT count)
1983 {
1984     FIXME("(%p, %p, %p, %d): stub\n", graphics, image, dstpoints, count);
1985     return NotImplemented;
1986 }
1987
1988 GpStatus WINGDIPAPI GdipDrawImagePointsI(GpGraphics *graphics, GpImage *image,
1989     GDIPCONST GpPoint *dstpoints, INT count)
1990 {
1991     FIXME("(%p, %p, %p, %d): stub\n", graphics, image, dstpoints, count);
1992     return NotImplemented;
1993 }
1994
1995 GpStatus WINGDIPAPI GdipDrawImagePointsRect(GpGraphics *graphics, GpImage *image,
1996      GDIPCONST GpPointF *points, INT count, REAL srcx, REAL srcy, REAL srcwidth,
1997      REAL srcheight, GpUnit srcUnit, GDIPCONST GpImageAttributes* imageAttributes,
1998      DrawImageAbort callback, VOID * callbackData)
1999 {
2000     GpPointF ptf[4];
2001     POINT pti[4];
2002     REAL dx, dy;
2003     GpStatus stat;
2004
2005     TRACE("(%p, %p, %p, %d, %f, %f, %f, %f, %d, %p, %p, %p)\n", graphics, image, points,
2006           count, srcx, srcy, srcwidth, srcheight, srcUnit, imageAttributes, callback,
2007           callbackData);
2008
2009     if(!graphics || !image || !points || count != 3)
2010          return InvalidParameter;
2011
2012     TRACE("%s %s %s\n", debugstr_pointf(&points[0]), debugstr_pointf(&points[1]),
2013         debugstr_pointf(&points[2]));
2014
2015     memcpy(ptf, points, 3 * sizeof(GpPointF));
2016     ptf[3].X = ptf[2].X + ptf[1].X - ptf[0].X;
2017     ptf[3].Y = ptf[2].Y + ptf[1].Y - ptf[0].Y;
2018     transform_and_round_points(graphics, pti, ptf, 4);
2019
2020     if (image->picture)
2021     {
2022         if (!graphics->hdc)
2023         {
2024             FIXME("graphics object has no HDC\n");
2025         }
2026
2027         /* FIXME: partially implemented (only works for rectangular parallelograms) */
2028         if(srcUnit == UnitInch)
2029             dx = dy = (REAL) INCH_HIMETRIC;
2030         else if(srcUnit == UnitPixel){
2031             dx = ((REAL) INCH_HIMETRIC) /
2032                  ((REAL) GetDeviceCaps(graphics->hdc, LOGPIXELSX));
2033             dy = ((REAL) INCH_HIMETRIC) /
2034                  ((REAL) GetDeviceCaps(graphics->hdc, LOGPIXELSY));
2035         }
2036         else
2037             return NotImplemented;
2038
2039         if(IPicture_Render(image->picture, graphics->hdc,
2040             pti[0].x, pti[0].y, pti[1].x - pti[0].x, pti[2].y - pti[0].y,
2041             srcx * dx, srcy * dy,
2042             srcwidth * dx, srcheight * dy,
2043             NULL) != S_OK){
2044             if(callback)
2045                 callback(callbackData);
2046             return GenericError;
2047         }
2048     }
2049     else if (image->type == ImageTypeBitmap)
2050     {
2051         GpBitmap* bitmap = (GpBitmap*)image;
2052         int use_software=0;
2053
2054         if (srcUnit == UnitInch)
2055             dx = dy = 96.0; /* FIXME: use the image resolution */
2056         else if (srcUnit == UnitPixel)
2057             dx = dy = 1.0;
2058         else
2059             return NotImplemented;
2060
2061         if (imageAttributes ||
2062             (graphics->image && graphics->image->type == ImageTypeBitmap) ||
2063             !((GpBitmap*)image)->hbitmap ||
2064             ptf[1].Y != ptf[0].Y || ptf[2].X != ptf[0].X)
2065             use_software = 1;
2066
2067         if (use_software)
2068         {
2069             RECT src_area, dst_area;
2070             int i, x, y, stride;
2071             GpMatrix *dst_to_src;
2072             REAL m11, m12, m21, m22, mdx, mdy;
2073             LPBYTE data;
2074
2075             src_area.left = srcx*dx;
2076             src_area.top = srcy*dy;
2077             src_area.right = (srcx+srcwidth)*dx;
2078             src_area.bottom = (srcy+srcheight)*dy;
2079
2080             dst_area.left = dst_area.right = pti[0].x;
2081             dst_area.top = dst_area.bottom = pti[0].y;
2082             for (i=1; i<4; i++)
2083             {
2084                 if (dst_area.left > pti[i].x) dst_area.left = pti[i].x;
2085                 if (dst_area.right < pti[i].x) dst_area.right = pti[i].x;
2086                 if (dst_area.top > pti[i].y) dst_area.top = pti[i].y;
2087                 if (dst_area.bottom < pti[i].y) dst_area.bottom = pti[i].y;
2088             }
2089
2090             m11 = (ptf[1].X - ptf[0].X) / srcwidth;
2091             m21 = (ptf[2].X - ptf[0].X) / srcheight;
2092             mdx = ptf[0].X - m11 * srcx - m21 * srcy;
2093             m12 = (ptf[1].Y - ptf[0].Y) / srcwidth;
2094             m22 = (ptf[2].Y - ptf[0].Y) / srcheight;
2095             mdy = ptf[0].Y - m12 * srcx - m22 * srcy;
2096
2097             stat = GdipCreateMatrix2(m11, m12, m21, m22, mdx, mdy, &dst_to_src);
2098             if (stat != Ok) return stat;
2099
2100             stat = GdipInvertMatrix(dst_to_src);
2101             if (stat != Ok)
2102             {
2103                 GdipDeleteMatrix(dst_to_src);
2104                 return stat;
2105             }
2106
2107             data = GdipAlloc(sizeof(ARGB) * (dst_area.right - dst_area.left) * (dst_area.bottom - dst_area.top));
2108             if (!data)
2109             {
2110                 GdipDeleteMatrix(dst_to_src);
2111                 return OutOfMemory;
2112             }
2113
2114             stride = sizeof(ARGB) * (dst_area.right - dst_area.left);
2115
2116             if (imageAttributes &&
2117                 (imageAttributes->wrap != WrapModeClamp ||
2118                  imageAttributes->outside_color != 0x00000000 ||
2119                  imageAttributes->clamp))
2120             {
2121                 static int fixme;
2122                 if (!fixme++)
2123                     FIXME("Image wrap mode not implemented\n");
2124             }
2125
2126             for (x=dst_area.left; x<dst_area.right; x++)
2127             {
2128                 for (y=dst_area.top; y<dst_area.bottom; y++)
2129                 {
2130                     GpPointF src_pointf;
2131                     int src_x, src_y;
2132                     ARGB *src_color;
2133
2134                     src_pointf.X = x;
2135                     src_pointf.Y = y;
2136
2137                     GdipTransformMatrixPoints(dst_to_src, &src_pointf, 1);
2138
2139                     src_x = roundr(src_pointf.X);
2140                     src_y = roundr(src_pointf.Y);
2141
2142                     src_color = (ARGB*)(data + stride * (y - dst_area.top) + sizeof(ARGB) * (x - dst_area.left));
2143
2144                     if (src_x < src_area.left || src_x >= src_area.right ||
2145                         src_y < src_area.top || src_y >= src_area.bottom)
2146                         *src_color = 0;
2147                     else
2148                         GdipBitmapGetPixel(bitmap, src_x, src_y, src_color);
2149                 }
2150             }
2151
2152             GdipDeleteMatrix(dst_to_src);
2153
2154             if (imageAttributes)
2155             {
2156                 if (imageAttributes->colorkeys[ColorAdjustTypeBitmap].enabled ||
2157                     imageAttributes->colorkeys[ColorAdjustTypeDefault].enabled)
2158                 {
2159                     const struct color_key *key;
2160                     BYTE min_blue, min_green, min_red;
2161                     BYTE max_blue, max_green, max_red;
2162
2163                     if (imageAttributes->colorkeys[ColorAdjustTypeBitmap].enabled)
2164                         key = &imageAttributes->colorkeys[ColorAdjustTypeBitmap];
2165                     else
2166                         key = &imageAttributes->colorkeys[ColorAdjustTypeDefault];
2167
2168                     min_blue = key->low&0xff;
2169                     min_green = (key->low>>8)&0xff;
2170                     min_red = (key->low>>16)&0xff;
2171
2172                     max_blue = key->high&0xff;
2173                     max_green = (key->high>>8)&0xff;
2174                     max_red = (key->high>>16)&0xff;
2175
2176                     for (x=dst_area.left; x<dst_area.right; x++)
2177                         for (y=dst_area.top; y<dst_area.bottom; y++)
2178                         {
2179                             ARGB *src_color;
2180                             BYTE blue, green, red;
2181                             src_color = (ARGB*)(data + stride * (y - dst_area.top) + sizeof(ARGB) * (x - dst_area.left));
2182                             blue = *src_color&0xff;
2183                             green = (*src_color>>8)&0xff;
2184                             red = (*src_color>>16)&0xff;
2185                             if (blue >= min_blue && green >= min_green && red >= min_red &&
2186                                 blue <= max_blue && green <= max_green && red <= max_red)
2187                                 *src_color = 0x00000000;
2188                         }
2189                 }
2190
2191                 if (imageAttributes->colorremaptables[ColorAdjustTypeBitmap].enabled ||
2192                     imageAttributes->colorremaptables[ColorAdjustTypeDefault].enabled)
2193                 {
2194                     const struct color_remap_table *table;
2195
2196                     if (imageAttributes->colorremaptables[ColorAdjustTypeBitmap].enabled)
2197                         table = &imageAttributes->colorremaptables[ColorAdjustTypeBitmap];
2198                     else
2199                         table = &imageAttributes->colorremaptables[ColorAdjustTypeDefault];
2200
2201                     for (x=dst_area.left; x<dst_area.right; x++)
2202                         for (y=dst_area.top; y<dst_area.bottom; y++)
2203                         {
2204                             ARGB *src_color;
2205                             src_color = (ARGB*)(data + stride * (y - dst_area.top) + sizeof(ARGB) * (x - dst_area.left));
2206                             for (i=0; i<table->mapsize; i++)
2207                             {
2208                                 if (*src_color == table->colormap[i].oldColor.Argb)
2209                                 {
2210                                     *src_color = table->colormap[i].newColor.Argb;
2211                                     break;
2212                                 }
2213                             }
2214                         }
2215                 }
2216
2217                 if (imageAttributes->colormatrices[ColorAdjustTypeBitmap].enabled ||
2218                     imageAttributes->colormatrices[ColorAdjustTypeDefault].enabled)
2219                 {
2220                     static int fixme;
2221                     if (!fixme++)
2222                         FIXME("Color transforms not implemented\n");
2223                 }
2224
2225                 if (imageAttributes->gamma_enabled[ColorAdjustTypeBitmap] ||
2226                     imageAttributes->gamma_enabled[ColorAdjustTypeDefault])
2227                 {
2228                     static int fixme;
2229                     if (!fixme++)
2230                         FIXME("Gamma adjustment not implemented\n");
2231                 }
2232             }
2233
2234             stat = alpha_blend_pixels(graphics, dst_area.left, dst_area.top,
2235                 data, dst_area.right - dst_area.left, dst_area.bottom - dst_area.top, stride);
2236
2237             GdipFree(data);
2238
2239             return stat;
2240         }
2241         else
2242         {
2243             HDC hdc;
2244             int temp_hdc=0, temp_bitmap=0;
2245             HBITMAP hbitmap, old_hbm=NULL;
2246
2247             if (!(bitmap->format == PixelFormat16bppRGB555 ||
2248                   bitmap->format == PixelFormat24bppRGB ||
2249                   bitmap->format == PixelFormat32bppRGB ||
2250                   bitmap->format == PixelFormat32bppPARGB))
2251             {
2252                 BITMAPINFOHEADER bih;
2253                 BYTE *temp_bits;
2254                 PixelFormat dst_format;
2255
2256                 /* we can't draw a bitmap of this format directly */
2257                 hdc = CreateCompatibleDC(0);
2258                 temp_hdc = 1;
2259                 temp_bitmap = 1;
2260
2261                 bih.biSize = sizeof(BITMAPINFOHEADER);
2262                 bih.biWidth = bitmap->width;
2263                 bih.biHeight = -bitmap->height;
2264                 bih.biPlanes = 1;
2265                 bih.biBitCount = 32;
2266                 bih.biCompression = BI_RGB;
2267                 bih.biSizeImage = 0;
2268                 bih.biXPelsPerMeter = 0;
2269                 bih.biYPelsPerMeter = 0;
2270                 bih.biClrUsed = 0;
2271                 bih.biClrImportant = 0;
2272
2273                 hbitmap = CreateDIBSection(hdc, (BITMAPINFO*)&bih, DIB_RGB_COLORS,
2274                     (void**)&temp_bits, NULL, 0);
2275
2276                 if (bitmap->format & (PixelFormatAlpha|PixelFormatPAlpha))
2277                     dst_format = PixelFormat32bppPARGB;
2278                 else
2279                     dst_format = PixelFormat32bppRGB;
2280
2281                 convert_pixels(bitmap->width, bitmap->height,
2282                     bitmap->width*4, temp_bits, dst_format,
2283                     bitmap->stride, bitmap->bits, bitmap->format, bitmap->image.palette_entries);
2284             }
2285             else
2286             {
2287                 hbitmap = bitmap->hbitmap;
2288                 hdc = bitmap->hdc;
2289                 temp_hdc = (hdc == 0);
2290             }
2291
2292             if (temp_hdc)
2293             {
2294                 if (!hdc) hdc = CreateCompatibleDC(0);
2295                 old_hbm = SelectObject(hdc, hbitmap);
2296             }
2297
2298             if (bitmap->format & (PixelFormatAlpha|PixelFormatPAlpha))
2299             {
2300                 BLENDFUNCTION bf;
2301
2302                 bf.BlendOp = AC_SRC_OVER;
2303                 bf.BlendFlags = 0;
2304                 bf.SourceConstantAlpha = 255;
2305                 bf.AlphaFormat = AC_SRC_ALPHA;
2306
2307                 GdiAlphaBlend(graphics->hdc, pti[0].x, pti[0].y, pti[1].x-pti[0].x, pti[2].y-pti[0].y,
2308                     hdc, srcx*dx, srcy*dy, srcwidth*dx, srcheight*dy, bf);
2309             }
2310             else
2311             {
2312                 StretchBlt(graphics->hdc, pti[0].x, pti[0].y, pti[1].x-pti[0].x, pti[2].y-pti[0].y,
2313                     hdc, srcx*dx, srcy*dy, srcwidth*dx, srcheight*dy, SRCCOPY);
2314             }
2315
2316             if (temp_hdc)
2317             {
2318                 SelectObject(hdc, old_hbm);
2319                 DeleteDC(hdc);
2320             }
2321
2322             if (temp_bitmap)
2323                 DeleteObject(hbitmap);
2324         }
2325     }
2326     else
2327     {
2328         ERR("GpImage with no IPicture or HBITMAP?!\n");
2329         return NotImplemented;
2330     }
2331
2332     return Ok;
2333 }
2334
2335 GpStatus WINGDIPAPI GdipDrawImagePointsRectI(GpGraphics *graphics, GpImage *image,
2336      GDIPCONST GpPoint *points, INT count, INT srcx, INT srcy, INT srcwidth,
2337      INT srcheight, GpUnit srcUnit, GDIPCONST GpImageAttributes* imageAttributes,
2338      DrawImageAbort callback, VOID * callbackData)
2339 {
2340     GpPointF pointsF[3];
2341     INT i;
2342
2343     TRACE("(%p, %p, %p, %d, %d, %d, %d, %d, %d, %p, %p, %p)\n", graphics, image, points, count,
2344           srcx, srcy, srcwidth, srcheight, srcUnit, imageAttributes, callback,
2345           callbackData);
2346
2347     if(!points || count!=3)
2348         return InvalidParameter;
2349
2350     for(i = 0; i < count; i++){
2351         pointsF[i].X = (REAL)points[i].X;
2352         pointsF[i].Y = (REAL)points[i].Y;
2353     }
2354
2355     return GdipDrawImagePointsRect(graphics, image, pointsF, count, (REAL)srcx, (REAL)srcy,
2356                                    (REAL)srcwidth, (REAL)srcheight, srcUnit, imageAttributes,
2357                                    callback, callbackData);
2358 }
2359
2360 GpStatus WINGDIPAPI GdipDrawImageRectRect(GpGraphics *graphics, GpImage *image,
2361     REAL dstx, REAL dsty, REAL dstwidth, REAL dstheight, REAL srcx, REAL srcy,
2362     REAL srcwidth, REAL srcheight, GpUnit srcUnit,
2363     GDIPCONST GpImageAttributes* imageattr, DrawImageAbort callback,
2364     VOID * callbackData)
2365 {
2366     GpPointF points[3];
2367
2368     TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %d, %p, %p, %p)\n",
2369           graphics, image, dstx, dsty, dstwidth, dstheight, srcx, srcy,
2370           srcwidth, srcheight, srcUnit, imageattr, callback, callbackData);
2371
2372     points[0].X = dstx;
2373     points[0].Y = dsty;
2374     points[1].X = dstx + dstwidth;
2375     points[1].Y = dsty;
2376     points[2].X = dstx;
2377     points[2].Y = dsty + dstheight;
2378
2379     return GdipDrawImagePointsRect(graphics, image, points, 3, srcx, srcy,
2380                srcwidth, srcheight, srcUnit, imageattr, callback, callbackData);
2381 }
2382
2383 GpStatus WINGDIPAPI GdipDrawImageRectRectI(GpGraphics *graphics, GpImage *image,
2384         INT dstx, INT dsty, INT dstwidth, INT dstheight, INT srcx, INT srcy,
2385         INT srcwidth, INT srcheight, GpUnit srcUnit,
2386         GDIPCONST GpImageAttributes* imageAttributes, DrawImageAbort callback,
2387         VOID * callbackData)
2388 {
2389     GpPointF points[3];
2390
2391     TRACE("(%p, %p, %d, %d, %d, %d, %d, %d, %d, %d, %d, %p, %p, %p)\n",
2392           graphics, image, dstx, dsty, dstwidth, dstheight, srcx, srcy,
2393           srcwidth, srcheight, srcUnit, imageAttributes, callback, callbackData);
2394
2395     points[0].X = dstx;
2396     points[0].Y = dsty;
2397     points[1].X = dstx + dstwidth;
2398     points[1].Y = dsty;
2399     points[2].X = dstx;
2400     points[2].Y = dsty + dstheight;
2401
2402     return GdipDrawImagePointsRect(graphics, image, points, 3, srcx, srcy,
2403                srcwidth, srcheight, srcUnit, imageAttributes, callback, callbackData);
2404 }
2405
2406 GpStatus WINGDIPAPI GdipDrawImageRect(GpGraphics *graphics, GpImage *image,
2407     REAL x, REAL y, REAL width, REAL height)
2408 {
2409     RectF bounds;
2410     GpUnit unit;
2411     GpStatus ret;
2412
2413     TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f)\n", graphics, image, x, y, width, height);
2414
2415     if(!graphics || !image)
2416         return InvalidParameter;
2417
2418     ret = GdipGetImageBounds(image, &bounds, &unit);
2419     if(ret != Ok)
2420         return ret;
2421
2422     return GdipDrawImageRectRect(graphics, image, x, y, width, height,
2423                                  bounds.X, bounds.Y, bounds.Width, bounds.Height,
2424                                  unit, NULL, NULL, NULL);
2425 }
2426
2427 GpStatus WINGDIPAPI GdipDrawImageRectI(GpGraphics *graphics, GpImage *image,
2428     INT x, INT y, INT width, INT height)
2429 {
2430     TRACE("(%p, %p, %d, %d, %d, %d)\n", graphics, image, x, y, width, height);
2431
2432     return GdipDrawImageRect(graphics, image, (REAL)x, (REAL)y, (REAL)width, (REAL)height);
2433 }
2434
2435 GpStatus WINGDIPAPI GdipDrawLine(GpGraphics *graphics, GpPen *pen, REAL x1,
2436     REAL y1, REAL x2, REAL y2)
2437 {
2438     INT save_state;
2439     GpPointF pt[2];
2440     GpStatus retval;
2441
2442     TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f)\n", graphics, pen, x1, y1, x2, y2);
2443
2444     if(!pen || !graphics)
2445         return InvalidParameter;
2446
2447     if(graphics->busy)
2448         return ObjectBusy;
2449
2450     pt[0].X = x1;
2451     pt[0].Y = y1;
2452     pt[1].X = x2;
2453     pt[1].Y = y2;
2454
2455     save_state = prepare_dc(graphics, pen);
2456
2457     retval = draw_polyline(graphics, pen, pt, 2, TRUE);
2458
2459     restore_dc(graphics, save_state);
2460
2461     return retval;
2462 }
2463
2464 GpStatus WINGDIPAPI GdipDrawLineI(GpGraphics *graphics, GpPen *pen, INT x1,
2465     INT y1, INT x2, INT y2)
2466 {
2467     INT save_state;
2468     GpPointF pt[2];
2469     GpStatus retval;
2470
2471     TRACE("(%p, %p, %d, %d, %d, %d)\n", graphics, pen, x1, y1, x2, y2);
2472
2473     if(!pen || !graphics)
2474         return InvalidParameter;
2475
2476     if(graphics->busy)
2477         return ObjectBusy;
2478
2479     pt[0].X = (REAL)x1;
2480     pt[0].Y = (REAL)y1;
2481     pt[1].X = (REAL)x2;
2482     pt[1].Y = (REAL)y2;
2483
2484     save_state = prepare_dc(graphics, pen);
2485
2486     retval = draw_polyline(graphics, pen, pt, 2, TRUE);
2487
2488     restore_dc(graphics, save_state);
2489
2490     return retval;
2491 }
2492
2493 GpStatus WINGDIPAPI GdipDrawLines(GpGraphics *graphics, GpPen *pen, GDIPCONST
2494     GpPointF *points, INT count)
2495 {
2496     INT save_state;
2497     GpStatus retval;
2498
2499     TRACE("(%p, %p, %p, %d)\n", graphics, pen, points, count);
2500
2501     if(!pen || !graphics || (count < 2))
2502         return InvalidParameter;
2503
2504     if(graphics->busy)
2505         return ObjectBusy;
2506
2507     save_state = prepare_dc(graphics, pen);
2508
2509     retval = draw_polyline(graphics, pen, points, count, TRUE);
2510
2511     restore_dc(graphics, save_state);
2512
2513     return retval;
2514 }
2515
2516 GpStatus WINGDIPAPI GdipDrawLinesI(GpGraphics *graphics, GpPen *pen, GDIPCONST
2517     GpPoint *points, INT count)
2518 {
2519     INT save_state;
2520     GpStatus retval;
2521     GpPointF *ptf = NULL;
2522     int i;
2523
2524     TRACE("(%p, %p, %p, %d)\n", graphics, pen, points, count);
2525
2526     if(!pen || !graphics || (count < 2))
2527         return InvalidParameter;
2528
2529     if(graphics->busy)
2530         return ObjectBusy;
2531
2532     ptf = GdipAlloc(count * sizeof(GpPointF));
2533     if(!ptf) return OutOfMemory;
2534
2535     for(i = 0; i < count; i ++){
2536         ptf[i].X = (REAL) points[i].X;
2537         ptf[i].Y = (REAL) points[i].Y;
2538     }
2539
2540     save_state = prepare_dc(graphics, pen);
2541
2542     retval = draw_polyline(graphics, pen, ptf, count, TRUE);
2543
2544     restore_dc(graphics, save_state);
2545
2546     GdipFree(ptf);
2547     return retval;
2548 }
2549
2550 GpStatus WINGDIPAPI GdipDrawPath(GpGraphics *graphics, GpPen *pen, GpPath *path)
2551 {
2552     INT save_state;
2553     GpStatus retval;
2554
2555     TRACE("(%p, %p, %p)\n", graphics, pen, path);
2556
2557     if(!pen || !graphics)
2558         return InvalidParameter;
2559
2560     if(graphics->busy)
2561         return ObjectBusy;
2562
2563     save_state = prepare_dc(graphics, pen);
2564
2565     retval = draw_poly(graphics, pen, path->pathdata.Points,
2566                        path->pathdata.Types, path->pathdata.Count, TRUE);
2567
2568     restore_dc(graphics, save_state);
2569
2570     return retval;
2571 }
2572
2573 GpStatus WINGDIPAPI GdipDrawPie(GpGraphics *graphics, GpPen *pen, REAL x,
2574     REAL y, REAL width, REAL height, REAL startAngle, REAL sweepAngle)
2575 {
2576     INT save_state;
2577
2578     TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f)\n", graphics, pen, x, y,
2579             width, height, startAngle, sweepAngle);
2580
2581     if(!graphics || !pen)
2582         return InvalidParameter;
2583
2584     if(graphics->busy)
2585         return ObjectBusy;
2586
2587     save_state = prepare_dc(graphics, pen);
2588     SelectObject(graphics->hdc, GetStockObject(NULL_BRUSH));
2589
2590     draw_pie(graphics, x, y, width, height, startAngle, sweepAngle);
2591
2592     restore_dc(graphics, save_state);
2593
2594     return Ok;
2595 }
2596
2597 GpStatus WINGDIPAPI GdipDrawPieI(GpGraphics *graphics, GpPen *pen, INT x,
2598     INT y, INT width, INT height, REAL startAngle, REAL sweepAngle)
2599 {
2600     TRACE("(%p, %p, %d, %d, %d, %d, %.2f, %.2f)\n", graphics, pen, x, y,
2601             width, height, startAngle, sweepAngle);
2602
2603     return GdipDrawPie(graphics,pen,(REAL)x,(REAL)y,(REAL)width,(REAL)height,startAngle,sweepAngle);
2604 }
2605
2606 GpStatus WINGDIPAPI GdipDrawRectangle(GpGraphics *graphics, GpPen *pen, REAL x,
2607     REAL y, REAL width, REAL height)
2608 {
2609     INT save_state;
2610     GpPointF ptf[4];
2611     POINT pti[4];
2612
2613     TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f)\n", graphics, pen, x, y, width, height);
2614
2615     if(!pen || !graphics)
2616         return InvalidParameter;
2617
2618     if(graphics->busy)
2619         return ObjectBusy;
2620
2621     ptf[0].X = x;
2622     ptf[0].Y = y;
2623     ptf[1].X = x + width;
2624     ptf[1].Y = y;
2625     ptf[2].X = x + width;
2626     ptf[2].Y = y + height;
2627     ptf[3].X = x;
2628     ptf[3].Y = y + height;
2629
2630     save_state = prepare_dc(graphics, pen);
2631     SelectObject(graphics->hdc, GetStockObject(NULL_BRUSH));
2632
2633     transform_and_round_points(graphics, pti, ptf, 4);
2634     Polygon(graphics->hdc, pti, 4);
2635
2636     restore_dc(graphics, save_state);
2637
2638     return Ok;
2639 }
2640
2641 GpStatus WINGDIPAPI GdipDrawRectangleI(GpGraphics *graphics, GpPen *pen, INT x,
2642     INT y, INT width, INT height)
2643 {
2644     TRACE("(%p, %p, %d, %d, %d, %d)\n", graphics, pen, x, y, width, height);
2645
2646     return GdipDrawRectangle(graphics,pen,(REAL)x,(REAL)y,(REAL)width,(REAL)height);
2647 }
2648
2649 GpStatus WINGDIPAPI GdipDrawRectangles(GpGraphics *graphics, GpPen *pen,
2650     GDIPCONST GpRectF* rects, INT count)
2651 {
2652     GpPointF *ptf;
2653     POINT *pti;
2654     INT save_state, i;
2655
2656     TRACE("(%p, %p, %p, %d)\n", graphics, pen, rects, count);
2657
2658     if(!graphics || !pen || !rects || count < 1)
2659         return InvalidParameter;
2660
2661     if(graphics->busy)
2662         return ObjectBusy;
2663
2664     ptf = GdipAlloc(4 * count * sizeof(GpPointF));
2665     pti = GdipAlloc(4 * count * sizeof(POINT));
2666
2667     if(!ptf || !pti){
2668         GdipFree(ptf);
2669         GdipFree(pti);
2670         return OutOfMemory;
2671     }
2672
2673     for(i = 0; i < count; i++){
2674         ptf[4 * i + 3].X = ptf[4 * i].X = rects[i].X;
2675         ptf[4 * i + 1].Y = ptf[4 * i].Y = rects[i].Y;
2676         ptf[4 * i + 2].X = ptf[4 * i + 1].X = rects[i].X + rects[i].Width;
2677         ptf[4 * i + 3].Y = ptf[4 * i + 2].Y = rects[i].Y + rects[i].Height;
2678     }
2679
2680     save_state = prepare_dc(graphics, pen);
2681     SelectObject(graphics->hdc, GetStockObject(NULL_BRUSH));
2682
2683     transform_and_round_points(graphics, pti, ptf, 4 * count);
2684
2685     for(i = 0; i < count; i++)
2686         Polygon(graphics->hdc, &pti[4 * i], 4);
2687
2688     restore_dc(graphics, save_state);
2689
2690     GdipFree(ptf);
2691     GdipFree(pti);
2692
2693     return Ok;
2694 }
2695
2696 GpStatus WINGDIPAPI GdipDrawRectanglesI(GpGraphics *graphics, GpPen *pen,
2697     GDIPCONST GpRect* rects, INT count)
2698 {
2699     GpRectF *rectsF;
2700     GpStatus ret;
2701     INT i;
2702
2703     TRACE("(%p, %p, %p, %d)\n", graphics, pen, rects, count);
2704
2705     if(!rects || count<=0)
2706         return InvalidParameter;
2707
2708     rectsF = GdipAlloc(sizeof(GpRectF) * count);
2709     if(!rectsF)
2710         return OutOfMemory;
2711
2712     for(i = 0;i < count;i++){
2713         rectsF[i].X      = (REAL)rects[i].X;
2714         rectsF[i].Y      = (REAL)rects[i].Y;
2715         rectsF[i].Width  = (REAL)rects[i].Width;
2716         rectsF[i].Height = (REAL)rects[i].Height;
2717     }
2718
2719     ret = GdipDrawRectangles(graphics, pen, rectsF, count);
2720     GdipFree(rectsF);
2721
2722     return ret;
2723 }
2724
2725 GpStatus WINGDIPAPI GdipFillClosedCurve2(GpGraphics *graphics, GpBrush *brush,
2726     GDIPCONST GpPointF *points, INT count, REAL tension, GpFillMode fill)
2727 {
2728     GpPath *path;
2729     GpStatus stat;
2730
2731     TRACE("(%p, %p, %p, %d, %.2f, %d)\n", graphics, brush, points,
2732             count, tension, fill);
2733
2734     if(!graphics || !brush || !points)
2735         return InvalidParameter;
2736
2737     if(graphics->busy)
2738         return ObjectBusy;
2739
2740     if(count == 1)    /* Do nothing */
2741         return Ok;
2742
2743     stat = GdipCreatePath(fill, &path);
2744     if(stat != Ok)
2745         return stat;
2746
2747     stat = GdipAddPathClosedCurve2(path, points, count, tension);
2748     if(stat != Ok){
2749         GdipDeletePath(path);
2750         return stat;
2751     }
2752
2753     stat = GdipFillPath(graphics, brush, path);
2754     if(stat != Ok){
2755         GdipDeletePath(path);
2756         return stat;
2757     }
2758
2759     GdipDeletePath(path);
2760
2761     return Ok;
2762 }
2763
2764 GpStatus WINGDIPAPI GdipFillClosedCurve2I(GpGraphics *graphics, GpBrush *brush,
2765     GDIPCONST GpPoint *points, INT count, REAL tension, GpFillMode fill)
2766 {
2767     GpPointF *ptf;
2768     GpStatus stat;
2769     INT i;
2770
2771     TRACE("(%p, %p, %p, %d, %.2f, %d)\n", graphics, brush, points,
2772             count, tension, fill);
2773
2774     if(!points || count == 0)
2775         return InvalidParameter;
2776
2777     if(count == 1)    /* Do nothing */
2778         return Ok;
2779
2780     ptf = GdipAlloc(sizeof(GpPointF)*count);
2781     if(!ptf)
2782         return OutOfMemory;
2783
2784     for(i = 0;i < count;i++){
2785         ptf[i].X = (REAL)points[i].X;
2786         ptf[i].Y = (REAL)points[i].Y;
2787     }
2788
2789     stat = GdipFillClosedCurve2(graphics, brush, ptf, count, tension, fill);
2790
2791     GdipFree(ptf);
2792
2793     return stat;
2794 }
2795
2796 GpStatus WINGDIPAPI GdipFillClosedCurve(GpGraphics *graphics, GpBrush *brush,
2797     GDIPCONST GpPointF *points, INT count)
2798 {
2799     TRACE("(%p, %p, %p, %d)\n", graphics, brush, points, count);
2800     return GdipFillClosedCurve2(graphics, brush, points, count,
2801                0.5f, FillModeAlternate);
2802 }
2803
2804 GpStatus WINGDIPAPI GdipFillClosedCurveI(GpGraphics *graphics, GpBrush *brush,
2805     GDIPCONST GpPoint *points, INT count)
2806 {
2807     TRACE("(%p, %p, %p, %d)\n", graphics, brush, points, count);
2808     return GdipFillClosedCurve2I(graphics, brush, points, count,
2809                0.5f, FillModeAlternate);
2810 }
2811
2812 GpStatus WINGDIPAPI GdipFillEllipse(GpGraphics *graphics, GpBrush *brush, REAL x,
2813     REAL y, REAL width, REAL height)
2814 {
2815     INT save_state;
2816     GpPointF ptf[2];
2817     POINT pti[2];
2818
2819     TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f)\n", graphics, brush, x, y, width, height);
2820
2821     if(!graphics || !brush)
2822         return InvalidParameter;
2823
2824     if(graphics->busy)
2825         return ObjectBusy;
2826
2827     if(!graphics->hdc)
2828     {
2829         FIXME("graphics object has no HDC\n");
2830         return Ok;
2831     }
2832
2833     ptf[0].X = x;
2834     ptf[0].Y = y;
2835     ptf[1].X = x + width;
2836     ptf[1].Y = y + height;
2837
2838     save_state = SaveDC(graphics->hdc);
2839     EndPath(graphics->hdc);
2840
2841     transform_and_round_points(graphics, pti, ptf, 2);
2842
2843     BeginPath(graphics->hdc);
2844     Ellipse(graphics->hdc, pti[0].x, pti[0].y, pti[1].x, pti[1].y);
2845     EndPath(graphics->hdc);
2846
2847     brush_fill_path(graphics, brush);
2848
2849     RestoreDC(graphics->hdc, save_state);
2850
2851     return Ok;
2852 }
2853
2854 GpStatus WINGDIPAPI GdipFillEllipseI(GpGraphics *graphics, GpBrush *brush, INT x,
2855     INT y, INT width, INT height)
2856 {
2857     TRACE("(%p, %p, %d, %d, %d, %d)\n", graphics, brush, x, y, width, height);
2858
2859     return GdipFillEllipse(graphics,brush,(REAL)x,(REAL)y,(REAL)width,(REAL)height);
2860 }
2861
2862 GpStatus WINGDIPAPI GdipFillPath(GpGraphics *graphics, GpBrush *brush, GpPath *path)
2863 {
2864     INT save_state;
2865     GpStatus retval;
2866
2867     TRACE("(%p, %p, %p)\n", graphics, brush, path);
2868
2869     if(!brush || !graphics || !path)
2870         return InvalidParameter;
2871
2872     if(graphics->busy)
2873         return ObjectBusy;
2874
2875     if(!graphics->hdc)
2876     {
2877         FIXME("graphics object has no HDC\n");
2878         return Ok;
2879     }
2880
2881     save_state = SaveDC(graphics->hdc);
2882     EndPath(graphics->hdc);
2883     SetPolyFillMode(graphics->hdc, (path->fill == FillModeAlternate ? ALTERNATE
2884                                                                     : WINDING));
2885
2886     BeginPath(graphics->hdc);
2887     retval = draw_poly(graphics, NULL, path->pathdata.Points,
2888                        path->pathdata.Types, path->pathdata.Count, FALSE);
2889
2890     if(retval != Ok)
2891         goto end;
2892
2893     EndPath(graphics->hdc);
2894     brush_fill_path(graphics, brush);
2895
2896     retval = Ok;
2897
2898 end:
2899     RestoreDC(graphics->hdc, save_state);
2900
2901     return retval;
2902 }
2903
2904 GpStatus WINGDIPAPI GdipFillPie(GpGraphics *graphics, GpBrush *brush, REAL x,
2905     REAL y, REAL width, REAL height, REAL startAngle, REAL sweepAngle)
2906 {
2907     INT save_state;
2908
2909     TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f)\n",
2910             graphics, brush, x, y, width, height, startAngle, sweepAngle);
2911
2912     if(!graphics || !brush)
2913         return InvalidParameter;
2914
2915     if(graphics->busy)
2916         return ObjectBusy;
2917
2918     if(!graphics->hdc)
2919     {
2920         FIXME("graphics object has no HDC\n");
2921         return Ok;
2922     }
2923
2924     save_state = SaveDC(graphics->hdc);
2925     EndPath(graphics->hdc);
2926
2927     BeginPath(graphics->hdc);
2928     draw_pie(graphics, x, y, width, height, startAngle, sweepAngle);
2929     EndPath(graphics->hdc);
2930
2931     brush_fill_path(graphics, brush);
2932
2933     RestoreDC(graphics->hdc, save_state);
2934
2935     return Ok;
2936 }
2937
2938 GpStatus WINGDIPAPI GdipFillPieI(GpGraphics *graphics, GpBrush *brush, INT x,
2939     INT y, INT width, INT height, REAL startAngle, REAL sweepAngle)
2940 {
2941     TRACE("(%p, %p, %d, %d, %d, %d, %.2f, %.2f)\n",
2942             graphics, brush, x, y, width, height, startAngle, sweepAngle);
2943
2944     return GdipFillPie(graphics,brush,(REAL)x,(REAL)y,(REAL)width,(REAL)height,startAngle,sweepAngle);
2945 }
2946
2947 GpStatus WINGDIPAPI GdipFillPolygon(GpGraphics *graphics, GpBrush *brush,
2948     GDIPCONST GpPointF *points, INT count, GpFillMode fillMode)
2949 {
2950     INT save_state;
2951     GpPointF *ptf = NULL;
2952     POINT *pti = NULL;
2953     GpStatus retval = Ok;
2954
2955     TRACE("(%p, %p, %p, %d, %d)\n", graphics, brush, points, count, fillMode);
2956
2957     if(!graphics || !brush || !points || !count)
2958         return InvalidParameter;
2959
2960     if(graphics->busy)
2961         return ObjectBusy;
2962
2963     if(!graphics->hdc)
2964     {
2965         FIXME("graphics object has no HDC\n");
2966         return Ok;
2967     }
2968
2969     ptf = GdipAlloc(count * sizeof(GpPointF));
2970     pti = GdipAlloc(count * sizeof(POINT));
2971     if(!ptf || !pti){
2972         retval = OutOfMemory;
2973         goto end;
2974     }
2975
2976     memcpy(ptf, points, count * sizeof(GpPointF));
2977
2978     save_state = SaveDC(graphics->hdc);
2979     EndPath(graphics->hdc);
2980     SetPolyFillMode(graphics->hdc, (fillMode == FillModeAlternate ? ALTERNATE
2981                                                                   : WINDING));
2982
2983     transform_and_round_points(graphics, pti, ptf, count);
2984
2985     BeginPath(graphics->hdc);
2986     Polygon(graphics->hdc, pti, count);
2987     EndPath(graphics->hdc);
2988
2989     brush_fill_path(graphics, brush);
2990
2991     RestoreDC(graphics->hdc, save_state);
2992
2993 end:
2994     GdipFree(ptf);
2995     GdipFree(pti);
2996
2997     return retval;
2998 }
2999
3000 GpStatus WINGDIPAPI GdipFillPolygonI(GpGraphics *graphics, GpBrush *brush,
3001     GDIPCONST GpPoint *points, INT count, GpFillMode fillMode)
3002 {
3003     INT save_state, i;
3004     GpPointF *ptf = NULL;
3005     POINT *pti = NULL;
3006     GpStatus retval = Ok;
3007
3008     TRACE("(%p, %p, %p, %d, %d)\n", graphics, brush, points, count, fillMode);
3009
3010     if(!graphics || !brush || !points || !count)
3011         return InvalidParameter;
3012
3013     if(graphics->busy)
3014         return ObjectBusy;
3015
3016     if(!graphics->hdc)
3017     {
3018         FIXME("graphics object has no HDC\n");
3019         return Ok;
3020     }
3021
3022     ptf = GdipAlloc(count * sizeof(GpPointF));
3023     pti = GdipAlloc(count * sizeof(POINT));
3024     if(!ptf || !pti){
3025         retval = OutOfMemory;
3026         goto end;
3027     }
3028
3029     for(i = 0; i < count; i ++){
3030         ptf[i].X = (REAL) points[i].X;
3031         ptf[i].Y = (REAL) points[i].Y;
3032     }
3033
3034     save_state = SaveDC(graphics->hdc);
3035     EndPath(graphics->hdc);
3036     SetPolyFillMode(graphics->hdc, (fillMode == FillModeAlternate ? ALTERNATE
3037                                                                   : WINDING));
3038
3039     transform_and_round_points(graphics, pti, ptf, count);
3040
3041     BeginPath(graphics->hdc);
3042     Polygon(graphics->hdc, pti, count);
3043     EndPath(graphics->hdc);
3044
3045     brush_fill_path(graphics, brush);
3046
3047     RestoreDC(graphics->hdc, save_state);
3048
3049 end:
3050     GdipFree(ptf);
3051     GdipFree(pti);
3052
3053     return retval;
3054 }
3055
3056 GpStatus WINGDIPAPI GdipFillPolygon2(GpGraphics *graphics, GpBrush *brush,
3057     GDIPCONST GpPointF *points, INT count)
3058 {
3059     TRACE("(%p, %p, %p, %d)\n", graphics, brush, points, count);
3060
3061     return GdipFillPolygon(graphics, brush, points, count, FillModeAlternate);
3062 }
3063
3064 GpStatus WINGDIPAPI GdipFillPolygon2I(GpGraphics *graphics, GpBrush *brush,
3065     GDIPCONST GpPoint *points, INT count)
3066 {
3067     TRACE("(%p, %p, %p, %d)\n", graphics, brush, points, count);
3068
3069     return GdipFillPolygonI(graphics, brush, points, count, FillModeAlternate);
3070 }
3071
3072 GpStatus WINGDIPAPI GdipFillRectangle(GpGraphics *graphics, GpBrush *brush,
3073     REAL x, REAL y, REAL width, REAL height)
3074 {
3075     INT save_state;
3076     GpPointF ptf[4];
3077     POINT pti[4];
3078
3079     TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f)\n", graphics, brush, x, y, width, height);
3080
3081     if(!graphics || !brush)
3082         return InvalidParameter;
3083
3084     if(graphics->busy)
3085         return ObjectBusy;
3086
3087     if(!graphics->hdc)
3088     {
3089         FIXME("graphics object has no HDC\n");
3090         return Ok;
3091     }
3092
3093     ptf[0].X = x;
3094     ptf[0].Y = y;
3095     ptf[1].X = x + width;
3096     ptf[1].Y = y;
3097     ptf[2].X = x + width;
3098     ptf[2].Y = y + height;
3099     ptf[3].X = x;
3100     ptf[3].Y = y + height;
3101
3102     save_state = SaveDC(graphics->hdc);
3103     EndPath(graphics->hdc);
3104
3105     transform_and_round_points(graphics, pti, ptf, 4);
3106
3107     BeginPath(graphics->hdc);
3108     Polygon(graphics->hdc, pti, 4);
3109     EndPath(graphics->hdc);
3110
3111     brush_fill_path(graphics, brush);
3112
3113     RestoreDC(graphics->hdc, save_state);
3114
3115     return Ok;
3116 }
3117
3118 GpStatus WINGDIPAPI GdipFillRectangleI(GpGraphics *graphics, GpBrush *brush,
3119     INT x, INT y, INT width, INT height)
3120 {
3121     INT save_state;
3122     GpPointF ptf[4];
3123     POINT pti[4];
3124
3125     TRACE("(%p, %p, %d, %d, %d, %d)\n", graphics, brush, x, y, width, height);
3126
3127     if(!graphics || !brush)
3128         return InvalidParameter;
3129
3130     if(graphics->busy)
3131         return ObjectBusy;
3132
3133     if(!graphics->hdc)
3134     {
3135         FIXME("graphics object has no HDC\n");
3136         return Ok;
3137     }
3138
3139     ptf[0].X = x;
3140     ptf[0].Y = y;
3141     ptf[1].X = x + width;
3142     ptf[1].Y = y;
3143     ptf[2].X = x + width;
3144     ptf[2].Y = y + height;
3145     ptf[3].X = x;
3146     ptf[3].Y = y + height;
3147
3148     save_state = SaveDC(graphics->hdc);
3149     EndPath(graphics->hdc);
3150
3151     transform_and_round_points(graphics, pti, ptf, 4);
3152
3153     BeginPath(graphics->hdc);
3154     Polygon(graphics->hdc, pti, 4);
3155     EndPath(graphics->hdc);
3156
3157     brush_fill_path(graphics, brush);
3158
3159     RestoreDC(graphics->hdc, save_state);
3160
3161     return Ok;
3162 }
3163
3164 GpStatus WINGDIPAPI GdipFillRectangles(GpGraphics *graphics, GpBrush *brush, GDIPCONST GpRectF *rects,
3165     INT count)
3166 {
3167     GpStatus ret;
3168     INT i;
3169
3170     TRACE("(%p, %p, %p, %d)\n", graphics, brush, rects, count);
3171
3172     if(!rects)
3173         return InvalidParameter;
3174
3175     for(i = 0; i < count; i++){
3176         ret = GdipFillRectangle(graphics, brush, rects[i].X, rects[i].Y, rects[i].Width, rects[i].Height);
3177         if(ret != Ok)   return ret;
3178     }
3179
3180     return Ok;
3181 }
3182
3183 GpStatus WINGDIPAPI GdipFillRectanglesI(GpGraphics *graphics, GpBrush *brush, GDIPCONST GpRect *rects,
3184     INT count)
3185 {
3186     GpRectF *rectsF;
3187     GpStatus ret;
3188     INT i;
3189
3190     TRACE("(%p, %p, %p, %d)\n", graphics, brush, rects, count);
3191
3192     if(!rects || count <= 0)
3193         return InvalidParameter;
3194
3195     rectsF = GdipAlloc(sizeof(GpRectF)*count);
3196     if(!rectsF)
3197         return OutOfMemory;
3198
3199     for(i = 0; i < count; i++){
3200         rectsF[i].X      = (REAL)rects[i].X;
3201         rectsF[i].Y      = (REAL)rects[i].Y;
3202         rectsF[i].X      = (REAL)rects[i].Width;
3203         rectsF[i].Height = (REAL)rects[i].Height;
3204     }
3205
3206     ret = GdipFillRectangles(graphics,brush,rectsF,count);
3207     GdipFree(rectsF);
3208
3209     return ret;
3210 }
3211
3212 /*****************************************************************************
3213  * GdipFillRegion [GDIPLUS.@]
3214  */
3215 GpStatus WINGDIPAPI GdipFillRegion(GpGraphics* graphics, GpBrush* brush,
3216         GpRegion* region)
3217 {
3218     INT save_state;
3219     GpStatus status;
3220     HRGN hrgn;
3221     RECT rc;
3222
3223     TRACE("(%p, %p, %p)\n", graphics, brush, region);
3224
3225     if (!(graphics && brush && region))
3226         return InvalidParameter;
3227
3228     if(graphics->busy)
3229         return ObjectBusy;
3230
3231     if(!graphics->hdc)
3232     {
3233         FIXME("graphics object has no HDC\n");
3234         return Ok;
3235     }
3236
3237     status = GdipGetRegionHRgn(region, graphics, &hrgn);
3238     if(status != Ok)
3239         return status;
3240
3241     save_state = SaveDC(graphics->hdc);
3242     EndPath(graphics->hdc);
3243
3244     ExtSelectClipRgn(graphics->hdc, hrgn, RGN_AND);
3245
3246     if (GetClipBox(graphics->hdc, &rc) != NULLREGION)
3247     {
3248         BeginPath(graphics->hdc);
3249         Rectangle(graphics->hdc, rc.left, rc.top, rc.right, rc.bottom);
3250         EndPath(graphics->hdc);
3251
3252         brush_fill_path(graphics, brush);
3253     }
3254
3255     RestoreDC(graphics->hdc, save_state);
3256
3257     DeleteObject(hrgn);
3258
3259     return Ok;
3260 }
3261
3262 GpStatus WINGDIPAPI GdipFlush(GpGraphics *graphics, GpFlushIntention intention)
3263 {
3264     TRACE("(%p,%u)\n", graphics, intention);
3265
3266     if(!graphics)
3267         return InvalidParameter;
3268
3269     if(graphics->busy)
3270         return ObjectBusy;
3271
3272     /* We have no internal operation queue, so there's no need to clear it. */
3273
3274     if (graphics->hdc)
3275         GdiFlush();
3276
3277     return Ok;
3278 }
3279
3280 /*****************************************************************************
3281  * GdipGetClipBounds [GDIPLUS.@]
3282  */
3283 GpStatus WINGDIPAPI GdipGetClipBounds(GpGraphics *graphics, GpRectF *rect)
3284 {
3285     TRACE("(%p, %p)\n", graphics, rect);
3286
3287     if(!graphics)
3288         return InvalidParameter;
3289
3290     if(graphics->busy)
3291         return ObjectBusy;
3292
3293     return GdipGetRegionBounds(graphics->clip, graphics, rect);
3294 }
3295
3296 /*****************************************************************************
3297  * GdipGetClipBoundsI [GDIPLUS.@]
3298  */
3299 GpStatus WINGDIPAPI GdipGetClipBoundsI(GpGraphics *graphics, GpRect *rect)
3300 {
3301     TRACE("(%p, %p)\n", graphics, rect);
3302
3303     if(!graphics)
3304         return InvalidParameter;
3305
3306     if(graphics->busy)
3307         return ObjectBusy;
3308
3309     return GdipGetRegionBoundsI(graphics->clip, graphics, rect);
3310 }
3311
3312 /* FIXME: Compositing mode is not used anywhere except the getter/setter. */
3313 GpStatus WINGDIPAPI GdipGetCompositingMode(GpGraphics *graphics,
3314     CompositingMode *mode)
3315 {
3316     TRACE("(%p, %p)\n", graphics, mode);
3317
3318     if(!graphics || !mode)
3319         return InvalidParameter;
3320
3321     if(graphics->busy)
3322         return ObjectBusy;
3323
3324     *mode = graphics->compmode;
3325
3326     return Ok;
3327 }
3328
3329 /* FIXME: Compositing quality is not used anywhere except the getter/setter. */
3330 GpStatus WINGDIPAPI GdipGetCompositingQuality(GpGraphics *graphics,
3331     CompositingQuality *quality)
3332 {
3333     TRACE("(%p, %p)\n", graphics, quality);
3334
3335     if(!graphics || !quality)
3336         return InvalidParameter;
3337
3338     if(graphics->busy)
3339         return ObjectBusy;
3340
3341     *quality = graphics->compqual;
3342
3343     return Ok;
3344 }
3345
3346 /* FIXME: Interpolation mode is not used anywhere except the getter/setter. */
3347 GpStatus WINGDIPAPI GdipGetInterpolationMode(GpGraphics *graphics,
3348     InterpolationMode *mode)
3349 {
3350     TRACE("(%p, %p)\n", graphics, mode);
3351
3352     if(!graphics || !mode)
3353         return InvalidParameter;
3354
3355     if(graphics->busy)
3356         return ObjectBusy;
3357
3358     *mode = graphics->interpolation;
3359
3360     return Ok;
3361 }
3362
3363 /* FIXME: Need to handle color depths less than 24bpp */
3364 GpStatus WINGDIPAPI GdipGetNearestColor(GpGraphics *graphics, ARGB* argb)
3365 {
3366     FIXME("(%p, %p): Passing color unmodified\n", graphics, argb);
3367
3368     if(!graphics || !argb)
3369         return InvalidParameter;
3370
3371     if(graphics->busy)
3372         return ObjectBusy;
3373
3374     return Ok;
3375 }
3376
3377 GpStatus WINGDIPAPI GdipGetPageScale(GpGraphics *graphics, REAL *scale)
3378 {
3379     TRACE("(%p, %p)\n", graphics, scale);
3380
3381     if(!graphics || !scale)
3382         return InvalidParameter;
3383
3384     if(graphics->busy)
3385         return ObjectBusy;
3386
3387     *scale = graphics->scale;
3388
3389     return Ok;
3390 }
3391
3392 GpStatus WINGDIPAPI GdipGetPageUnit(GpGraphics *graphics, GpUnit *unit)
3393 {
3394     TRACE("(%p, %p)\n", graphics, unit);
3395
3396     if(!graphics || !unit)
3397         return InvalidParameter;
3398
3399     if(graphics->busy)
3400         return ObjectBusy;
3401
3402     *unit = graphics->unit;
3403
3404     return Ok;
3405 }
3406
3407 /* FIXME: Pixel offset mode is not used anywhere except the getter/setter. */
3408 GpStatus WINGDIPAPI GdipGetPixelOffsetMode(GpGraphics *graphics, PixelOffsetMode
3409     *mode)
3410 {
3411     TRACE("(%p, %p)\n", graphics, mode);
3412
3413     if(!graphics || !mode)
3414         return InvalidParameter;
3415
3416     if(graphics->busy)
3417         return ObjectBusy;
3418
3419     *mode = graphics->pixeloffset;
3420
3421     return Ok;
3422 }
3423
3424 /* FIXME: Smoothing mode is not used anywhere except the getter/setter. */
3425 GpStatus WINGDIPAPI GdipGetSmoothingMode(GpGraphics *graphics, SmoothingMode *mode)
3426 {
3427     TRACE("(%p, %p)\n", graphics, mode);
3428
3429     if(!graphics || !mode)
3430         return InvalidParameter;
3431
3432     if(graphics->busy)
3433         return ObjectBusy;
3434
3435     *mode = graphics->smoothing;
3436
3437     return Ok;
3438 }
3439
3440 GpStatus WINGDIPAPI GdipGetTextContrast(GpGraphics *graphics, UINT *contrast)
3441 {
3442     TRACE("(%p, %p)\n", graphics, contrast);
3443
3444     if(!graphics || !contrast)
3445         return InvalidParameter;
3446
3447     *contrast = graphics->textcontrast;
3448
3449     return Ok;
3450 }
3451
3452 /* FIXME: Text rendering hint is not used anywhere except the getter/setter. */
3453 GpStatus WINGDIPAPI GdipGetTextRenderingHint(GpGraphics *graphics,
3454     TextRenderingHint *hint)
3455 {
3456     TRACE("(%p, %p)\n", graphics, hint);
3457
3458     if(!graphics || !hint)
3459         return InvalidParameter;
3460
3461     if(graphics->busy)
3462         return ObjectBusy;
3463
3464     *hint = graphics->texthint;
3465
3466     return Ok;
3467 }
3468
3469 GpStatus WINGDIPAPI GdipGetVisibleClipBounds(GpGraphics *graphics, GpRectF *rect)
3470 {
3471     GpRegion *clip_rgn;
3472     GpStatus stat;
3473
3474     TRACE("(%p, %p)\n", graphics, rect);
3475
3476     if(!graphics || !rect)
3477         return InvalidParameter;
3478
3479     if(graphics->busy)
3480         return ObjectBusy;
3481
3482     /* intersect window and graphics clipping regions */
3483     if((stat = GdipCreateRegion(&clip_rgn)) != Ok)
3484         return stat;
3485
3486     if((stat = get_visible_clip_region(graphics, clip_rgn)) != Ok)
3487         goto cleanup;
3488
3489     /* get bounds of the region */
3490     stat = GdipGetRegionBounds(clip_rgn, graphics, rect);
3491
3492 cleanup:
3493     GdipDeleteRegion(clip_rgn);
3494
3495     return stat;
3496 }
3497
3498 GpStatus WINGDIPAPI GdipGetVisibleClipBoundsI(GpGraphics *graphics, GpRect *rect)
3499 {
3500     GpRectF rectf;
3501     GpStatus stat;
3502
3503     TRACE("(%p, %p)\n", graphics, rect);
3504
3505     if(!graphics || !rect)
3506         return InvalidParameter;
3507
3508     if((stat = GdipGetVisibleClipBounds(graphics, &rectf)) == Ok)
3509     {
3510         rect->X = roundr(rectf.X);
3511         rect->Y = roundr(rectf.Y);
3512         rect->Width  = roundr(rectf.Width);
3513         rect->Height = roundr(rectf.Height);
3514     }
3515
3516     return stat;
3517 }
3518
3519 GpStatus WINGDIPAPI GdipGetWorldTransform(GpGraphics *graphics, GpMatrix *matrix)
3520 {
3521     TRACE("(%p, %p)\n", graphics, matrix);
3522
3523     if(!graphics || !matrix)
3524         return InvalidParameter;
3525
3526     if(graphics->busy)
3527         return ObjectBusy;
3528
3529     *matrix = *graphics->worldtrans;
3530     return Ok;
3531 }
3532
3533 GpStatus WINGDIPAPI GdipGraphicsClear(GpGraphics *graphics, ARGB color)
3534 {
3535     GpSolidFill *brush;
3536     GpStatus stat;
3537     GpRectF wnd_rect;
3538
3539     TRACE("(%p, %x)\n", graphics, color);
3540
3541     if(!graphics)
3542         return InvalidParameter;
3543
3544     if(graphics->busy)
3545         return ObjectBusy;
3546
3547     if((stat = GdipCreateSolidFill(color, &brush)) != Ok)
3548         return stat;
3549
3550     if((stat = get_graphics_bounds(graphics, &wnd_rect)) != Ok){
3551         GdipDeleteBrush((GpBrush*)brush);
3552         return stat;
3553     }
3554
3555     GdipFillRectangle(graphics, (GpBrush*)brush, wnd_rect.X, wnd_rect.Y,
3556                                                  wnd_rect.Width, wnd_rect.Height);
3557
3558     GdipDeleteBrush((GpBrush*)brush);
3559
3560     return Ok;
3561 }
3562
3563 GpStatus WINGDIPAPI GdipIsClipEmpty(GpGraphics *graphics, BOOL *res)
3564 {
3565     TRACE("(%p, %p)\n", graphics, res);
3566
3567     if(!graphics || !res)
3568         return InvalidParameter;
3569
3570     return GdipIsEmptyRegion(graphics->clip, graphics, res);
3571 }
3572
3573 GpStatus WINGDIPAPI GdipIsVisiblePoint(GpGraphics *graphics, REAL x, REAL y, BOOL *result)
3574 {
3575     GpStatus stat;
3576     GpRegion* rgn;
3577     GpPointF pt;
3578
3579     TRACE("(%p, %.2f, %.2f, %p)\n", graphics, x, y, result);
3580
3581     if(!graphics || !result)
3582         return InvalidParameter;
3583
3584     if(graphics->busy)
3585         return ObjectBusy;
3586
3587     pt.X = x;
3588     pt.Y = y;
3589     if((stat = GdipTransformPoints(graphics, CoordinateSpaceDevice,
3590                    CoordinateSpaceWorld, &pt, 1)) != Ok)
3591         return stat;
3592
3593     if((stat = GdipCreateRegion(&rgn)) != Ok)
3594         return stat;
3595
3596     if((stat = get_visible_clip_region(graphics, rgn)) != Ok)
3597         goto cleanup;
3598
3599     stat = GdipIsVisibleRegionPoint(rgn, pt.X, pt.Y, graphics, result);
3600
3601 cleanup:
3602     GdipDeleteRegion(rgn);
3603     return stat;
3604 }
3605
3606 GpStatus WINGDIPAPI GdipIsVisiblePointI(GpGraphics *graphics, INT x, INT y, BOOL *result)
3607 {
3608     return GdipIsVisiblePoint(graphics, (REAL)x, (REAL)y, result);
3609 }
3610
3611 GpStatus WINGDIPAPI GdipIsVisibleRect(GpGraphics *graphics, REAL x, REAL y, REAL width, REAL height, BOOL *result)
3612 {
3613     GpStatus stat;
3614     GpRegion* rgn;
3615     GpPointF pts[2];
3616
3617     TRACE("(%p %.2f %.2f %.2f %.2f %p)\n", graphics, x, y, width, height, result);
3618
3619     if(!graphics || !result)
3620         return InvalidParameter;
3621
3622     if(graphics->busy)
3623         return ObjectBusy;
3624
3625     pts[0].X = x;
3626     pts[0].Y = y;
3627     pts[1].X = x + width;
3628     pts[1].Y = y + height;
3629
3630     if((stat = GdipTransformPoints(graphics, CoordinateSpaceDevice,
3631                     CoordinateSpaceWorld, pts, 2)) != Ok)
3632         return stat;
3633
3634     pts[1].X -= pts[0].X;
3635     pts[1].Y -= pts[0].Y;
3636
3637     if((stat = GdipCreateRegion(&rgn)) != Ok)
3638         return stat;
3639
3640     if((stat = get_visible_clip_region(graphics, rgn)) != Ok)
3641         goto cleanup;
3642
3643     stat = GdipIsVisibleRegionRect(rgn, pts[0].X, pts[0].Y, pts[1].X, pts[1].Y, graphics, result);
3644
3645 cleanup:
3646     GdipDeleteRegion(rgn);
3647     return stat;
3648 }
3649
3650 GpStatus WINGDIPAPI GdipIsVisibleRectI(GpGraphics *graphics, INT x, INT y, INT width, INT height, BOOL *result)
3651 {
3652     return GdipIsVisibleRect(graphics, (REAL)x, (REAL)y, (REAL)width, (REAL)height, result);
3653 }
3654
3655 typedef GpStatus (*gdip_format_string_callback)(GpGraphics *graphics,
3656     GDIPCONST WCHAR *string, INT index, INT length, GDIPCONST GpFont *font,
3657     GDIPCONST RectF *rect, GDIPCONST GpStringFormat *format,
3658     INT lineno, const RectF *bounds, void *user_data);
3659
3660 static GpStatus gdip_format_string(GpGraphics *graphics,
3661     GDIPCONST WCHAR *string, INT length, GDIPCONST GpFont *font,
3662     GDIPCONST RectF *rect, GDIPCONST GpStringFormat *format,
3663     gdip_format_string_callback callback, void *user_data)
3664 {
3665     WCHAR* stringdup;
3666     int sum = 0, height = 0, fit, fitcpy, i, j, lret, nwidth,
3667         nheight, lineend, lineno = 0;
3668     RectF bounds;
3669     StringAlignment halign;
3670     GpStatus stat = Ok;
3671     SIZE size;
3672
3673     if(length == -1) length = lstrlenW(string);
3674
3675     stringdup = GdipAlloc((length + 1) * sizeof(WCHAR));
3676     if(!stringdup) return OutOfMemory;
3677
3678     nwidth = roundr(rect->Width);
3679     nheight = roundr(rect->Height);
3680
3681     if (rect->Width >= INT_MAX || rect->Width < 0.5) nwidth = INT_MAX;
3682     if (rect->Height >= INT_MAX || rect->Width < 0.5) nheight = INT_MAX;
3683
3684     for(i = 0, j = 0; i < length; i++){
3685         /* FIXME: This makes the indexes passed to callback inaccurate. */
3686         if(!isprintW(string[i]) && (string[i] != '\n'))
3687             continue;
3688
3689         stringdup[j] = string[i];
3690         j++;
3691     }
3692
3693     length = j;
3694
3695     if (format) halign = format->align;
3696     else halign = StringAlignmentNear;
3697
3698     while(sum < length){
3699         GetTextExtentExPointW(graphics->hdc, stringdup + sum, length - sum,
3700                               nwidth, &fit, NULL, &size);
3701         fitcpy = fit;
3702
3703         if(fit == 0)
3704             break;
3705
3706         for(lret = 0; lret < fit; lret++)
3707             if(*(stringdup + sum + lret) == '\n')
3708                 break;
3709
3710         /* Line break code (may look strange, but it imitates windows). */
3711         if(lret < fit)
3712             lineend = fit = lret;    /* this is not an off-by-one error */
3713         else if(fit < (length - sum)){
3714             if(*(stringdup + sum + fit) == ' ')
3715                 while(*(stringdup + sum + fit) == ' ')
3716                     fit++;
3717             else
3718                 while(*(stringdup + sum + fit - 1) != ' '){
3719                     fit--;
3720
3721                     if(*(stringdup + sum + fit) == '\t')
3722                         break;
3723
3724                     if(fit == 0){
3725                         fit = fitcpy;
3726                         break;
3727                     }
3728                 }
3729             lineend = fit;
3730             while(*(stringdup + sum + lineend - 1) == ' ' ||
3731                   *(stringdup + sum + lineend - 1) == '\t')
3732                 lineend--;
3733         }
3734         else
3735             lineend = fit;
3736
3737         GetTextExtentExPointW(graphics->hdc, stringdup + sum, lineend,
3738                               nwidth, &j, NULL, &size);
3739
3740         bounds.Width = size.cx;
3741
3742         if(height + size.cy > nheight)
3743             bounds.Height = nheight - (height + size.cy);
3744         else
3745             bounds.Height = size.cy;
3746
3747         bounds.Y = rect->Y + height;
3748
3749         switch (halign)
3750         {
3751         case StringAlignmentNear:
3752         default:
3753             bounds.X = rect->X;
3754             break;
3755         case StringAlignmentCenter:
3756             bounds.X = rect->X + (rect->Width/2) - (bounds.Width/2);
3757             break;
3758         case StringAlignmentFar:
3759             bounds.X = rect->X + rect->Width - bounds.Width;
3760             break;
3761         }
3762
3763         stat = callback(graphics, stringdup, sum, lineend,
3764             font, rect, format, lineno, &bounds, user_data);
3765
3766         if (stat != Ok)
3767             break;
3768
3769         sum += fit + (lret < fitcpy ? 1 : 0);
3770         height += size.cy;
3771         lineno++;
3772
3773         if(height > nheight)
3774             break;
3775
3776         /* Stop if this was a linewrap (but not if it was a linebreak). */
3777         if((lret == fitcpy) && format && (format->attr & StringFormatFlagsNoWrap))
3778             break;
3779     }
3780
3781     GdipFree(stringdup);
3782
3783     return stat;
3784 }
3785
3786 struct measure_ranges_args {
3787     GpRegion **regions;
3788 };
3789
3790 static GpStatus measure_ranges_callback(GpGraphics *graphics,
3791     GDIPCONST WCHAR *string, INT index, INT length, GDIPCONST GpFont *font,
3792     GDIPCONST RectF *rect, GDIPCONST GpStringFormat *format,
3793     INT lineno, const RectF *bounds, void *user_data)
3794 {
3795     int i;
3796     GpStatus stat = Ok;
3797     struct measure_ranges_args *args = user_data;
3798
3799     for (i=0; i<format->range_count; i++)
3800     {
3801         INT range_start = max(index, format->character_ranges[i].First);
3802         INT range_end = min(index+length, format->character_ranges[i].First+format->character_ranges[i].Length);
3803         if (range_start < range_end)
3804         {
3805             GpRectF range_rect;
3806             SIZE range_size;
3807
3808             range_rect.Y = bounds->Y;
3809             range_rect.Height = bounds->Height;
3810
3811             GetTextExtentExPointW(graphics->hdc, string + index, range_start - index,
3812                                   INT_MAX, NULL, NULL, &range_size);
3813             range_rect.X = bounds->X + range_size.cx;
3814
3815             GetTextExtentExPointW(graphics->hdc, string + index, range_end - index,
3816                                   INT_MAX, NULL, NULL, &range_size);
3817             range_rect.Width = (bounds->X + range_size.cx) - range_rect.X;
3818
3819             stat = GdipCombineRegionRect(args->regions[i], &range_rect, CombineModeUnion);
3820             if (stat != Ok)
3821                 break;
3822         }
3823     }
3824
3825     return stat;
3826 }
3827
3828 GpStatus WINGDIPAPI GdipMeasureCharacterRanges(GpGraphics* graphics,
3829         GDIPCONST WCHAR* string, INT length, GDIPCONST GpFont* font,
3830         GDIPCONST RectF* layoutRect, GDIPCONST GpStringFormat *stringFormat,
3831         INT regionCount, GpRegion** regions)
3832 {
3833     GpStatus stat;
3834     int i;
3835     HFONT oldfont;
3836     struct measure_ranges_args args;
3837
3838     TRACE("(%p %s %d %p %s %p %d %p)\n", graphics, debugstr_w(string),
3839             length, font, debugstr_rectf(layoutRect), stringFormat, regionCount, regions);
3840
3841     if (!(graphics && string && font && layoutRect && stringFormat && regions))
3842         return InvalidParameter;
3843
3844     if (regionCount < stringFormat->range_count)
3845         return InvalidParameter;
3846
3847     if(!graphics->hdc)
3848     {
3849         FIXME("graphics object has no HDC\n");
3850         return NotImplemented;
3851     }
3852
3853     if (stringFormat->attr)
3854         TRACE("may be ignoring some format flags: attr %x\n", stringFormat->attr);
3855
3856     oldfont = SelectObject(graphics->hdc, CreateFontIndirectW(&font->lfw));
3857
3858     for (i=0; i<stringFormat->range_count; i++)
3859     {
3860         stat = GdipSetEmpty(regions[i]);
3861         if (stat != Ok)
3862             return stat;
3863     }
3864
3865     args.regions = regions;
3866
3867     stat = gdip_format_string(graphics, string, length, font, layoutRect, stringFormat,
3868         measure_ranges_callback, &args);
3869
3870     DeleteObject(SelectObject(graphics->hdc, oldfont));
3871
3872     return stat;
3873 }
3874
3875 struct measure_string_args {
3876     RectF *bounds;
3877     INT *codepointsfitted;
3878     INT *linesfilled;
3879 };
3880
3881 static GpStatus measure_string_callback(GpGraphics *graphics,
3882     GDIPCONST WCHAR *string, INT index, INT length, GDIPCONST GpFont *font,
3883     GDIPCONST RectF *rect, GDIPCONST GpStringFormat *format,
3884     INT lineno, const RectF *bounds, void *user_data)
3885 {
3886     struct measure_string_args *args = user_data;
3887
3888     if (bounds->Width > args->bounds->Width)
3889         args->bounds->Width = bounds->Width;
3890
3891     if (bounds->Height + bounds->Y > args->bounds->Height + args->bounds->Y)
3892         args->bounds->Height = bounds->Height + bounds->Y - args->bounds->Y;
3893
3894     if (args->codepointsfitted)
3895         *args->codepointsfitted = index + length;
3896
3897     if (args->linesfilled)
3898         (*args->linesfilled)++;
3899
3900     return Ok;
3901 }
3902
3903 /* Find the smallest rectangle that bounds the text when it is printed in rect
3904  * according to the format options listed in format. If rect has 0 width and
3905  * height, then just find the smallest rectangle that bounds the text when it's
3906  * printed at location (rect->X, rect-Y). */
3907 GpStatus WINGDIPAPI GdipMeasureString(GpGraphics *graphics,
3908     GDIPCONST WCHAR *string, INT length, GDIPCONST GpFont *font,
3909     GDIPCONST RectF *rect, GDIPCONST GpStringFormat *format, RectF *bounds,
3910     INT *codepointsfitted, INT *linesfilled)
3911 {
3912     HFONT oldfont;
3913     struct measure_string_args args;
3914
3915     TRACE("(%p, %s, %i, %p, %s, %p, %p, %p, %p)\n", graphics,
3916         debugstr_wn(string, length), length, font, debugstr_rectf(rect), format,
3917         bounds, codepointsfitted, linesfilled);
3918
3919     if(!graphics || !string || !font || !rect || !bounds)
3920         return InvalidParameter;
3921
3922     if(!graphics->hdc)
3923     {
3924         FIXME("graphics object has no HDC\n");
3925         return NotImplemented;
3926     }
3927
3928     if(linesfilled) *linesfilled = 0;
3929     if(codepointsfitted) *codepointsfitted = 0;
3930
3931     if(format)
3932         TRACE("may be ignoring some format flags: attr %x\n", format->attr);
3933
3934     oldfont = SelectObject(graphics->hdc, CreateFontIndirectW(&font->lfw));
3935
3936     bounds->X = rect->X;
3937     bounds->Y = rect->Y;
3938     bounds->Width = 0.0;
3939     bounds->Height = 0.0;
3940
3941     args.bounds = bounds;
3942     args.codepointsfitted = codepointsfitted;
3943     args.linesfilled = linesfilled;
3944
3945     gdip_format_string(graphics, string, length, font, rect, format,
3946         measure_string_callback, &args);
3947
3948     DeleteObject(SelectObject(graphics->hdc, oldfont));
3949
3950     return Ok;
3951 }
3952
3953 struct draw_string_args {
3954     POINT drawbase;
3955     UINT drawflags;
3956     REAL ang_cos, ang_sin;
3957 };
3958
3959 static GpStatus draw_string_callback(GpGraphics *graphics,
3960     GDIPCONST WCHAR *string, INT index, INT length, GDIPCONST GpFont *font,
3961     GDIPCONST RectF *rect, GDIPCONST GpStringFormat *format,
3962     INT lineno, const RectF *bounds, void *user_data)
3963 {
3964     struct draw_string_args *args = user_data;
3965     RECT drawcoord;
3966
3967     drawcoord.left = drawcoord.right = args->drawbase.x + roundr(args->ang_sin * bounds->Y);
3968     drawcoord.top = drawcoord.bottom = args->drawbase.y + roundr(args->ang_cos * bounds->Y);
3969
3970     DrawTextW(graphics->hdc, string + index, length, &drawcoord, args->drawflags);
3971
3972     return Ok;
3973 }
3974
3975 GpStatus WINGDIPAPI GdipDrawString(GpGraphics *graphics, GDIPCONST WCHAR *string,
3976     INT length, GDIPCONST GpFont *font, GDIPCONST RectF *rect,
3977     GDIPCONST GpStringFormat *format, GDIPCONST GpBrush *brush)
3978 {
3979     HRGN rgn = NULL;
3980     HFONT gdifont;
3981     LOGFONTW lfw;
3982     TEXTMETRICW textmet;
3983     GpPointF pt[3], rectcpy[4];
3984     POINT corners[4];
3985     REAL angle, rel_width, rel_height;
3986     INT offsety = 0, save_state;
3987     struct draw_string_args args;
3988     RectF scaled_rect;
3989
3990     TRACE("(%p, %s, %i, %p, %s, %p, %p)\n", graphics, debugstr_wn(string, length),
3991         length, font, debugstr_rectf(rect), format, brush);
3992
3993     if(!graphics || !string || !font || !brush || !rect)
3994         return InvalidParameter;
3995
3996     if((brush->bt != BrushTypeSolidColor)){
3997         FIXME("not implemented for given parameters\n");
3998         return NotImplemented;
3999     }
4000
4001     if(!graphics->hdc)
4002     {
4003         FIXME("graphics object has no HDC\n");
4004         return NotImplemented;
4005     }
4006
4007     if(format){
4008         TRACE("may be ignoring some format flags: attr %x\n", format->attr);
4009
4010         /* Should be no need to explicitly test for StringAlignmentNear as
4011          * that is default behavior if no alignment is passed. */
4012         if(format->vertalign != StringAlignmentNear){
4013             RectF bounds;
4014             GdipMeasureString(graphics, string, length, font, rect, format, &bounds, 0, 0);
4015
4016             if(format->vertalign == StringAlignmentCenter)
4017                 offsety = (rect->Height - bounds.Height) / 2;
4018             else if(format->vertalign == StringAlignmentFar)
4019                 offsety = (rect->Height - bounds.Height);
4020         }
4021     }
4022
4023     save_state = SaveDC(graphics->hdc);
4024     SetBkMode(graphics->hdc, TRANSPARENT);
4025     SetTextColor(graphics->hdc, brush->lb.lbColor);
4026
4027     pt[0].X = 0.0;
4028     pt[0].Y = 0.0;
4029     pt[1].X = 1.0;
4030     pt[1].Y = 0.0;
4031     pt[2].X = 0.0;
4032     pt[2].Y = 1.0;
4033     GdipTransformPoints(graphics, CoordinateSpaceDevice, CoordinateSpaceWorld, pt, 3);
4034     angle = -gdiplus_atan2((pt[1].Y - pt[0].Y), (pt[1].X - pt[0].X));
4035     args.ang_cos = cos(angle);
4036     args.ang_sin = sin(angle);
4037     rel_width = sqrt((pt[1].Y-pt[0].Y)*(pt[1].Y-pt[0].Y)+
4038                      (pt[1].X-pt[0].X)*(pt[1].X-pt[0].X));
4039     rel_height = sqrt((pt[2].Y-pt[0].Y)*(pt[2].Y-pt[0].Y)+
4040                       (pt[2].X-pt[0].X)*(pt[2].X-pt[0].X));
4041
4042     rectcpy[3].X = rectcpy[0].X = rect->X;
4043     rectcpy[1].Y = rectcpy[0].Y = rect->Y + offsety;
4044     rectcpy[2].X = rectcpy[1].X = rect->X + rect->Width;
4045     rectcpy[3].Y = rectcpy[2].Y = rect->Y + offsety + rect->Height;
4046     transform_and_round_points(graphics, corners, rectcpy, 4);
4047
4048     scaled_rect.X = 0.0;
4049     scaled_rect.Y = 0.0;
4050     scaled_rect.Width = rel_width * rect->Width;
4051     scaled_rect.Height = rel_height * rect->Height;
4052
4053     if (roundr(scaled_rect.Width) != 0 && roundr(scaled_rect.Height) != 0)
4054     {
4055         /* FIXME: If only the width or only the height is 0, we should probably still clip */
4056         rgn = CreatePolygonRgn(corners, 4, ALTERNATE);
4057         SelectClipRgn(graphics->hdc, rgn);
4058     }
4059
4060     /* Use gdi to find the font, then perform transformations on it (height,
4061      * width, angle). */
4062     SelectObject(graphics->hdc, CreateFontIndirectW(&font->lfw));
4063     GetTextMetricsW(graphics->hdc, &textmet);
4064     lfw = font->lfw;
4065
4066     lfw.lfHeight = roundr(((REAL)lfw.lfHeight) * rel_height);
4067     lfw.lfWidth = roundr(textmet.tmAveCharWidth * rel_width);
4068
4069     lfw.lfEscapement = lfw.lfOrientation = roundr((angle / M_PI) * 1800.0);
4070
4071     gdifont = CreateFontIndirectW(&lfw);
4072     DeleteObject(SelectObject(graphics->hdc, CreateFontIndirectW(&lfw)));
4073
4074     if (!format || format->align == StringAlignmentNear)
4075     {
4076         args.drawbase.x = corners[0].x;
4077         args.drawbase.y = corners[0].y;
4078         args.drawflags = DT_NOCLIP | DT_EXPANDTABS;
4079     }
4080     else if (format->align == StringAlignmentCenter)
4081     {
4082         args.drawbase.x = (corners[0].x + corners[1].x)/2;
4083         args.drawbase.y = (corners[0].y + corners[1].y)/2;
4084         args.drawflags = DT_NOCLIP | DT_EXPANDTABS | DT_CENTER;
4085     }
4086     else /* (format->align == StringAlignmentFar) */
4087     {
4088         args.drawbase.x = corners[1].x;
4089         args.drawbase.y = corners[1].y;
4090         args.drawflags = DT_NOCLIP | DT_EXPANDTABS | DT_RIGHT;
4091     }
4092
4093     gdip_format_string(graphics, string, length, font, &scaled_rect, format,
4094         draw_string_callback, &args);
4095
4096     DeleteObject(rgn);
4097     DeleteObject(gdifont);
4098
4099     RestoreDC(graphics->hdc, save_state);
4100
4101     return Ok;
4102 }
4103
4104 GpStatus WINGDIPAPI GdipResetClip(GpGraphics *graphics)
4105 {
4106     TRACE("(%p)\n", graphics);
4107
4108     if(!graphics)
4109         return InvalidParameter;
4110
4111     if(graphics->busy)
4112         return ObjectBusy;
4113
4114     return GdipSetInfinite(graphics->clip);
4115 }
4116
4117 GpStatus WINGDIPAPI GdipResetWorldTransform(GpGraphics *graphics)
4118 {
4119     TRACE("(%p)\n", graphics);
4120
4121     if(!graphics)
4122         return InvalidParameter;
4123
4124     if(graphics->busy)
4125         return ObjectBusy;
4126
4127     graphics->worldtrans->matrix[0] = 1.0;
4128     graphics->worldtrans->matrix[1] = 0.0;
4129     graphics->worldtrans->matrix[2] = 0.0;
4130     graphics->worldtrans->matrix[3] = 1.0;
4131     graphics->worldtrans->matrix[4] = 0.0;
4132     graphics->worldtrans->matrix[5] = 0.0;
4133
4134     return Ok;
4135 }
4136
4137 GpStatus WINGDIPAPI GdipRestoreGraphics(GpGraphics *graphics, GraphicsState state)
4138 {
4139     return GdipEndContainer(graphics, state);
4140 }
4141
4142 GpStatus WINGDIPAPI GdipRotateWorldTransform(GpGraphics *graphics, REAL angle,
4143     GpMatrixOrder order)
4144 {
4145     TRACE("(%p, %.2f, %d)\n", graphics, angle, order);
4146
4147     if(!graphics)
4148         return InvalidParameter;
4149
4150     if(graphics->busy)
4151         return ObjectBusy;
4152
4153     return GdipRotateMatrix(graphics->worldtrans, angle, order);
4154 }
4155
4156 GpStatus WINGDIPAPI GdipSaveGraphics(GpGraphics *graphics, GraphicsState *state)
4157 {
4158     return GdipBeginContainer2(graphics, state);
4159 }
4160
4161 GpStatus WINGDIPAPI GdipBeginContainer2(GpGraphics *graphics,
4162         GraphicsContainer *state)
4163 {
4164     GraphicsContainerItem *container;
4165     GpStatus sts;
4166
4167     TRACE("(%p, %p)\n", graphics, state);
4168
4169     if(!graphics || !state)
4170         return InvalidParameter;
4171
4172     sts = init_container(&container, graphics);
4173     if(sts != Ok)
4174         return sts;
4175
4176     list_add_head(&graphics->containers, &container->entry);
4177     *state = graphics->contid = container->contid;
4178
4179     return Ok;
4180 }
4181
4182 GpStatus WINGDIPAPI GdipBeginContainer(GpGraphics *graphics, GDIPCONST GpRectF *dstrect, GDIPCONST GpRectF *srcrect, GpUnit unit, GraphicsContainer *state)
4183 {
4184     FIXME("(%p, %p, %p, %d, %p): stub\n", graphics, dstrect, srcrect, unit, state);
4185     return NotImplemented;
4186 }
4187
4188 GpStatus WINGDIPAPI GdipBeginContainerI(GpGraphics *graphics, GDIPCONST GpRect *dstrect, GDIPCONST GpRect *srcrect, GpUnit unit, GraphicsContainer *state)
4189 {
4190     FIXME("(%p, %p, %p, %d, %p): stub\n", graphics, dstrect, srcrect, unit, state);
4191     return NotImplemented;
4192 }
4193
4194 GpStatus WINGDIPAPI GdipComment(GpGraphics *graphics, UINT sizeData, GDIPCONST BYTE *data)
4195 {
4196     FIXME("(%p, %d, %p): stub\n", graphics, sizeData, data);
4197     return NotImplemented;
4198 }
4199
4200 GpStatus WINGDIPAPI GdipEndContainer(GpGraphics *graphics, GraphicsContainer state)
4201 {
4202     GpStatus sts;
4203     GraphicsContainerItem *container, *container2;
4204
4205     TRACE("(%p, %x)\n", graphics, state);
4206
4207     if(!graphics)
4208         return InvalidParameter;
4209
4210     LIST_FOR_EACH_ENTRY(container, &graphics->containers, GraphicsContainerItem, entry){
4211         if(container->contid == state)
4212             break;
4213     }
4214
4215     /* did not find a matching container */
4216     if(&container->entry == &graphics->containers)
4217         return Ok;
4218
4219     sts = restore_container(graphics, container);
4220     if(sts != Ok)
4221         return sts;
4222
4223     /* remove all of the containers on top of the found container */
4224     LIST_FOR_EACH_ENTRY_SAFE(container, container2, &graphics->containers, GraphicsContainerItem, entry){
4225         if(container->contid == state)
4226             break;
4227         list_remove(&container->entry);
4228         delete_container(container);
4229     }
4230
4231     list_remove(&container->entry);
4232     delete_container(container);
4233
4234     return Ok;
4235 }
4236
4237 GpStatus WINGDIPAPI GdipScaleWorldTransform(GpGraphics *graphics, REAL sx,
4238     REAL sy, GpMatrixOrder order)
4239 {
4240     TRACE("(%p, %.2f, %.2f, %d)\n", graphics, sx, sy, order);
4241
4242     if(!graphics)
4243         return InvalidParameter;
4244
4245     if(graphics->busy)
4246         return ObjectBusy;
4247
4248     return GdipScaleMatrix(graphics->worldtrans, sx, sy, order);
4249 }
4250
4251 GpStatus WINGDIPAPI GdipSetClipGraphics(GpGraphics *graphics, GpGraphics *srcgraphics,
4252     CombineMode mode)
4253 {
4254     TRACE("(%p, %p, %d)\n", graphics, srcgraphics, mode);
4255
4256     if(!graphics || !srcgraphics)
4257         return InvalidParameter;
4258
4259     return GdipCombineRegionRegion(graphics->clip, srcgraphics->clip, mode);
4260 }
4261
4262 GpStatus WINGDIPAPI GdipSetCompositingMode(GpGraphics *graphics,
4263     CompositingMode mode)
4264 {
4265     TRACE("(%p, %d)\n", graphics, mode);
4266
4267     if(!graphics)
4268         return InvalidParameter;
4269
4270     if(graphics->busy)
4271         return ObjectBusy;
4272
4273     graphics->compmode = mode;
4274
4275     return Ok;
4276 }
4277
4278 GpStatus WINGDIPAPI GdipSetCompositingQuality(GpGraphics *graphics,
4279     CompositingQuality quality)
4280 {
4281     TRACE("(%p, %d)\n", graphics, quality);
4282
4283     if(!graphics)
4284         return InvalidParameter;
4285
4286     if(graphics->busy)
4287         return ObjectBusy;
4288
4289     graphics->compqual = quality;
4290
4291     return Ok;
4292 }
4293
4294 GpStatus WINGDIPAPI GdipSetInterpolationMode(GpGraphics *graphics,
4295     InterpolationMode mode)
4296 {
4297     TRACE("(%p, %d)\n", graphics, mode);
4298
4299     if(!graphics)
4300         return InvalidParameter;
4301
4302     if(graphics->busy)
4303         return ObjectBusy;
4304
4305     graphics->interpolation = mode;
4306
4307     return Ok;
4308 }
4309
4310 GpStatus WINGDIPAPI GdipSetPageScale(GpGraphics *graphics, REAL scale)
4311 {
4312     TRACE("(%p, %.2f)\n", graphics, scale);
4313
4314     if(!graphics || (scale <= 0.0))
4315         return InvalidParameter;
4316
4317     if(graphics->busy)
4318         return ObjectBusy;
4319
4320     graphics->scale = scale;
4321
4322     return Ok;
4323 }
4324
4325 GpStatus WINGDIPAPI GdipSetPageUnit(GpGraphics *graphics, GpUnit unit)
4326 {
4327     TRACE("(%p, %d)\n", graphics, unit);
4328
4329     if(!graphics)
4330         return InvalidParameter;
4331
4332     if(graphics->busy)
4333         return ObjectBusy;
4334
4335     if(unit == UnitWorld)
4336         return InvalidParameter;
4337
4338     graphics->unit = unit;
4339
4340     return Ok;
4341 }
4342
4343 GpStatus WINGDIPAPI GdipSetPixelOffsetMode(GpGraphics *graphics, PixelOffsetMode
4344     mode)
4345 {
4346     TRACE("(%p, %d)\n", graphics, mode);
4347
4348     if(!graphics)
4349         return InvalidParameter;
4350
4351     if(graphics->busy)
4352         return ObjectBusy;
4353
4354     graphics->pixeloffset = mode;
4355
4356     return Ok;
4357 }
4358
4359 GpStatus WINGDIPAPI GdipSetRenderingOrigin(GpGraphics *graphics, INT x, INT y)
4360 {
4361     static int calls;
4362
4363     TRACE("(%p,%i,%i)\n", graphics, x, y);
4364
4365     if (!(calls++))
4366         FIXME("not implemented\n");
4367
4368     return NotImplemented;
4369 }
4370
4371 GpStatus WINGDIPAPI GdipGetRenderingOrigin(GpGraphics *graphics, INT *x, INT *y)
4372 {
4373     static int calls;
4374
4375     TRACE("(%p,%p,%p)\n", graphics, x, y);
4376
4377     if (!(calls++))
4378         FIXME("not implemented\n");
4379
4380     *x = *y = 0;
4381
4382     return NotImplemented;
4383 }
4384
4385 GpStatus WINGDIPAPI GdipSetSmoothingMode(GpGraphics *graphics, SmoothingMode mode)
4386 {
4387     TRACE("(%p, %d)\n", graphics, mode);
4388
4389     if(!graphics)
4390         return InvalidParameter;
4391
4392     if(graphics->busy)
4393         return ObjectBusy;
4394
4395     graphics->smoothing = mode;
4396
4397     return Ok;
4398 }
4399
4400 GpStatus WINGDIPAPI GdipSetTextContrast(GpGraphics *graphics, UINT contrast)
4401 {
4402     TRACE("(%p, %d)\n", graphics, contrast);
4403
4404     if(!graphics)
4405         return InvalidParameter;
4406
4407     graphics->textcontrast = contrast;
4408
4409     return Ok;
4410 }
4411
4412 GpStatus WINGDIPAPI GdipSetTextRenderingHint(GpGraphics *graphics,
4413     TextRenderingHint hint)
4414 {
4415     TRACE("(%p, %d)\n", graphics, hint);
4416
4417     if(!graphics)
4418         return InvalidParameter;
4419
4420     if(graphics->busy)
4421         return ObjectBusy;
4422
4423     graphics->texthint = hint;
4424
4425     return Ok;
4426 }
4427
4428 GpStatus WINGDIPAPI GdipSetWorldTransform(GpGraphics *graphics, GpMatrix *matrix)
4429 {
4430     TRACE("(%p, %p)\n", graphics, matrix);
4431
4432     if(!graphics || !matrix)
4433         return InvalidParameter;
4434
4435     if(graphics->busy)
4436         return ObjectBusy;
4437
4438     GdipDeleteMatrix(graphics->worldtrans);
4439     return GdipCloneMatrix(matrix, &graphics->worldtrans);
4440 }
4441
4442 GpStatus WINGDIPAPI GdipTranslateWorldTransform(GpGraphics *graphics, REAL dx,
4443     REAL dy, GpMatrixOrder order)
4444 {
4445     TRACE("(%p, %.2f, %.2f, %d)\n", graphics, dx, dy, order);
4446
4447     if(!graphics)
4448         return InvalidParameter;
4449
4450     if(graphics->busy)
4451         return ObjectBusy;
4452
4453     return GdipTranslateMatrix(graphics->worldtrans, dx, dy, order);
4454 }
4455
4456 /*****************************************************************************
4457  * GdipSetClipHrgn [GDIPLUS.@]
4458  */
4459 GpStatus WINGDIPAPI GdipSetClipHrgn(GpGraphics *graphics, HRGN hrgn, CombineMode mode)
4460 {
4461     GpRegion *region;
4462     GpStatus status;
4463
4464     TRACE("(%p, %p, %d)\n", graphics, hrgn, mode);
4465
4466     if(!graphics)
4467         return InvalidParameter;
4468
4469     status = GdipCreateRegionHrgn(hrgn, &region);
4470     if(status != Ok)
4471         return status;
4472
4473     status = GdipSetClipRegion(graphics, region, mode);
4474
4475     GdipDeleteRegion(region);
4476     return status;
4477 }
4478
4479 GpStatus WINGDIPAPI GdipSetClipPath(GpGraphics *graphics, GpPath *path, CombineMode mode)
4480 {
4481     TRACE("(%p, %p, %d)\n", graphics, path, mode);
4482
4483     if(!graphics)
4484         return InvalidParameter;
4485
4486     if(graphics->busy)
4487         return ObjectBusy;
4488
4489     return GdipCombineRegionPath(graphics->clip, path, mode);
4490 }
4491
4492 GpStatus WINGDIPAPI GdipSetClipRect(GpGraphics *graphics, REAL x, REAL y,
4493                                     REAL width, REAL height,
4494                                     CombineMode mode)
4495 {
4496     GpRectF rect;
4497
4498     TRACE("(%p, %.2f, %.2f, %.2f, %.2f, %d)\n", graphics, x, y, width, height, mode);
4499
4500     if(!graphics)
4501         return InvalidParameter;
4502
4503     if(graphics->busy)
4504         return ObjectBusy;
4505
4506     rect.X = x;
4507     rect.Y = y;
4508     rect.Width  = width;
4509     rect.Height = height;
4510
4511     return GdipCombineRegionRect(graphics->clip, &rect, mode);
4512 }
4513
4514 GpStatus WINGDIPAPI GdipSetClipRectI(GpGraphics *graphics, INT x, INT y,
4515                                      INT width, INT height,
4516                                      CombineMode mode)
4517 {
4518     TRACE("(%p, %d, %d, %d, %d, %d)\n", graphics, x, y, width, height, mode);
4519
4520     if(!graphics)
4521         return InvalidParameter;
4522
4523     if(graphics->busy)
4524         return ObjectBusy;
4525
4526     return GdipSetClipRect(graphics, (REAL)x, (REAL)y, (REAL)width, (REAL)height, mode);
4527 }
4528
4529 GpStatus WINGDIPAPI GdipSetClipRegion(GpGraphics *graphics, GpRegion *region,
4530                                       CombineMode mode)
4531 {
4532     TRACE("(%p, %p, %d)\n", graphics, region, mode);
4533
4534     if(!graphics || !region)
4535         return InvalidParameter;
4536
4537     if(graphics->busy)
4538         return ObjectBusy;
4539
4540     return GdipCombineRegionRegion(graphics->clip, region, mode);
4541 }
4542
4543 GpStatus WINGDIPAPI GdipSetMetafileDownLevelRasterizationLimit(GpMetafile *metafile,
4544     UINT limitDpi)
4545 {
4546     static int calls;
4547
4548     TRACE("(%p,%u)\n", metafile, limitDpi);
4549
4550     if(!(calls++))
4551         FIXME("not implemented\n");
4552
4553     return NotImplemented;
4554 }
4555
4556 GpStatus WINGDIPAPI GdipDrawPolygon(GpGraphics *graphics,GpPen *pen,GDIPCONST GpPointF *points,
4557     INT count)
4558 {
4559     INT save_state;
4560     POINT *pti;
4561
4562     TRACE("(%p, %p, %d)\n", graphics, points, count);
4563
4564     if(!graphics || !pen || count<=0)
4565         return InvalidParameter;
4566
4567     if(graphics->busy)
4568         return ObjectBusy;
4569
4570     pti = GdipAlloc(sizeof(POINT) * count);
4571
4572     save_state = prepare_dc(graphics, pen);
4573     SelectObject(graphics->hdc, GetStockObject(NULL_BRUSH));
4574
4575     transform_and_round_points(graphics, pti, (GpPointF*)points, count);
4576     Polygon(graphics->hdc, pti, count);
4577
4578     restore_dc(graphics, save_state);
4579     GdipFree(pti);
4580
4581     return Ok;
4582 }
4583
4584 GpStatus WINGDIPAPI GdipDrawPolygonI(GpGraphics *graphics,GpPen *pen,GDIPCONST GpPoint *points,
4585     INT count)
4586 {
4587     GpStatus ret;
4588     GpPointF *ptf;
4589     INT i;
4590
4591     TRACE("(%p, %p, %p, %d)\n", graphics, pen, points, count);
4592
4593     if(count<=0)    return InvalidParameter;
4594     ptf = GdipAlloc(sizeof(GpPointF) * count);
4595
4596     for(i = 0;i < count; i++){
4597         ptf[i].X = (REAL)points[i].X;
4598         ptf[i].Y = (REAL)points[i].Y;
4599     }
4600
4601     ret = GdipDrawPolygon(graphics,pen,ptf,count);
4602     GdipFree(ptf);
4603
4604     return ret;
4605 }
4606
4607 GpStatus WINGDIPAPI GdipGetDpiX(GpGraphics *graphics, REAL* dpi)
4608 {
4609     TRACE("(%p, %p)\n", graphics, dpi);
4610
4611     if(!graphics || !dpi)
4612         return InvalidParameter;
4613
4614     if(graphics->busy)
4615         return ObjectBusy;
4616
4617     if (graphics->image)
4618         *dpi = graphics->image->xres;
4619     else
4620         *dpi = (REAL)GetDeviceCaps(graphics->hdc, LOGPIXELSX);
4621
4622     return Ok;
4623 }
4624
4625 GpStatus WINGDIPAPI GdipGetDpiY(GpGraphics *graphics, REAL* dpi)
4626 {
4627     TRACE("(%p, %p)\n", graphics, dpi);
4628
4629     if(!graphics || !dpi)
4630         return InvalidParameter;
4631
4632     if(graphics->busy)
4633         return ObjectBusy;
4634
4635     if (graphics->image)
4636         *dpi = graphics->image->yres;
4637     else
4638         *dpi = (REAL)GetDeviceCaps(graphics->hdc, LOGPIXELSY);
4639
4640     return Ok;
4641 }
4642
4643 GpStatus WINGDIPAPI GdipMultiplyWorldTransform(GpGraphics *graphics, GDIPCONST GpMatrix *matrix,
4644     GpMatrixOrder order)
4645 {
4646     GpMatrix m;
4647     GpStatus ret;
4648
4649     TRACE("(%p, %p, %d)\n", graphics, matrix, order);
4650
4651     if(!graphics || !matrix)
4652         return InvalidParameter;
4653
4654     if(graphics->busy)
4655         return ObjectBusy;
4656
4657     m = *(graphics->worldtrans);
4658
4659     ret = GdipMultiplyMatrix(&m, matrix, order);
4660     if(ret == Ok)
4661         *(graphics->worldtrans) = m;
4662
4663     return ret;
4664 }
4665
4666 /* Color used to fill bitmaps so we can tell which parts have been drawn over by gdi32. */
4667 static const COLORREF DC_BACKGROUND_KEY = 0x0c0b0d;
4668
4669 GpStatus WINGDIPAPI GdipGetDC(GpGraphics *graphics, HDC *hdc)
4670 {
4671     TRACE("(%p, %p)\n", graphics, hdc);
4672
4673     if(!graphics || !hdc)
4674         return InvalidParameter;
4675
4676     if(graphics->busy)
4677         return ObjectBusy;
4678
4679     if (!graphics->hdc ||
4680         (graphics->image && graphics->image->type == ImageTypeBitmap && ((GpBitmap*)graphics->image)->format & PixelFormatAlpha))
4681     {
4682         /* Create a fake HDC and fill it with a constant color. */
4683         HDC temp_hdc;
4684         HBITMAP hbitmap;
4685         GpStatus stat;
4686         GpRectF bounds;
4687         BITMAPINFOHEADER bmih;
4688         int i;
4689
4690         stat = get_graphics_bounds(graphics, &bounds);
4691         if (stat != Ok)
4692             return stat;
4693
4694         graphics->temp_hbitmap_width = bounds.Width;
4695         graphics->temp_hbitmap_height = bounds.Height;
4696
4697         bmih.biSize = sizeof(bmih);
4698         bmih.biWidth = graphics->temp_hbitmap_width;
4699         bmih.biHeight = -graphics->temp_hbitmap_height;
4700         bmih.biPlanes = 1;
4701         bmih.biBitCount = 32;
4702         bmih.biCompression = BI_RGB;
4703         bmih.biSizeImage = 0;
4704         bmih.biXPelsPerMeter = 0;
4705         bmih.biYPelsPerMeter = 0;
4706         bmih.biClrUsed = 0;
4707         bmih.biClrImportant = 0;
4708
4709         hbitmap = CreateDIBSection(NULL, (BITMAPINFO*)&bmih, DIB_RGB_COLORS,
4710             (void**)&graphics->temp_bits, NULL, 0);
4711         if (!hbitmap)
4712             return GenericError;
4713
4714         temp_hdc = CreateCompatibleDC(0);
4715         if (!temp_hdc)
4716         {
4717             DeleteObject(hbitmap);
4718             return GenericError;
4719         }
4720
4721         for (i=0; i<(graphics->temp_hbitmap_width * graphics->temp_hbitmap_height); i++)
4722             ((DWORD*)graphics->temp_bits)[i] = DC_BACKGROUND_KEY;
4723
4724         SelectObject(temp_hdc, hbitmap);
4725
4726         graphics->temp_hbitmap = hbitmap;
4727         *hdc = graphics->temp_hdc = temp_hdc;
4728     }
4729     else
4730     {
4731         *hdc = graphics->hdc;
4732     }
4733
4734     graphics->busy = TRUE;
4735
4736     return Ok;
4737 }
4738
4739 GpStatus WINGDIPAPI GdipReleaseDC(GpGraphics *graphics, HDC hdc)
4740 {
4741     TRACE("(%p, %p)\n", graphics, hdc);
4742
4743     if(!graphics || !hdc)
4744         return InvalidParameter;
4745
4746     if((graphics->hdc != hdc && graphics->temp_hdc != hdc) || !(graphics->busy))
4747         return InvalidParameter;
4748
4749     if (graphics->temp_hdc == hdc)
4750     {
4751         DWORD* pos;
4752         int i;
4753
4754         /* Find the pixels that have changed, and mark them as opaque. */
4755         pos = (DWORD*)graphics->temp_bits;
4756         for (i=0; i<(graphics->temp_hbitmap_width * graphics->temp_hbitmap_height); i++)
4757         {
4758             if (*pos != DC_BACKGROUND_KEY)
4759             {
4760                 *pos |= 0xff000000;
4761             }
4762             pos++;
4763         }
4764
4765         /* Write the changed pixels to the real target. */
4766         alpha_blend_pixels(graphics, 0, 0, graphics->temp_bits,
4767             graphics->temp_hbitmap_width, graphics->temp_hbitmap_height,
4768             graphics->temp_hbitmap_width * 4);
4769
4770         /* Clean up. */
4771         DeleteDC(graphics->temp_hdc);
4772         DeleteObject(graphics->temp_hbitmap);
4773         graphics->temp_hdc = NULL;
4774         graphics->temp_hbitmap = NULL;
4775     }
4776
4777     graphics->busy = FALSE;
4778
4779     return Ok;
4780 }
4781
4782 GpStatus WINGDIPAPI GdipGetClip(GpGraphics *graphics, GpRegion *region)
4783 {
4784     GpRegion *clip;
4785     GpStatus status;
4786
4787     TRACE("(%p, %p)\n", graphics, region);
4788
4789     if(!graphics || !region)
4790         return InvalidParameter;
4791
4792     if(graphics->busy)
4793         return ObjectBusy;
4794
4795     if((status = GdipCloneRegion(graphics->clip, &clip)) != Ok)
4796         return status;
4797
4798     /* free everything except root node and header */
4799     delete_element(&region->node);
4800     memcpy(region, clip, sizeof(GpRegion));
4801     GdipFree(clip);
4802
4803     return Ok;
4804 }
4805
4806 GpStatus WINGDIPAPI GdipTransformPoints(GpGraphics *graphics, GpCoordinateSpace dst_space,
4807                                         GpCoordinateSpace src_space, GpPointF *points, INT count)
4808 {
4809     GpMatrix *matrix;
4810     GpStatus stat;
4811     REAL unitscale;
4812
4813     if(!graphics || !points || count <= 0)
4814         return InvalidParameter;
4815
4816     if(graphics->busy)
4817         return ObjectBusy;
4818
4819     TRACE("(%p, %d, %d, %p, %d)\n", graphics, dst_space, src_space, points, count);
4820
4821     if (src_space == dst_space) return Ok;
4822
4823     stat = GdipCreateMatrix(&matrix);
4824     if (stat == Ok)
4825     {
4826         unitscale = convert_unit(graphics_res(graphics), graphics->unit);
4827
4828         if(graphics->unit != UnitDisplay)
4829             unitscale *= graphics->scale;
4830
4831         /* transform from src_space to CoordinateSpacePage */
4832         switch (src_space)
4833         {
4834         case CoordinateSpaceWorld:
4835             GdipMultiplyMatrix(matrix, graphics->worldtrans, MatrixOrderAppend);
4836             break;
4837         case CoordinateSpacePage:
4838             break;
4839         case CoordinateSpaceDevice:
4840             GdipScaleMatrix(matrix, 1.0/unitscale, 1.0/unitscale, MatrixOrderAppend);
4841             break;
4842         }
4843
4844         /* transform from CoordinateSpacePage to dst_space */
4845         switch (dst_space)
4846         {
4847         case CoordinateSpaceWorld:
4848             {
4849                 GpMatrix *inverted_transform;
4850                 stat = GdipCloneMatrix(graphics->worldtrans, &inverted_transform);
4851                 if (stat == Ok)
4852                 {
4853                     stat = GdipInvertMatrix(inverted_transform);
4854                     if (stat == Ok)
4855                         GdipMultiplyMatrix(matrix, inverted_transform, MatrixOrderAppend);
4856                     GdipDeleteMatrix(inverted_transform);
4857                 }
4858                 break;
4859             }
4860         case CoordinateSpacePage:
4861             break;
4862         case CoordinateSpaceDevice:
4863             GdipScaleMatrix(matrix, unitscale, unitscale, MatrixOrderAppend);
4864             break;
4865         }
4866
4867         if (stat == Ok)
4868             stat = GdipTransformMatrixPoints(matrix, points, count);
4869
4870         GdipDeleteMatrix(matrix);
4871     }
4872
4873     return stat;
4874 }
4875
4876 GpStatus WINGDIPAPI GdipTransformPointsI(GpGraphics *graphics, GpCoordinateSpace dst_space,
4877                                          GpCoordinateSpace src_space, GpPoint *points, INT count)
4878 {
4879     GpPointF *pointsF;
4880     GpStatus ret;
4881     INT i;
4882
4883     TRACE("(%p, %d, %d, %p, %d)\n", graphics, dst_space, src_space, points, count);
4884
4885     if(count <= 0)
4886         return InvalidParameter;
4887
4888     pointsF = GdipAlloc(sizeof(GpPointF) * count);
4889     if(!pointsF)
4890         return OutOfMemory;
4891
4892     for(i = 0; i < count; i++){
4893         pointsF[i].X = (REAL)points[i].X;
4894         pointsF[i].Y = (REAL)points[i].Y;
4895     }
4896
4897     ret = GdipTransformPoints(graphics, dst_space, src_space, pointsF, count);
4898
4899     if(ret == Ok)
4900         for(i = 0; i < count; i++){
4901             points[i].X = roundr(pointsF[i].X);
4902             points[i].Y = roundr(pointsF[i].Y);
4903         }
4904     GdipFree(pointsF);
4905
4906     return ret;
4907 }
4908
4909 HPALETTE WINGDIPAPI GdipCreateHalftonePalette(void)
4910 {
4911     static int calls;
4912
4913     TRACE("\n");
4914
4915     if (!calls++)
4916       FIXME("stub\n");
4917
4918     return NULL;
4919 }
4920
4921 /*****************************************************************************
4922  * GdipTranslateClip [GDIPLUS.@]
4923  */
4924 GpStatus WINGDIPAPI GdipTranslateClip(GpGraphics *graphics, REAL dx, REAL dy)
4925 {
4926     TRACE("(%p, %.2f, %.2f)\n", graphics, dx, dy);
4927
4928     if(!graphics)
4929         return InvalidParameter;
4930
4931     if(graphics->busy)
4932         return ObjectBusy;
4933
4934     return GdipTranslateRegion(graphics->clip, dx, dy);
4935 }
4936
4937 /*****************************************************************************
4938  * GdipTranslateClipI [GDIPLUS.@]
4939  */
4940 GpStatus WINGDIPAPI GdipTranslateClipI(GpGraphics *graphics, INT dx, INT dy)
4941 {
4942     TRACE("(%p, %d, %d)\n", graphics, dx, dy);
4943
4944     if(!graphics)
4945         return InvalidParameter;
4946
4947     if(graphics->busy)
4948         return ObjectBusy;
4949
4950     return GdipTranslateRegion(graphics->clip, (REAL)dx, (REAL)dy);
4951 }
4952
4953
4954 /*****************************************************************************
4955  * GdipMeasureDriverString [GDIPLUS.@]
4956  */
4957 GpStatus WINGDIPAPI GdipMeasureDriverString(GpGraphics *graphics, GDIPCONST UINT16 *text, INT length,
4958                                             GDIPCONST GpFont *font, GDIPCONST PointF *positions,
4959                                             INT flags, GDIPCONST GpMatrix *matrix, RectF *boundingBox)
4960 {
4961     FIXME("(%p %p %d %p %p %d %p %p): stub\n", graphics, text, length, font, positions, flags, matrix, boundingBox);
4962     return NotImplemented;
4963 }
4964
4965 /*****************************************************************************
4966  * GdipDrawDriverString [GDIPLUS.@]
4967  */
4968 GpStatus WINGDIPAPI GdipDrawDriverString(GpGraphics *graphics, GDIPCONST UINT16 *text, INT length,
4969                                          GDIPCONST GpFont *font, GDIPCONST GpBrush *brush,
4970                                          GDIPCONST PointF *positions, INT flags,
4971                                          GDIPCONST GpMatrix *matrix )
4972 {
4973     FIXME("(%p %p %d %p %p %p %d %p): stub\n", graphics, text, length, font, brush, positions, flags, matrix);
4974     return NotImplemented;
4975 }
4976
4977 GpStatus WINGDIPAPI GdipRecordMetafile(HDC hdc, EmfType type, GDIPCONST GpRectF *frameRect,
4978                                        MetafileFrameUnit frameUnit, GDIPCONST WCHAR *desc, GpMetafile **metafile)
4979 {
4980     FIXME("(%p %d %p %d %p %p): stub\n", hdc, type, frameRect, frameUnit, desc, metafile);
4981     return NotImplemented;
4982 }
4983
4984 /*****************************************************************************
4985  * GdipRecordMetafileI [GDIPLUS.@]
4986  */
4987 GpStatus WINGDIPAPI GdipRecordMetafileI(HDC hdc, EmfType type, GDIPCONST GpRect *frameRect,
4988                                         MetafileFrameUnit frameUnit, GDIPCONST WCHAR *desc, GpMetafile **metafile)
4989 {
4990     FIXME("(%p %d %p %d %p %p): stub\n", hdc, type, frameRect, frameUnit, desc, metafile);
4991     return NotImplemented;
4992 }
4993
4994 GpStatus WINGDIPAPI GdipRecordMetafileStream(IStream *stream, HDC hdc, EmfType type, GDIPCONST GpRect *frameRect,
4995                                         MetafileFrameUnit frameUnit, GDIPCONST WCHAR *desc, GpMetafile **metafile)
4996 {
4997     FIXME("(%p %p %d %p %d %p %p): stub\n", stream, hdc, type, frameRect, frameUnit, desc, metafile);
4998     return NotImplemented;
4999 }
5000
5001 /*****************************************************************************
5002  * GdipIsVisibleClipEmpty [GDIPLUS.@]
5003  */
5004 GpStatus WINGDIPAPI GdipIsVisibleClipEmpty(GpGraphics *graphics, BOOL *res)
5005 {
5006     GpStatus stat;
5007     GpRegion* rgn;
5008
5009     TRACE("(%p, %p)\n", graphics, res);
5010
5011     if((stat = GdipCreateRegion(&rgn)) != Ok)
5012         return stat;
5013
5014     if((stat = get_visible_clip_region(graphics, rgn)) != Ok)
5015         goto cleanup;
5016
5017     stat = GdipIsEmptyRegion(rgn, graphics, res);
5018
5019 cleanup:
5020     GdipDeleteRegion(rgn);
5021     return stat;
5022 }