dlls/gdiplus/graphicspath.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
  20 #include <stdarg.h>
  21 #include <math.h>
  22
  23 #include "windef.h"
  24 #include "winbase.h"
  25 #include "winuser.h"
  26 #include "wingdi.h"
  27
  28 #include "objbase.h"
  29
  30 #include "gdiplus.h"
  31 #include "gdiplus_private.h"
  32 #include "wine/debug.h"
  33
  34 WINE_DEFAULT_DEBUG_CHANNEL(gdiplus);
  35
  36 typedef struct path_list_node_t path_list_node_t;
  37 struct path_list_node_t {
  38     GpPointF pt;
  39     BYTE type; /* PathPointTypeStart or PathPointTypeLine */
  40     path_list_node_t *next;
  41 };
  42
  43 /* init list */
  44 static BOOL init_path_list(path_list_node_t **node, REAL x, REAL y)
  45 {
  46     *node = GdipAlloc(sizeof(path_list_node_t));
  47     if(!*node)
  48         return FALSE;
  49
  50     (*node)->pt.X = x;
  51     (*node)->pt.Y = y;
  52     (*node)->type = PathPointTypeStart;
  53     (*node)->next = NULL;
  54
  55     return TRUE;
  56 }
  57
  58 /* free all nodes including argument */
  59 static void free_path_list(path_list_node_t *node)
  60 {
  61     path_list_node_t *n = node;
  62
  63     while(n){
  64         n = n->next;
  65         GdipFree(node);
  66         node = n;
  67     }
  68 }
  69
  70 /* Add a node after 'node' */
  71 /*
  72  * Returns
  73  *  pointer on success
  74  *  NULL    on allocation problems
  75  */
  76 static path_list_node_t* add_path_list_node(path_list_node_t *node, REAL x, REAL y, BOOL type)
  77 {
  78     path_list_node_t *new;
  79
  80     new = GdipAlloc(sizeof(path_list_node_t));
  81     if(!new)
  82         return NULL;
  83
  84     new->pt.X  = x;
  85     new->pt.Y  = y;
  86     new->type  = type;
  87     new->next  = node->next;
  88     node->next = new;
  89
  90     return new;
  91 }
  92
  93 /* returns element count */
  94 static INT path_list_count(path_list_node_t *node)
  95 {
  96     INT count = 1;
  97
  98     while((node = node->next))
  99         ++count;
 100
 101     return count;
 102 }
 103
 104 /* GdipFlattenPath helper */
 105 /*
 106  * Used to recursively flatten single Bezier curve
 107  * Parameters:
 108  *  - start   : pointer to start point node;
 109  *  - (x2, y2): first control point;
 110  *  - (x3, y3): second control point;
 111  *  - end     : pointer to end point node
 112  *  - flatness: admissible error of linear approximation.
 113  *
 114  * Return value:
 115  *  TRUE : success
 116  *  FALSE: out of memory
 117  *
 118  * TODO: used quality criteria should be revised to match native as
 119  *       closer as possible.
 120  */
 121 static BOOL flatten_bezier(path_list_node_t *start, REAL x2, REAL y2, REAL x3, REAL y3,
 122                            path_list_node_t *end, REAL flatness)
 123 {
 124     /* this 5 middle points with start/end define to half-curves */
 125     GpPointF mp[5];
 126     GpPointF pt, pt_st;
 127     path_list_node_t *node;
 128
 129     /* calculate bezier curve middle points == new control points */
 130     mp[0].X = (start->pt.X + x2) / 2.0;
 131     mp[0].Y = (start->pt.Y + y2) / 2.0;
 132     /* middle point between control points */
 133     pt.X = (x2 + x3) / 2.0;
 134     pt.Y = (y2 + y3) / 2.0;
 135     mp[1].X = (mp[0].X + pt.X) / 2.0;
 136     mp[1].Y = (mp[0].Y + pt.Y) / 2.0;
 137     mp[4].X = (end->pt.X + x3) / 2.0;
 138     mp[4].Y = (end->pt.Y + y3) / 2.0;
 139     mp[3].X = (mp[4].X + pt.X) / 2.0;
 140     mp[3].Y = (mp[4].Y + pt.Y) / 2.0;
 141
 142     mp[2].X = (mp[1].X + mp[3].X) / 2.0;
 143     mp[2].Y = (mp[1].Y + mp[3].Y) / 2.0;
 144
 145     pt = end->pt;
 146     pt_st = start->pt;
 147     /* check flatness as a half of distance between middle point and a linearized path */
 148     if(fabs(((pt.Y - pt_st.Y)*mp[2].X + (pt_st.X - pt.X)*mp[2].Y +
 149         (pt_st.Y*pt.X - pt_st.X*pt.Y))) <=
 150         (0.5 * flatness*sqrtf((powf(pt.Y - pt_st.Y, 2.0) + powf(pt_st.X - pt.X, 2.0))))){
 151         return TRUE;
 152     }
 153     else
 154         /* add a middle point */
 155         if(!(node = add_path_list_node(start, mp[2].X, mp[2].Y, PathPointTypeLine)))
 156             return FALSE;
 157
 158     /* do the same with halfs */
 159     flatten_bezier(start, mp[0].X, mp[0].Y, mp[1].X, mp[1].Y, node, flatness);
 160     flatten_bezier(node,  mp[3].X, mp[3].Y, mp[4].X, mp[4].Y, end,  flatness);
 161
 162     return TRUE;
 163 }
 164
 165 GpStatus WINGDIPAPI GdipAddPathArc(GpPath *path, REAL x1, REAL y1, REAL x2,
 166     REAL y2, REAL startAngle, REAL sweepAngle)
 167 {
 168     INT count, old_count, i;
 169
 170     TRACE("(%p, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f)\n",
 171           path, x1, y1, x2, y2, startAngle, sweepAngle);
 172
 173     if(!path)
 174         return InvalidParameter;
 175
 176     count = arc2polybezier(NULL, x1, y1, x2, y2, startAngle, sweepAngle);
 177
 178     if(count == 0)
 179         return Ok;
 180     if(!lengthen_path(path, count))
 181         return OutOfMemory;
 182
 183     old_count = path->pathdata.Count;
 184     arc2polybezier(&path->pathdata.Points[old_count], x1, y1, x2, y2,
 185                    startAngle, sweepAngle);
 186
 187     for(i = 0; i < count; i++){
 188         path->pathdata.Types[old_count + i] = PathPointTypeBezier;
 189     }
 190
 191     path->pathdata.Types[old_count] =
 192         (path->newfigure ? PathPointTypeStart : PathPointTypeLine);
 193     path->newfigure = FALSE;
 194     path->pathdata.Count += count;
 195
 196     return Ok;
 197 }
 198
 199 GpStatus WINGDIPAPI GdipAddPathArcI(GpPath *path, INT x1, INT y1, INT x2,
 200    INT y2, REAL startAngle, REAL sweepAngle)
 201 {
 202     TRACE("(%p, %d, %d, %d, %d, %.2f, %.2f)\n",
 203           path, x1, y1, x2, y2, startAngle, sweepAngle);
 204
 205     return GdipAddPathArc(path,(REAL)x1,(REAL)y1,(REAL)x2,(REAL)y2,startAngle,sweepAngle);
 206 }
 207
 208 GpStatus WINGDIPAPI GdipAddPathBezier(GpPath *path, REAL x1, REAL y1, REAL x2,
 209     REAL y2, REAL x3, REAL y3, REAL x4, REAL y4)
 210 {
 211     INT old_count;
 212
 213     TRACE("(%p, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f)\n",
 214           path, x1, y1, x2, y2, x3, y3, x4, y4);
 215
 216     if(!path)
 217         return InvalidParameter;
 218
 219     if(!lengthen_path(path, 4))
 220         return OutOfMemory;
 221
 222     old_count = path->pathdata.Count;
 223
 224     path->pathdata.Points[old_count].X = x1;
 225     path->pathdata.Points[old_count].Y = y1;
 226     path->pathdata.Points[old_count + 1].X = x2;
 227     path->pathdata.Points[old_count + 1].Y = y2;
 228     path->pathdata.Points[old_count + 2].X = x3;
 229     path->pathdata.Points[old_count + 2].Y = y3;
 230     path->pathdata.Points[old_count + 3].X = x4;
 231     path->pathdata.Points[old_count + 3].Y = y4;
 232
 233     path->pathdata.Types[old_count] =
 234         (path->newfigure ? PathPointTypeStart : PathPointTypeLine);
 235     path->pathdata.Types[old_count + 1] = PathPointTypeBezier;
 236     path->pathdata.Types[old_count + 2] = PathPointTypeBezier;
 237     path->pathdata.Types[old_count + 3] = PathPointTypeBezier;
 238
 239     path->newfigure = FALSE;
 240     path->pathdata.Count += 4;
 241
 242     return Ok;
 243 }
 244
 245 GpStatus WINGDIPAPI GdipAddPathBezierI(GpPath *path, INT x1, INT y1, INT x2,
 246     INT y2, INT x3, INT y3, INT x4, INT y4)
 247 {
 248     TRACE("(%p, %d, %d, %d, %d, %d, %d, %d, %d)\n",
 249           path, x1, y1, x2, y2, x3, y3, x4, y4);
 250
 251     return GdipAddPathBezier(path,(REAL)x1,(REAL)y1,(REAL)x2,(REAL)y2,(REAL)x3,(REAL)y3,
 252                                   (REAL)x4,(REAL)y4);
 253 }
 254
 255 GpStatus WINGDIPAPI GdipAddPathBeziers(GpPath *path, GDIPCONST GpPointF *points,
 256     INT count)
 257 {
 258     INT i, old_count;
 259
 260     TRACE("(%p, %p, %d)\n", path, points, count);
 261
 262     if(!path || !points || ((count - 1) % 3))
 263         return InvalidParameter;
 264
 265     if(!lengthen_path(path, count))
 266         return OutOfMemory;
 267
 268     old_count = path->pathdata.Count;
 269
 270     for(i = 0; i < count; i++){
 271         path->pathdata.Points[old_count + i].X = points[i].X;
 272         path->pathdata.Points[old_count + i].Y = points[i].Y;
 273         path->pathdata.Types[old_count + i] = PathPointTypeBezier;
 274     }
 275
 276     path->pathdata.Types[old_count] =
 277         (path->newfigure ? PathPointTypeStart : PathPointTypeLine);
 278     path->newfigure = FALSE;
 279     path->pathdata.Count += count;
 280
 281     return Ok;
 282 }
 283
 284 GpStatus WINGDIPAPI GdipAddPathBeziersI(GpPath *path, GDIPCONST GpPoint *points,
 285     INT count)
 286 {
 287     GpPointF *ptsF;
 288     GpStatus ret;
 289     INT i;
 290
 291     TRACE("(%p, %p, %d)\n", path, points, count);
 292
 293     if(!points || ((count - 1) % 3))
 294         return InvalidParameter;
 295
 296     ptsF = GdipAlloc(sizeof(GpPointF) * count);
 297     if(!ptsF)
 298         return OutOfMemory;
 299
 300     for(i = 0; i < count; i++){
 301         ptsF[i].X = (REAL)points[i].X;
 302         ptsF[i].Y = (REAL)points[i].Y;
 303     }
 304
 305     ret = GdipAddPathBeziers(path, ptsF, count);
 306     GdipFree(ptsF);
 307
 308     return ret;
 309 }
 310
 311 GpStatus WINGDIPAPI GdipAddPathClosedCurve(GpPath *path, GDIPCONST GpPointF *points,
 312     INT count)
 313 {
 314     TRACE("(%p, %p, %d)\n", path, points, count);
 315
 316     return GdipAddPathClosedCurve2(path, points, count, 1.0);
 317 }
 318
 319 GpStatus WINGDIPAPI GdipAddPathClosedCurveI(GpPath *path, GDIPCONST GpPoint *points,
 320     INT count)
 321 {
 322     TRACE("(%p, %p, %d)\n", path, points, count);
 323
 324     return GdipAddPathClosedCurve2I(path, points, count, 1.0);
 325 }
 326
 327 GpStatus WINGDIPAPI GdipAddPathClosedCurve2(GpPath *path, GDIPCONST GpPointF *points,
 328     INT count, REAL tension)
 329 {
 330     INT i, len_pt = (count + 1)*3-2;
 331     GpPointF *pt;
 332     GpPointF *pts;
 333     REAL x1, x2, y1, y2;
 334     GpStatus stat;
 335
 336     TRACE("(%p, %p, %d, %.2f)\n", path, points, count, tension);
 337
 338     if(!path || !points || count <= 1)
 339         return InvalidParameter;
 340
 341     pt = GdipAlloc(len_pt * sizeof(GpPointF));
 342     pts = GdipAlloc((count + 1)*sizeof(GpPointF));
 343     if(!pt || !pts){
 344         GdipFree(pt);
 345         GdipFree(pts);
 346         return OutOfMemory;
 347     }
 348
 349     /* copy source points to extend with the last one */
 350     memcpy(pts, points, sizeof(GpPointF)*count);
 351     pts[count] = pts[0];
 352
 353     tension = tension * TENSION_CONST;
 354
 355     for(i = 0; i < count-1; i++){
 356         calc_curve_bezier(&(pts[i]), tension, &x1, &y1, &x2, &y2);
 357
 358         pt[3*i+2].X = x1;
 359         pt[3*i+2].Y = y1;
 360         pt[3*i+3].X = pts[i+1].X;
 361         pt[3*i+3].Y = pts[i+1].Y;
 362         pt[3*i+4].X = x2;
 363         pt[3*i+4].Y = y2;
 364     }
 365
 366     /* points [len_pt-2] and [0] are calculated
 367        separately to connect splines properly */
 368     pts[0] = points[count-1];
 369     pts[1] = points[0]; /* equals to start and end of a resulting path */
 370     pts[2] = points[1];
 371
 372     calc_curve_bezier(pts, tension, &x1, &y1, &x2, &y2);
 373     pt[len_pt-2].X = x1;
 374     pt[len_pt-2].Y = y1;
 375     pt[0].X = pts[1].X;
 376     pt[0].Y = pts[1].Y;
 377     pt[1].X = x2;
 378     pt[1].Y = y2;
 379     /* close path */
 380     pt[len_pt-1].X = pt[0].X;
 381     pt[len_pt-1].Y = pt[0].Y;
 382
 383     stat = GdipAddPathBeziers(path, pt, len_pt);
 384
 385     /* close figure */
 386     if(stat == Ok){
 387         INT count = path->pathdata.Count;
 388         path->pathdata.Types[count - 1] |= PathPointTypeCloseSubpath;
 389         path->newfigure = TRUE;
 390     }
 391
 392     GdipFree(pts);
 393     GdipFree(pt);
 394
 395     return stat;
 396 }
 397
 398 GpStatus WINGDIPAPI GdipAddPathClosedCurve2I(GpPath *path, GDIPCONST GpPoint *points,
 399     INT count, REAL tension)
 400 {
 401     GpPointF *ptf;
 402     INT i;
 403     GpStatus stat;
 404
 405     TRACE("(%p, %p, %d, %.2f)\n", path, points, count, tension);
 406
 407     if(!path || !points || count <= 1)
 408         return InvalidParameter;
 409
 410     ptf = GdipAlloc(sizeof(GpPointF)*count);
 411     if(!ptf)
 412         return OutOfMemory;
 413
 414     for(i = 0; i < count; i++){
 415         ptf[i].X = (REAL)points[i].X;
 416         ptf[i].Y = (REAL)points[i].Y;
 417     }
 418
 419     stat = GdipAddPathClosedCurve2(path, ptf, count, tension);
 420
 421     GdipFree(ptf);
 422
 423     return stat;
 424 }
 425
 426 GpStatus WINGDIPAPI GdipAddPathCurve(GpPath *path, GDIPCONST GpPointF *points, INT count)
 427 {
 428     TRACE("(%p, %p, %d)\n", path, points, count);
 429
 430     if(!path || !points || count <= 1)
 431         return InvalidParameter;
 432
 433     return GdipAddPathCurve2(path, points, count, 1.0);
 434 }
 435
 436 GpStatus WINGDIPAPI GdipAddPathCurveI(GpPath *path, GDIPCONST GpPoint *points, INT count)
 437 {
 438     TRACE("(%p, %p, %d)\n", path, points, count);
 439
 440     if(!path || !points || count <= 1)
 441         return InvalidParameter;
 442
 443     return GdipAddPathCurve2I(path, points, count, 1.0);
 444 }
 445
 446 GpStatus WINGDIPAPI GdipAddPathCurve2(GpPath *path, GDIPCONST GpPointF *points, INT count,
 447     REAL tension)
 448 {
 449     INT i, len_pt = count*3-2;
 450     GpPointF *pt;
 451     REAL x1, x2, y1, y2;
 452     GpStatus stat;
 453
 454     TRACE("(%p, %p, %d, %.2f)\n", path, points, count, tension);
 455
 456     if(!path || !points || count <= 1)
 457         return InvalidParameter;
 458
 459     pt = GdipAlloc(len_pt * sizeof(GpPointF));
 460     if(!pt)
 461         return OutOfMemory;
 462
 463     tension = tension * TENSION_CONST;
 464
 465     calc_curve_bezier_endp(points[0].X, points[0].Y, points[1].X, points[1].Y,
 466         tension, &x1, &y1);
 467
 468     pt[0].X = points[0].X;
 469     pt[0].Y = points[0].Y;
 470     pt[1].X = x1;
 471     pt[1].Y = y1;
 472
 473     for(i = 0; i < count-2; i++){
 474         calc_curve_bezier(&(points[i]), tension, &x1, &y1, &x2, &y2);
 475
 476         pt[3*i+2].X = x1;
 477         pt[3*i+2].Y = y1;
 478         pt[3*i+3].X = points[i+1].X;
 479         pt[3*i+3].Y = points[i+1].Y;
 480         pt[3*i+4].X = x2;
 481         pt[3*i+4].Y = y2;
 482     }
 483
 484     calc_curve_bezier_endp(points[count-1].X, points[count-1].Y,
 485         points[count-2].X, points[count-2].Y, tension, &x1, &y1);
 486
 487     pt[len_pt-2].X = x1;
 488     pt[len_pt-2].Y = y1;
 489     pt[len_pt-1].X = points[count-1].X;
 490     pt[len_pt-1].Y = points[count-1].Y;
 491
 492     stat = GdipAddPathBeziers(path, pt, len_pt);
 493
 494     GdipFree(pt);
 495
 496     return stat;
 497 }
 498
 499 GpStatus WINGDIPAPI GdipAddPathCurve2I(GpPath *path, GDIPCONST GpPoint *points,
 500     INT count, REAL tension)
 501 {
 502     GpPointF *ptf;
 503     INT i;
 504     GpStatus stat;
 505
 506     TRACE("(%p, %p, %d, %.2f)\n", path, points, count, tension);
 507
 508     if(!path || !points || count <= 1)
 509         return InvalidParameter;
 510
 511     ptf = GdipAlloc(sizeof(GpPointF)*count);
 512     if(!ptf)
 513         return OutOfMemory;
 514
 515     for(i = 0; i < count; i++){
 516         ptf[i].X = (REAL)points[i].X;
 517         ptf[i].Y = (REAL)points[i].Y;
 518     }
 519
 520     stat = GdipAddPathCurve2(path, ptf, count, tension);
 521
 522     GdipFree(ptf);
 523
 524     return stat;
 525 }
 526
 527 GpStatus WINGDIPAPI GdipAddPathCurve3(GpPath *path, GDIPCONST GpPointF *points,
 528     INT count, INT offset, INT nseg, REAL tension)
 529 {
 530     TRACE("(%p, %p, %d, %d, %d, %.2f)\n", path, points, count, offset, nseg, tension);
 531
 532     if(!path || !points || offset + 1 >= count || count - offset < nseg + 1)
 533         return InvalidParameter;
 534
 535     return GdipAddPathCurve2(path, &points[offset], nseg + 1, tension);
 536 }
 537
 538 GpStatus WINGDIPAPI GdipAddPathCurve3I(GpPath *path, GDIPCONST GpPoint *points,
 539     INT count, INT offset, INT nseg, REAL tension)
 540 {
 541     TRACE("(%p, %p, %d, %d, %d, %.2f)\n", path, points, count, offset, nseg, tension);
 542
 543     if(!path || !points || offset + 1 >= count || count - offset < nseg + 1)
 544         return InvalidParameter;
 545
 546     return GdipAddPathCurve2I(path, &points[offset], nseg + 1, tension);
 547 }
 548
 549 GpStatus WINGDIPAPI GdipAddPathEllipse(GpPath *path, REAL x, REAL y, REAL width,
 550     REAL height)
 551 {
 552     INT old_count, numpts;
 553
 554     TRACE("(%p, %.2f, %.2f, %.2f, %.2f)\n", path, x, y, width, height);
 555
 556     if(!path)
 557         return InvalidParameter;
 558
 559     if(!lengthen_path(path, MAX_ARC_PTS))
 560         return OutOfMemory;
 561
 562     old_count = path->pathdata.Count;
 563     if((numpts = arc2polybezier(&path->pathdata.Points[old_count],  x, y, width,
 564                                height, 0.0, 360.0)) != MAX_ARC_PTS){
 565         ERR("expected %d points but got %d\n", MAX_ARC_PTS, numpts);
 566         return GenericError;
 567     }
 568
 569     memset(&path->pathdata.Types[old_count + 1], PathPointTypeBezier,
 570            MAX_ARC_PTS - 1);
 571
 572     /* An ellipse is an intrinsic figure (always is its own subpath). */
 573     path->pathdata.Types[old_count] = PathPointTypeStart;
 574     path->pathdata.Types[old_count + MAX_ARC_PTS - 1] |= PathPointTypeCloseSubpath;
 575     path->newfigure = TRUE;
 576     path->pathdata.Count += MAX_ARC_PTS;
 577
 578     return Ok;
 579 }
 580
 581 GpStatus WINGDIPAPI GdipAddPathEllipseI(GpPath *path, INT x, INT y, INT width,
 582     INT height)
 583 {
 584     TRACE("(%p, %d, %d, %d, %d)\n", path, x, y, width, height);
 585
 586     return GdipAddPathEllipse(path,(REAL)x,(REAL)y,(REAL)width,(REAL)height);
 587 }
 588
 589 GpStatus WINGDIPAPI GdipAddPathLine2(GpPath *path, GDIPCONST GpPointF *points,
 590     INT count)
 591 {
 592     INT i, old_count;
 593
 594     TRACE("(%p, %p, %d)\n", path, points, count);
 595
 596     if(!path || !points)
 597         return InvalidParameter;
 598
 599     if(!lengthen_path(path, count))
 600         return OutOfMemory;
 601
 602     old_count = path->pathdata.Count;
 603
 604     for(i = 0; i < count; i++){
 605         path->pathdata.Points[old_count + i].X = points[i].X;
 606         path->pathdata.Points[old_count + i].Y = points[i].Y;
 607         path->pathdata.Types[old_count + i] = PathPointTypeLine;
 608     }
 609
 610     if(path->newfigure){
 611         path->pathdata.Types[old_count] = PathPointTypeStart;
 612         path->newfigure = FALSE;
 613     }
 614
 615     path->pathdata.Count += count;
 616
 617     return Ok;
 618 }
 619
 620 GpStatus WINGDIPAPI GdipAddPathLine2I(GpPath *path, GDIPCONST GpPoint *points, INT count)
 621 {
 622     GpPointF *pointsF;
 623     INT i;
 624     GpStatus stat;
 625
 626     TRACE("(%p, %p, %d)\n", path, points, count);
 627
 628     if(count <= 0)
 629         return InvalidParameter;
 630
 631     pointsF = GdipAlloc(sizeof(GpPointF) * count);
 632     if(!pointsF)    return OutOfMemory;
 633
 634     for(i = 0;i < count; i++){
 635         pointsF[i].X = (REAL)points[i].X;
 636         pointsF[i].Y = (REAL)points[i].Y;
 637     }
 638
 639     stat = GdipAddPathLine2(path, pointsF, count);
 640
 641     GdipFree(pointsF);
 642
 643     return stat;
 644 }
 645
 646 GpStatus WINGDIPAPI GdipAddPathLine(GpPath *path, REAL x1, REAL y1, REAL x2, REAL y2)
 647 {
 648     INT old_count;
 649
 650     TRACE("(%p, %.2f, %.2f, %.2f, %.2f)\n", path, x1, y1, x2, y2);
 651
 652     if(!path)
 653         return InvalidParameter;
 654
 655     if(!lengthen_path(path, 2))
 656         return OutOfMemory;
 657
 658     old_count = path->pathdata.Count;
 659
 660     path->pathdata.Points[old_count].X = x1;
 661     path->pathdata.Points[old_count].Y = y1;
 662     path->pathdata.Points[old_count + 1].X = x2;
 663     path->pathdata.Points[old_count + 1].Y = y2;
 664
 665     path->pathdata.Types[old_count] =
 666         (path->newfigure ? PathPointTypeStart : PathPointTypeLine);
 667     path->pathdata.Types[old_count + 1] = PathPointTypeLine;
 668
 669     path->newfigure = FALSE;
 670     path->pathdata.Count += 2;
 671
 672     return Ok;
 673 }
 674
 675 GpStatus WINGDIPAPI GdipAddPathLineI(GpPath *path, INT x1, INT y1, INT x2, INT y2)
 676 {
 677     TRACE("(%p, %d, %d, %d, %d)\n", path, x1, y1, x2, y2);
 678
 679     return GdipAddPathLine(path, (REAL)x1, (REAL)y1, (REAL)x2, (REAL)y2);
 680 }
 681
 682 GpStatus WINGDIPAPI GdipAddPathPath(GpPath *path, GDIPCONST GpPath* addingPath,
 683     BOOL connect)
 684 {
 685     INT old_count, count;
 686
 687     TRACE("(%p, %p, %d)\n", path, addingPath, connect);
 688
 689     if(!path || !addingPath)
 690         return InvalidParameter;
 691
 692     old_count = path->pathdata.Count;
 693     count = addingPath->pathdata.Count;
 694
 695     if(!lengthen_path(path, count))
 696         return OutOfMemory;
 697
 698     memcpy(&path->pathdata.Points[old_count], addingPath->pathdata.Points,
 699            count * sizeof(GpPointF));
 700     memcpy(&path->pathdata.Types[old_count], addingPath->pathdata.Types, count);
 701
 702     if(path->newfigure || !connect)
 703         path->pathdata.Types[old_count] = PathPointTypeStart;
 704     else
 705         path->pathdata.Types[old_count] = PathPointTypeLine;
 706
 707     path->newfigure = FALSE;
 708     path->pathdata.Count += count;
 709
 710     return Ok;
 711 }
 712
 713 GpStatus WINGDIPAPI GdipAddPathPie(GpPath *path, REAL x, REAL y, REAL width, REAL height,
 714     REAL startAngle, REAL sweepAngle)
 715 {
 716     GpPointF *ptf;
 717     GpStatus status;
 718     INT i, count;
 719
 720     TRACE("(%p, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f)\n",
 721           path, x, y, width, height, startAngle, sweepAngle);
 722
 723     if(!path)
 724         return InvalidParameter;
 725
 726     /* on zero width/height only start point added */
 727     if(width <= 1e-7 || height <= 1e-7){
 728         if(!lengthen_path(path, 1))
 729             return OutOfMemory;
 730         path->pathdata.Points[0].X = x + width  / 2.0;
 731         path->pathdata.Points[0].Y = y + height / 2.0;
 732         path->pathdata.Types[0] = PathPointTypeStart | PathPointTypeCloseSubpath;
 733         path->pathdata.Count = 1;
 734         return InvalidParameter;
 735     }
 736
 737     count = arc2polybezier(NULL, x, y, width, height, startAngle, sweepAngle);
 738
 739     if(count == 0)
 740         return Ok;
 741
 742     ptf = GdipAlloc(sizeof(GpPointF)*count);
 743     if(!ptf)
 744         return OutOfMemory;
 745
 746     arc2polybezier(ptf, x, y, width, height, startAngle, sweepAngle);
 747
 748     status = GdipAddPathLine(path, (width - x)/2, (height - y)/2, ptf[0].X, ptf[0].Y);
 749     if(status != Ok){
 750         GdipFree(ptf);
 751         return status;
 752     }
 753     /* one spline is already added as a line endpoint */
 754     if(!lengthen_path(path, count - 1)){
 755         GdipFree(ptf);
 756         return OutOfMemory;
 757     }
 758
 759     memcpy(&(path->pathdata.Points[path->pathdata.Count]), &(ptf[1]),sizeof(GpPointF)*(count-1));
 760     for(i = 0; i < count-1; i++)
 761         path->pathdata.Types[path->pathdata.Count+i] = PathPointTypeBezier;
 762
 763     path->pathdata.Count += count-1;
 764
 765     GdipClosePathFigure(path);
 766
 767     GdipFree(ptf);
 768
 769     return status;
 770 }
 771
 772 GpStatus WINGDIPAPI GdipAddPathPieI(GpPath *path, INT x, INT y, INT width, INT height,
 773     REAL startAngle, REAL sweepAngle)
 774 {
 775     TRACE("(%p, %d, %d, %d, %d, %.2f, %.2f)\n",
 776           path, x, y, width, height, startAngle, sweepAngle);
 777
 778     return GdipAddPathPie(path, (REAL)x, (REAL)y, (REAL)width, (REAL)height, startAngle, sweepAngle);
 779 }
 780
 781 GpStatus WINGDIPAPI GdipAddPathPolygon(GpPath *path, GDIPCONST GpPointF *points, INT count)
 782 {
 783     INT old_count;
 784
 785     TRACE("(%p, %p, %d)\n", path, points, count);
 786
 787     if(!path || !points || count < 3)
 788         return InvalidParameter;
 789
 790     if(!lengthen_path(path, count))
 791         return OutOfMemory;
 792
 793     old_count = path->pathdata.Count;
 794
 795     memcpy(&path->pathdata.Points[old_count], points, count*sizeof(GpPointF));
 796     memset(&path->pathdata.Types[old_count + 1], PathPointTypeLine, count - 1);
 797
 798     /* A polygon is an intrinsic figure */
 799     path->pathdata.Types[old_count] = PathPointTypeStart;
 800     path->pathdata.Types[old_count + count - 1] |= PathPointTypeCloseSubpath;
 801     path->newfigure = TRUE;
 802     path->pathdata.Count += count;
 803
 804     return Ok;
 805 }
 806
 807 GpStatus WINGDIPAPI GdipAddPathPolygonI(GpPath *path, GDIPCONST GpPoint *points, INT count)
 808 {
 809     GpPointF *ptf;
 810     GpStatus status;
 811     INT i;
 812
 813     TRACE("(%p, %p, %d)\n", path, points, count);
 814
 815     if(!points || count < 3)
 816         return InvalidParameter;
 817
 818     ptf = GdipAlloc(sizeof(GpPointF) * count);
 819     if(!ptf)
 820         return OutOfMemory;
 821
 822     for(i = 0; i < count; i++){
 823         ptf[i].X = (REAL)points[i].X;
 824         ptf[i].Y = (REAL)points[i].Y;
 825     }
 826
 827     status = GdipAddPathPolygon(path, ptf, count);
 828
 829     GdipFree(ptf);
 830
 831     return status;
 832 }
 833
 834 static float fromfixedpoint(const FIXED v)
 835 {
 836     float f = ((float)v.fract) / (1<<(sizeof(v.fract)*8));
 837     f += v.value;
 838     return f;
 839 }
 840
 841 struct format_string_args
 842 {
 843     GpPath *path;
 844     UINT maxY;
 845 };
 846
 847 static GpStatus format_string_callback(HDC dc,
 848     GDIPCONST WCHAR *string, INT index, INT length, GDIPCONST GpFont *font,
 849     GDIPCONST RectF *rect, GDIPCONST GpStringFormat *format,
 850     INT lineno, const RectF *bounds, void *priv)
 851 {
 852     static const MAT2 identity = { {0,1}, {0,0}, {0,0}, {0,1} };
 853     struct format_string_args *args = priv;
 854     GpPath *path = args->path;
 855     GpStatus status = Ok;
 856     float x = bounds->X;
 857     float y = bounds->Y;
 858     int i;
 859
 860     for (i = index; i < length; ++i)
 861     {
 862         GLYPHMETRICS gm;
 863         TTPOLYGONHEADER *ph = NULL;
 864         char *start;
 865         DWORD len, ofs = 0;
 866         UINT bb_end;
 867         len = GetGlyphOutlineW(dc, string[i], GGO_BEZIER, &gm, 0, NULL, &identity);
 868         if (len == GDI_ERROR)
 869         {
 870             status = GenericError;
 871             break;
 872         }
 873         ph = GdipAlloc(len);
 874         start = (char *)ph;
 875         if (!ph || !lengthen_path(path, len / sizeof(POINTFX)))
 876         {
 877             status = OutOfMemory;
 878             break;
 879         }
 880         GetGlyphOutlineW(dc, string[i], GGO_BEZIER, &gm, len, start, &identity);
 881         bb_end = gm.gmBlackBoxY + gm.gmptGlyphOrigin.y;
 882         if (bb_end + y > args->maxY)
 883             args->maxY = bb_end + y;
 884
 885         ofs = 0;
 886         while (ofs < len)
 887         {
 888             DWORD ofs_start = ofs;
 889             ph = (TTPOLYGONHEADER*)&start[ofs];
 890             path->pathdata.Types[path->pathdata.Count] = PathPointTypeStart;
 891             path->pathdata.Points[path->pathdata.Count].X = x + fromfixedpoint(ph->pfxStart.x);
 892             path->pathdata.Points[path->pathdata.Count++].Y = y + bb_end - fromfixedpoint(ph->pfxStart.y);
 893             TRACE("Starting at count %i with pos %f, %f)\n", path->pathdata.Count, x, y);
 894             ofs += sizeof(*ph);
 895             while (ofs - ofs_start < ph->cb)
 896             {
 897                 TTPOLYCURVE *curve = (TTPOLYCURVE*)&start[ofs];
 898                 int j;
 899                 ofs += sizeof(TTPOLYCURVE) + (curve->cpfx - 1) * sizeof(POINTFX);
 900
 901                 switch (curve->wType)
 902                 {
 903                 case TT_PRIM_LINE:
 904                     for (j = 0; j < curve->cpfx; ++j)
 905                     {
 906                         path->pathdata.Types[path->pathdata.Count] = PathPointTypeLine;
 907                         path->pathdata.Points[path->pathdata.Count].X = x + fromfixedpoint(curve->apfx[j].x);
 908                         path->pathdata.Points[path->pathdata.Count++].Y = y + bb_end - fromfixedpoint(curve->apfx[j].y);
 909                     }
 910                     break;
 911                 case TT_PRIM_CSPLINE:
 912                     for (j = 0; j < curve->cpfx; ++j)
 913                     {
 914                         path->pathdata.Types[path->pathdata.Count] = PathPointTypeBezier;
 915                         path->pathdata.Points[path->pathdata.Count].X = x + fromfixedpoint(curve->apfx[j].x);
 916                         path->pathdata.Points[path->pathdata.Count++].Y = y + bb_end - fromfixedpoint(curve->apfx[j].y);
 917                     }
 918                     break;
 919                 default:
 920                     ERR("Unhandled type: %u\n", curve->wType);
 921                     status = GenericError;
 922                 }
 923             }
 924             path->pathdata.Types[path->pathdata.Count - 1] |= PathPointTypeCloseSubpath;
 925         }
 926         path->newfigure = TRUE;
 927         x += gm.gmCellIncX;
 928         y += gm.gmCellIncY;
 929
 930         GdipFree(ph);
 931         if (status != Ok)
 932             break;
 933     }
 934
 935     return status;
 936 }
 937
 938 GpStatus WINGDIPAPI GdipAddPathString(GpPath* path, GDIPCONST WCHAR* string, INT length, GDIPCONST GpFontFamily* family, INT style, REAL emSize, GDIPCONST RectF* layoutRect, GDIPCONST GpStringFormat* format)
 939 {
 940     GpFont *font;
 941     GpStatus status;
 942     HANDLE hfont;
 943     HDC dc;
 944     GpPath *backup;
 945     struct format_string_args args;
 946     int i;
 947
 948     FIXME("(%p, %s, %d, %p, %d, %f, %p, %p): stub\n", path, debugstr_w(string), length, family, style, emSize, layoutRect, format);
 949     if (!path || !string || !family || !emSize || !layoutRect || !format)
 950         return InvalidParameter;
 951
 952     status = GdipCreateFont(family, emSize, style, UnitPixel, &font);
 953     if (status != Ok)
 954         return status;
 955
 956     hfont = CreateFontIndirectW(&font->lfw);
 957     if (!hfont)
 958     {
 959         WARN("Failed to create font\n");
 960         return GenericError;
 961     }
 962
 963     if ((status = GdipClonePath(path, &backup)) != Ok)
 964     {
 965         DeleteObject(hfont);
 966         return status;
 967     }
 968
 969     dc = CreateCompatibleDC(0);
 970     SelectObject(dc, hfont);
 971
 972     args.path = path;
 973     args.maxY = 0;
 974     status = gdip_format_string(dc, string, length, NULL, layoutRect, format, format_string_callback, &args);
 975
 976     DeleteDC(dc);
 977     DeleteObject(hfont);
 978
 979     if (status != Ok) /* free backup */
 980     {
 981         GdipFree(path->pathdata.Points);
 982         GdipFree(path->pathdata.Types);
 983         *path = *backup;
 984         GdipFree(backup);
 985         return status;
 986     }
 987     if (format && format->vertalign == StringAlignmentCenter && layoutRect->Y + args.maxY < layoutRect->Height)
 988     {
 989         float inc = layoutRect->Height - args.maxY - layoutRect->Y;
 990         inc /= 2;
 991         for (i = backup->pathdata.Count; i < path->pathdata.Count; ++i)
 992             path->pathdata.Points[i].Y += inc;
 993     } else if (format && format->vertalign == StringAlignmentFar) {
 994         float inc = layoutRect->Height - args.maxY - layoutRect->Y;
 995         for (i = backup->pathdata.Count; i < path->pathdata.Count; ++i)
 996             path->pathdata.Points[i].Y += inc;
 997     }
 998     GdipDeletePath(backup);
 999     return status;
1000 }
1001
1002 GpStatus WINGDIPAPI GdipAddPathStringI(GpPath* path, GDIPCONST WCHAR* string, INT length, GDIPCONST GpFontFamily* family, INT style, REAL emSize, GDIPCONST Rect* layoutRect, GDIPCONST GpStringFormat* format)
1003 {
1004     if (layoutRect)
1005     {
1006         RectF layoutRectF = {
1007             (REAL)layoutRect->X,
1008             (REAL)layoutRect->Y,
1009             (REAL)layoutRect->Width,
1010             (REAL)layoutRect->Height
1011         };
1012         return GdipAddPathString(path, string, length, family, style, emSize, &layoutRectF, format);
1013     }
1014     return InvalidParameter;
1015 }
1016
1017 GpStatus WINGDIPAPI GdipClonePath(GpPath* path, GpPath **clone)
1018 {
1019     TRACE("(%p, %p)\n", path, clone);
1020
1021     if(!path || !clone)
1022         return InvalidParameter;
1023
1024     *clone = GdipAlloc(sizeof(GpPath));
1025     if(!*clone) return OutOfMemory;
1026
1027     **clone = *path;
1028
1029     (*clone)->pathdata.Points = GdipAlloc(path->datalen * sizeof(PointF));
1030     (*clone)->pathdata.Types = GdipAlloc(path->datalen);
1031     if(!(*clone)->pathdata.Points || !(*clone)->pathdata.Types){
1032         GdipFree(*clone);
1033         GdipFree((*clone)->pathdata.Points);
1034         GdipFree((*clone)->pathdata.Types);
1035         return OutOfMemory;
1036     }
1037
1038     memcpy((*clone)->pathdata.Points, path->pathdata.Points,
1039            path->datalen * sizeof(PointF));
1040     memcpy((*clone)->pathdata.Types, path->pathdata.Types, path->datalen);
1041
1042     return Ok;
1043 }
1044
1045 GpStatus WINGDIPAPI GdipClosePathFigure(GpPath* path)
1046 {
1047     TRACE("(%p)\n", path);
1048
1049     if(!path)
1050         return InvalidParameter;
1051
1052     if(path->pathdata.Count > 0){
1053         path->pathdata.Types[path->pathdata.Count - 1] |= PathPointTypeCloseSubpath;
1054         path->newfigure = TRUE;
1055     }
1056
1057     return Ok;
1058 }
1059
1060 GpStatus WINGDIPAPI GdipClosePathFigures(GpPath* path)
1061 {
1062     INT i;
1063
1064     TRACE("(%p)\n", path);
1065
1066     if(!path)
1067         return InvalidParameter;
1068
1069     for(i = 1; i < path->pathdata.Count; i++){
1070         if(path->pathdata.Types[i] == PathPointTypeStart)
1071             path->pathdata.Types[i-1] |= PathPointTypeCloseSubpath;
1072     }
1073
1074     path->newfigure = TRUE;
1075
1076     return Ok;
1077 }
1078
1079 GpStatus WINGDIPAPI GdipCreatePath(GpFillMode fill, GpPath **path)
1080 {
1081     TRACE("(%d, %p)\n", fill, path);
1082
1083     if(!path)
1084         return InvalidParameter;
1085
1086     *path = GdipAlloc(sizeof(GpPath));
1087     if(!*path)  return OutOfMemory;
1088
1089     (*path)->fill = fill;
1090     (*path)->newfigure = TRUE;
1091
1092     return Ok;
1093 }
1094
1095 GpStatus WINGDIPAPI GdipCreatePath2(GDIPCONST GpPointF* points,
1096     GDIPCONST BYTE* types, INT count, GpFillMode fill, GpPath **path)
1097 {
1098     TRACE("(%p, %p, %d, %d, %p)\n", points, types, count, fill, path);
1099
1100     if(!path)
1101         return InvalidParameter;
1102
1103     *path = GdipAlloc(sizeof(GpPath));
1104     if(!*path)  return OutOfMemory;
1105
1106     (*path)->pathdata.Points = GdipAlloc(count * sizeof(PointF));
1107     (*path)->pathdata.Types = GdipAlloc(count);
1108
1109     if(!(*path)->pathdata.Points || !(*path)->pathdata.Types){
1110         GdipFree((*path)->pathdata.Points);
1111         GdipFree((*path)->pathdata.Types);
1112         GdipFree(*path);
1113         return OutOfMemory;
1114     }
1115
1116     memcpy((*path)->pathdata.Points, points, count * sizeof(PointF));
1117     memcpy((*path)->pathdata.Types, types, count);
1118     (*path)->pathdata.Count = count;
1119     (*path)->datalen = count;
1120
1121     (*path)->fill = fill;
1122     (*path)->newfigure = TRUE;
1123
1124     return Ok;
1125 }
1126
1127 GpStatus WINGDIPAPI GdipCreatePath2I(GDIPCONST GpPoint* points,
1128     GDIPCONST BYTE* types, INT count, GpFillMode fill, GpPath **path)
1129 {
1130     GpPointF *ptF;
1131     GpStatus ret;
1132     INT i;
1133
1134     TRACE("(%p, %p, %d, %d, %p)\n", points, types, count, fill, path);
1135
1136     ptF = GdipAlloc(sizeof(GpPointF)*count);
1137
1138     for(i = 0;i < count; i++){
1139         ptF[i].X = (REAL)points[i].X;
1140         ptF[i].Y = (REAL)points[i].Y;
1141     }
1142
1143     ret = GdipCreatePath2(ptF, types, count, fill, path);
1144
1145     GdipFree(ptF);
1146
1147     return ret;
1148 }
1149
1150 GpStatus WINGDIPAPI GdipDeletePath(GpPath *path)
1151 {
1152     TRACE("(%p)\n", path);
1153
1154     if(!path)
1155         return InvalidParameter;
1156
1157     GdipFree(path->pathdata.Points);
1158     GdipFree(path->pathdata.Types);
1159     GdipFree(path);
1160
1161     return Ok;
1162 }
1163
1164 GpStatus WINGDIPAPI GdipFlattenPath(GpPath *path, GpMatrix* matrix, REAL flatness)
1165 {
1166     path_list_node_t *list, *node;
1167     GpPointF pt;
1168     INT i = 1;
1169     INT startidx = 0;
1170
1171     TRACE("(%p, %p, %.2f)\n", path, matrix, flatness);
1172
1173     if(!path)
1174         return InvalidParameter;
1175
1176     if(matrix){
1177         WARN("transformation not supported yet!\n");
1178         return NotImplemented;
1179     }
1180
1181     if(path->pathdata.Count == 0)
1182         return Ok;
1183
1184     pt = path->pathdata.Points[0];
1185     if(!init_path_list(&list, pt.X, pt.Y))
1186         return OutOfMemory;
1187
1188     node = list;
1189
1190     while(i < path->pathdata.Count){
1191
1192         BYTE type = path->pathdata.Types[i] & PathPointTypePathTypeMask;
1193         path_list_node_t *start;
1194
1195         pt = path->pathdata.Points[i];
1196
1197         /* save last start point index */
1198         if(type == PathPointTypeStart)
1199             startidx = i;
1200
1201         /* always add line points and start points */
1202         if((type == PathPointTypeStart) || (type == PathPointTypeLine)){
1203             if(!add_path_list_node(node, pt.X, pt.Y, path->pathdata.Types[i]))
1204                 goto memout;
1205
1206             node = node->next;
1207             ++i;
1208             continue;
1209         }
1210
1211         /* Bezier curve always stored as 4 points */
1212         if((path->pathdata.Types[i-1] & PathPointTypePathTypeMask) != PathPointTypeStart){
1213             type = (path->pathdata.Types[i] & ~PathPointTypePathTypeMask) | PathPointTypeLine;
1214             if(!add_path_list_node(node, pt.X, pt.Y, type))
1215                 goto memout;
1216
1217             node = node->next;
1218         }
1219
1220         /* test for closed figure */
1221         if(path->pathdata.Types[i+1] & PathPointTypeCloseSubpath){
1222             pt = path->pathdata.Points[startidx];
1223             ++i;
1224         }
1225         else
1226         {
1227             i += 2;
1228             pt = path->pathdata.Points[i];
1229         };
1230
1231         start = node;
1232         /* add Bezier end point */
1233         type = (path->pathdata.Types[i] & ~PathPointTypePathTypeMask) | PathPointTypeLine;
1234         if(!add_path_list_node(node, pt.X, pt.Y, type))
1235             goto memout;
1236         node = node->next;
1237
1238         /* flatten curve */
1239         if(!flatten_bezier(start, path->pathdata.Points[i-2].X, path->pathdata.Points[i-2].Y,
1240                                   path->pathdata.Points[i-1].X, path->pathdata.Points[i-1].Y,
1241                            node, flatness))
1242             goto memout;
1243
1244         ++i;
1245     }/* while */
1246
1247     /* store path data back */
1248     i = path_list_count(list);
1249     if(!lengthen_path(path, i))
1250         goto memout;
1251     path->pathdata.Count = i;
1252
1253     node = list;
1254     for(i = 0; i < path->pathdata.Count; i++){
1255         path->pathdata.Points[i] = node->pt;
1256         path->pathdata.Types[i]  = node->type;
1257         node = node->next;
1258     }
1259
1260     free_path_list(list);
1261     return Ok;
1262
1263 memout:
1264     free_path_list(list);
1265     return OutOfMemory;
1266 }
1267
1268 GpStatus WINGDIPAPI GdipGetPathData(GpPath *path, GpPathData* pathData)
1269 {
1270     TRACE("(%p, %p)\n", path, pathData);
1271
1272     if(!path || !pathData)
1273         return InvalidParameter;
1274
1275     /* Only copy data. pathData allocation/freeing controlled by wrapper class.
1276        Assumed that pathData is enough wide to get all data - controlled by wrapper too. */
1277     memcpy(pathData->Points, path->pathdata.Points, sizeof(PointF) * pathData->Count);
1278     memcpy(pathData->Types , path->pathdata.Types , pathData->Count);
1279
1280     return Ok;
1281 }
1282
1283 GpStatus WINGDIPAPI GdipGetPathFillMode(GpPath *path, GpFillMode *fillmode)
1284 {
1285     TRACE("(%p, %p)\n", path, fillmode);
1286
1287     if(!path || !fillmode)
1288         return InvalidParameter;
1289
1290     *fillmode = path->fill;
1291
1292     return Ok;
1293 }
1294
1295 GpStatus WINGDIPAPI GdipGetPathLastPoint(GpPath* path, GpPointF* lastPoint)
1296 {
1297     INT count;
1298
1299     TRACE("(%p, %p)\n", path, lastPoint);
1300
1301     if(!path || !lastPoint)
1302         return InvalidParameter;
1303
1304     count = path->pathdata.Count;
1305     if(count > 0)
1306         *lastPoint = path->pathdata.Points[count-1];
1307
1308     return Ok;
1309 }
1310
1311 GpStatus WINGDIPAPI GdipGetPathPoints(GpPath *path, GpPointF* points, INT count)
1312 {
1313     TRACE("(%p, %p, %d)\n", path, points, count);
1314
1315     if(!path)
1316         return InvalidParameter;
1317
1318     if(count < path->pathdata.Count)
1319         return InsufficientBuffer;
1320
1321     memcpy(points, path->pathdata.Points, path->pathdata.Count * sizeof(GpPointF));
1322
1323     return Ok;
1324 }
1325
1326 GpStatus WINGDIPAPI GdipGetPathPointsI(GpPath *path, GpPoint* points, INT count)
1327 {
1328     GpStatus ret;
1329     GpPointF *ptf;
1330     INT i;
1331
1332     TRACE("(%p, %p, %d)\n", path, points, count);
1333
1334     if(count <= 0)
1335         return InvalidParameter;
1336
1337     ptf = GdipAlloc(sizeof(GpPointF)*count);
1338     if(!ptf)    return OutOfMemory;
1339
1340     ret = GdipGetPathPoints(path,ptf,count);
1341     if(ret == Ok)
1342         for(i = 0;i < count;i++){
1343             points[i].X = roundr(ptf[i].X);
1344             points[i].Y = roundr(ptf[i].Y);
1345         };
1346     GdipFree(ptf);
1347
1348     return ret;
1349 }
1350
1351 GpStatus WINGDIPAPI GdipGetPathTypes(GpPath *path, BYTE* types, INT count)
1352 {
1353     TRACE("(%p, %p, %d)\n", path, types, count);
1354
1355     if(!path)
1356         return InvalidParameter;
1357
1358     if(count < path->pathdata.Count)
1359         return InsufficientBuffer;
1360
1361     memcpy(types, path->pathdata.Types, path->pathdata.Count);
1362
1363     return Ok;
1364 }
1365
1366 /* Windows expands the bounding box to the maximum possible bounding box
1367  * for a given pen.  For example, if a line join can extend past the point
1368  * it's joining by x units, the bounding box is extended by x units in every
1369  * direction (even though this is too conservative for most cases). */
1370 GpStatus WINGDIPAPI GdipGetPathWorldBounds(GpPath* path, GpRectF* bounds,
1371     GDIPCONST GpMatrix *matrix, GDIPCONST GpPen *pen)
1372 {
1373     GpPointF * points, temp_pts[4];
1374     INT count, i;
1375     REAL path_width = 1.0, width, height, temp, low_x, low_y, high_x, high_y;
1376
1377     TRACE("(%p, %p, %p, %p)\n", path, bounds, matrix, pen);
1378
1379     /* Matrix and pen can be null. */
1380     if(!path || !bounds)
1381         return InvalidParameter;
1382
1383     /* If path is empty just return. */
1384     count = path->pathdata.Count;
1385     if(count == 0){
1386         bounds->X = bounds->Y = bounds->Width = bounds->Height = 0.0;
1387         return Ok;
1388     }
1389
1390     points = path->pathdata.Points;
1391
1392     low_x = high_x = points[0].X;
1393     low_y = high_y = points[0].Y;
1394
1395     for(i = 1; i < count; i++){
1396         low_x = min(low_x, points[i].X);
1397         low_y = min(low_y, points[i].Y);
1398         high_x = max(high_x, points[i].X);
1399         high_y = max(high_y, points[i].Y);
1400     }
1401
1402     width = high_x - low_x;
1403     height = high_y - low_y;
1404
1405     /* This looks unusual but it's the only way I can imitate windows. */
1406     if(matrix){
1407         temp_pts[0].X = low_x;
1408         temp_pts[0].Y = low_y;
1409         temp_pts[1].X = low_x;
1410         temp_pts[1].Y = high_y;
1411         temp_pts[2].X = high_x;
1412         temp_pts[2].Y = high_y;
1413         temp_pts[3].X = high_x;
1414         temp_pts[3].Y = low_y;
1415
1416         GdipTransformMatrixPoints((GpMatrix*)matrix, temp_pts, 4);
1417         low_x = temp_pts[0].X;
1418         low_y = temp_pts[0].Y;
1419
1420         for(i = 1; i < 4; i++){
1421             low_x = min(low_x, temp_pts[i].X);
1422             low_y = min(low_y, temp_pts[i].Y);
1423         }
1424
1425         temp = width;
1426         width = height * fabs(matrix->matrix[2]) + width * fabs(matrix->matrix[0]);
1427         height = height * fabs(matrix->matrix[3]) + temp * fabs(matrix->matrix[1]);
1428     }
1429
1430     if(pen){
1431         path_width = pen->width / 2.0;
1432
1433         if(count > 2)
1434             path_width = max(path_width,  pen->width * pen->miterlimit / 2.0);
1435         /* FIXME: this should probably also check for the startcap */
1436         if(pen->endcap & LineCapNoAnchor)
1437             path_width = max(path_width,  pen->width * 2.2);
1438
1439         low_x -= path_width;
1440         low_y -= path_width;
1441         width += 2.0 * path_width;
1442         height += 2.0 * path_width;
1443     }
1444
1445     bounds->X = low_x;
1446     bounds->Y = low_y;
1447     bounds->Width = width;
1448     bounds->Height = height;
1449
1450     return Ok;
1451 }
1452
1453 GpStatus WINGDIPAPI GdipGetPathWorldBoundsI(GpPath* path, GpRect* bounds,
1454     GDIPCONST GpMatrix *matrix, GDIPCONST GpPen *pen)
1455 {
1456     GpStatus ret;
1457     GpRectF boundsF;
1458
1459     TRACE("(%p, %p, %p, %p)\n", path, bounds, matrix, pen);
1460
1461     ret = GdipGetPathWorldBounds(path,&boundsF,matrix,pen);
1462
1463     if(ret == Ok){
1464         bounds->X      = roundr(boundsF.X);
1465         bounds->Y      = roundr(boundsF.Y);
1466         bounds->Width  = roundr(boundsF.Width);
1467         bounds->Height = roundr(boundsF.Height);
1468     }
1469
1470     return ret;
1471 }
1472
1473 GpStatus WINGDIPAPI GdipGetPointCount(GpPath *path, INT *count)
1474 {
1475     TRACE("(%p, %p)\n", path, count);
1476
1477     if(!path)
1478         return InvalidParameter;
1479
1480     *count = path->pathdata.Count;
1481
1482     return Ok;
1483 }
1484
1485 GpStatus WINGDIPAPI GdipReversePath(GpPath* path)
1486 {
1487     INT i, count;
1488     INT start = 0; /* position in reversed path */
1489     GpPathData revpath;
1490
1491     TRACE("(%p)\n", path);
1492
1493     if(!path)
1494         return InvalidParameter;
1495
1496     count = path->pathdata.Count;
1497
1498     if(count == 0) return Ok;
1499
1500     revpath.Points = GdipAlloc(sizeof(GpPointF)*count);
1501     revpath.Types  = GdipAlloc(sizeof(BYTE)*count);
1502     revpath.Count  = count;
1503     if(!revpath.Points || !revpath.Types){
1504         GdipFree(revpath.Points);
1505         GdipFree(revpath.Types);
1506         return OutOfMemory;
1507     }
1508
1509     for(i = 0; i < count; i++){
1510
1511         /* find next start point */
1512         if(path->pathdata.Types[count-i-1] == PathPointTypeStart){
1513             INT j;
1514             for(j = start; j <= i; j++){
1515                 revpath.Points[j] = path->pathdata.Points[count-j-1];
1516                 revpath.Types[j] = path->pathdata.Types[count-j-1];
1517             }
1518             /* mark start point */
1519             revpath.Types[start] = PathPointTypeStart;
1520             /* set 'figure' endpoint type */
1521             if(i-start > 1){
1522                 revpath.Types[i] = path->pathdata.Types[count-start-1] & ~PathPointTypePathTypeMask;
1523                 revpath.Types[i] |= revpath.Types[i-1];
1524             }
1525             else
1526                 revpath.Types[i] = path->pathdata.Types[start];
1527
1528             start = i+1;
1529         }
1530     }
1531
1532     memcpy(path->pathdata.Points, revpath.Points, sizeof(GpPointF)*count);
1533     memcpy(path->pathdata.Types,  revpath.Types,  sizeof(BYTE)*count);
1534
1535     GdipFree(revpath.Points);
1536     GdipFree(revpath.Types);
1537
1538     return Ok;
1539 }
1540
1541 GpStatus WINGDIPAPI GdipIsOutlineVisiblePathPointI(GpPath* path, INT x, INT y,
1542     GpPen *pen, GpGraphics *graphics, BOOL *result)
1543 {
1544     TRACE("(%p, %d, %d, %p, %p, %p)\n", path, x, y, pen, graphics, result);
1545
1546     return GdipIsOutlineVisiblePathPoint(path, x, y, pen, graphics, result);
1547 }
1548
1549 GpStatus WINGDIPAPI GdipIsOutlineVisiblePathPoint(GpPath* path, REAL x, REAL y,
1550     GpPen *pen, GpGraphics *graphics, BOOL *result)
1551 {
1552     static int calls;
1553
1554     TRACE("(%p,%0.2f,%0.2f,%p,%p,%p)\n", path, x, y, pen, graphics, result);
1555
1556     if(!path || !pen)
1557         return InvalidParameter;
1558
1559     if(!(calls++))
1560         FIXME("not implemented\n");
1561
1562     return NotImplemented;
1563 }
1564
1565 GpStatus WINGDIPAPI GdipIsVisiblePathPointI(GpPath* path, INT x, INT y, GpGraphics *graphics, BOOL *result)
1566 {
1567     TRACE("(%p, %d, %d, %p, %p)\n", path, x, y, graphics, result);
1568
1569     return GdipIsVisiblePathPoint(path, x, y, graphics, result);
1570 }
1571
1572 /*****************************************************************************
1573  * GdipIsVisiblePathPoint [GDIPLUS.@]
1574  */
1575 GpStatus WINGDIPAPI GdipIsVisiblePathPoint(GpPath* path, REAL x, REAL y, GpGraphics *graphics, BOOL *result)
1576 {
1577     GpRegion *region;
1578     HRGN hrgn;
1579     GpStatus status;
1580
1581     if(!path || !result) return InvalidParameter;
1582
1583     status = GdipCreateRegionPath(path, &region);
1584     if(status != Ok)
1585         return status;
1586
1587     status = GdipGetRegionHRgn(region, graphics, &hrgn);
1588     if(status != Ok){
1589         GdipDeleteRegion(region);
1590         return status;
1591     }
1592
1593     *result = PtInRegion(hrgn, roundr(x), roundr(y));
1594
1595     DeleteObject(hrgn);
1596     GdipDeleteRegion(region);
1597
1598     return Ok;
1599 }
1600
1601 GpStatus WINGDIPAPI GdipStartPathFigure(GpPath *path)
1602 {
1603     TRACE("(%p)\n", path);
1604
1605     if(!path)
1606         return InvalidParameter;
1607
1608     path->newfigure = TRUE;
1609
1610     return Ok;
1611 }
1612
1613 GpStatus WINGDIPAPI GdipResetPath(GpPath *path)
1614 {
1615     TRACE("(%p)\n", path);
1616
1617     if(!path)
1618         return InvalidParameter;
1619
1620     path->pathdata.Count = 0;
1621     path->newfigure = TRUE;
1622     path->fill = FillModeAlternate;
1623
1624     return Ok;
1625 }
1626
1627 GpStatus WINGDIPAPI GdipSetPathFillMode(GpPath *path, GpFillMode fill)
1628 {
1629     TRACE("(%p, %d)\n", path, fill);
1630
1631     if(!path)
1632         return InvalidParameter;
1633
1634     path->fill = fill;
1635
1636     return Ok;
1637 }
1638
1639 GpStatus WINGDIPAPI GdipTransformPath(GpPath *path, GpMatrix *matrix)
1640 {
1641     TRACE("(%p, %p)\n", path, matrix);
1642
1643     if(!path)
1644         return InvalidParameter;
1645
1646     if(path->pathdata.Count == 0)
1647         return Ok;
1648
1649     return GdipTransformMatrixPoints(matrix, path->pathdata.Points,
1650                                      path->pathdata.Count);
1651 }
1652
1653 GpStatus WINGDIPAPI GdipWarpPath(GpPath *path, GpMatrix* matrix,
1654     GDIPCONST GpPointF *points, INT count, REAL x, REAL y, REAL width,
1655     REAL height, WarpMode warpmode, REAL flatness)
1656 {
1657     FIXME("(%p,%p,%p,%i,%0.2f,%0.2f,%0.2f,%0.2f,%i,%0.2f)\n", path, matrix,
1658         points, count, x, y, width, height, warpmode, flatness);
1659
1660     return NotImplemented;
1661 }
1662
1663 GpStatus WINGDIPAPI GdipWidenPath(GpPath *path, GpPen *pen, GpMatrix *matrix,
1664     REAL flatness)
1665 {
1666     FIXME("(%p,%p,%p,%0.2f)\n", path, pen, matrix, flatness);
1667
1668     return NotImplemented;
1669 }
1670
1671 GpStatus WINGDIPAPI GdipAddPathRectangle(GpPath *path, REAL x, REAL y,
1672     REAL width, REAL height)
1673 {
1674     GpPath *backup;
1675     GpPointF ptf[2];
1676     GpStatus retstat;
1677     BOOL old_new;
1678
1679     TRACE("(%p, %.2f, %.2f, %.2f, %.2f)\n", path, x, y, width, height);
1680
1681     if(!path)
1682         return InvalidParameter;
1683
1684     /* make a backup copy of path data */
1685     if((retstat = GdipClonePath(path, &backup)) != Ok)
1686         return retstat;
1687
1688     /* rectangle should start as new path */
1689     old_new = path->newfigure;
1690     path->newfigure = TRUE;
1691     if((retstat = GdipAddPathLine(path,x,y,x+width,y)) != Ok){
1692         path->newfigure = old_new;
1693         goto fail;
1694     }
1695
1696     ptf[0].X = x+width;
1697     ptf[0].Y = y+height;
1698     ptf[1].X = x;
1699     ptf[1].Y = y+height;
1700
1701     if((retstat = GdipAddPathLine2(path, ptf, 2)) != Ok)  goto fail;
1702     path->pathdata.Types[path->pathdata.Count-1] |= PathPointTypeCloseSubpath;
1703
1704     /* free backup */
1705     GdipDeletePath(backup);
1706     return Ok;
1707
1708 fail:
1709     /* reverting */
1710     GdipFree(path->pathdata.Points);
1711     GdipFree(path->pathdata.Types);
1712     memcpy(path, backup, sizeof(*path));
1713     GdipFree(backup);
1714
1715     return retstat;
1716 }
1717
1718 GpStatus WINGDIPAPI GdipAddPathRectangleI(GpPath *path, INT x, INT y,
1719     INT width, INT height)
1720 {
1721     TRACE("(%p, %d, %d, %d, %d)\n", path, x, y, width, height);
1722
1723     return GdipAddPathRectangle(path,(REAL)x,(REAL)y,(REAL)width,(REAL)height);
1724 }
1725
1726 GpStatus WINGDIPAPI GdipAddPathRectangles(GpPath *path, GDIPCONST GpRectF *rects, INT count)
1727 {
1728     GpPath *backup;
1729     GpStatus retstat;
1730     INT i;
1731
1732     TRACE("(%p, %p, %d)\n", path, rects, count);
1733
1734     /* count == 0 - verified condition  */
1735     if(!path || !rects || count == 0)
1736         return InvalidParameter;
1737
1738     if(count < 0)
1739         return OutOfMemory;
1740
1741     /* make a backup copy */
1742     if((retstat = GdipClonePath(path, &backup)) != Ok)
1743         return retstat;
1744
1745     for(i = 0; i < count; i++){
1746         if((retstat = GdipAddPathRectangle(path,rects[i].X,rects[i].Y,rects[i].Width,rects[i].Height)) != Ok)
1747             goto fail;
1748     }
1749
1750     /* free backup */
1751     GdipDeletePath(backup);
1752     return Ok;
1753
1754 fail:
1755     /* reverting */
1756     GdipFree(path->pathdata.Points);
1757     GdipFree(path->pathdata.Types);
1758     memcpy(path, backup, sizeof(*path));
1759     GdipFree(backup);
1760
1761     return retstat;
1762 }
1763
1764 GpStatus WINGDIPAPI GdipAddPathRectanglesI(GpPath *path, GDIPCONST GpRect *rects, INT count)
1765 {
1766     GpRectF *rectsF;
1767     GpStatus retstat;
1768     INT i;
1769
1770     TRACE("(%p, %p, %d)\n", path, rects, count);
1771
1772     if(!rects || count == 0)
1773         return InvalidParameter;
1774
1775     if(count < 0)
1776         return OutOfMemory;
1777
1778     rectsF = GdipAlloc(sizeof(GpRectF)*count);
1779
1780     for(i = 0;i < count;i++){
1781         rectsF[i].X      = (REAL)rects[i].X;
1782         rectsF[i].Y      = (REAL)rects[i].Y;
1783         rectsF[i].Width  = (REAL)rects[i].Width;
1784         rectsF[i].Height = (REAL)rects[i].Height;
1785     }
1786
1787     retstat = GdipAddPathRectangles(path, rectsF, count);
1788     GdipFree(rectsF);
1789
1790     return retstat;
1791 }
1792
1793 GpStatus WINGDIPAPI GdipSetPathMarker(GpPath* path)
1794 {
1795     INT count;
1796
1797     TRACE("(%p)\n", path);
1798
1799     if(!path)
1800         return InvalidParameter;
1801
1802     count = path->pathdata.Count;
1803
1804     /* set marker flag */
1805     if(count > 0)
1806         path->pathdata.Types[count-1] |= PathPointTypePathMarker;
1807
1808     return Ok;
1809 }
1810
1811 GpStatus WINGDIPAPI GdipClearPathMarkers(GpPath* path)
1812 {
1813     INT count;
1814     INT i;
1815
1816     TRACE("(%p)\n", path);
1817
1818     if(!path)
1819         return InvalidParameter;
1820
1821     count = path->pathdata.Count;
1822
1823     for(i = 0; i < count - 1; i++){
1824         path->pathdata.Types[i] &= ~PathPointTypePathMarker;
1825     }
1826
1827     return Ok;
1828 }
1829
1830 GpStatus WINGDIPAPI GdipWindingModeOutline(GpPath *path, GpMatrix *matrix, REAL flatness)
1831 {
1832    FIXME("stub: %p, %p, %.2f\n", path, matrix, flatness);
1833    return NotImplemented;
1834 }