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 halves */
 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         path->pathdata.Types[path->pathdata.Count - 1] |= PathPointTypeCloseSubpath;
 388         path->newfigure = TRUE;
 389     }
 390
 391     GdipFree(pts);
 392     GdipFree(pt);
 393
 394     return stat;
 395 }
 396
 397 GpStatus WINGDIPAPI GdipAddPathClosedCurve2I(GpPath *path, GDIPCONST GpPoint *points,
 398     INT count, REAL tension)
 399 {
 400     GpPointF *ptf;
 401     INT i;
 402     GpStatus stat;
 403
 404     TRACE("(%p, %p, %d, %.2f)\n", path, points, count, tension);
 405
 406     if(!path || !points || count <= 1)
 407         return InvalidParameter;
 408
 409     ptf = GdipAlloc(sizeof(GpPointF)*count);
 410     if(!ptf)
 411         return OutOfMemory;
 412
 413     for(i = 0; i < count; i++){
 414         ptf[i].X = (REAL)points[i].X;
 415         ptf[i].Y = (REAL)points[i].Y;
 416     }
 417
 418     stat = GdipAddPathClosedCurve2(path, ptf, count, tension);
 419
 420     GdipFree(ptf);
 421
 422     return stat;
 423 }
 424
 425 GpStatus WINGDIPAPI GdipAddPathCurve(GpPath *path, GDIPCONST GpPointF *points, INT count)
 426 {
 427     TRACE("(%p, %p, %d)\n", path, points, count);
 428
 429     if(!path || !points || count <= 1)
 430         return InvalidParameter;
 431
 432     return GdipAddPathCurve2(path, points, count, 1.0);
 433 }
 434
 435 GpStatus WINGDIPAPI GdipAddPathCurveI(GpPath *path, GDIPCONST GpPoint *points, INT count)
 436 {
 437     TRACE("(%p, %p, %d)\n", path, points, count);
 438
 439     if(!path || !points || count <= 1)
 440         return InvalidParameter;
 441
 442     return GdipAddPathCurve2I(path, points, count, 1.0);
 443 }
 444
 445 GpStatus WINGDIPAPI GdipAddPathCurve2(GpPath *path, GDIPCONST GpPointF *points, INT count,
 446     REAL tension)
 447 {
 448     INT i, len_pt = count*3-2;
 449     GpPointF *pt;
 450     REAL x1, x2, y1, y2;
 451     GpStatus stat;
 452
 453     TRACE("(%p, %p, %d, %.2f)\n", path, points, count, tension);
 454
 455     if(!path || !points || count <= 1)
 456         return InvalidParameter;
 457
 458     pt = GdipAlloc(len_pt * sizeof(GpPointF));
 459     if(!pt)
 460         return OutOfMemory;
 461
 462     tension = tension * TENSION_CONST;
 463
 464     calc_curve_bezier_endp(points[0].X, points[0].Y, points[1].X, points[1].Y,
 465         tension, &x1, &y1);
 466
 467     pt[0].X = points[0].X;
 468     pt[0].Y = points[0].Y;
 469     pt[1].X = x1;
 470     pt[1].Y = y1;
 471
 472     for(i = 0; i < count-2; i++){
 473         calc_curve_bezier(&(points[i]), tension, &x1, &y1, &x2, &y2);
 474
 475         pt[3*i+2].X = x1;
 476         pt[3*i+2].Y = y1;
 477         pt[3*i+3].X = points[i+1].X;
 478         pt[3*i+3].Y = points[i+1].Y;
 479         pt[3*i+4].X = x2;
 480         pt[3*i+4].Y = y2;
 481     }
 482
 483     calc_curve_bezier_endp(points[count-1].X, points[count-1].Y,
 484         points[count-2].X, points[count-2].Y, tension, &x1, &y1);
 485
 486     pt[len_pt-2].X = x1;
 487     pt[len_pt-2].Y = y1;
 488     pt[len_pt-1].X = points[count-1].X;
 489     pt[len_pt-1].Y = points[count-1].Y;
 490
 491     stat = GdipAddPathBeziers(path, pt, len_pt);
 492
 493     GdipFree(pt);
 494
 495     return stat;
 496 }
 497
 498 GpStatus WINGDIPAPI GdipAddPathCurve2I(GpPath *path, GDIPCONST GpPoint *points,
 499     INT count, REAL tension)
 500 {
 501     GpPointF *ptf;
 502     INT i;
 503     GpStatus stat;
 504
 505     TRACE("(%p, %p, %d, %.2f)\n", path, points, count, tension);
 506
 507     if(!path || !points || count <= 1)
 508         return InvalidParameter;
 509
 510     ptf = GdipAlloc(sizeof(GpPointF)*count);
 511     if(!ptf)
 512         return OutOfMemory;
 513
 514     for(i = 0; i < count; i++){
 515         ptf[i].X = (REAL)points[i].X;
 516         ptf[i].Y = (REAL)points[i].Y;
 517     }
 518
 519     stat = GdipAddPathCurve2(path, ptf, count, tension);
 520
 521     GdipFree(ptf);
 522
 523     return stat;
 524 }
 525
 526 GpStatus WINGDIPAPI GdipAddPathCurve3(GpPath *path, GDIPCONST GpPointF *points,
 527     INT count, INT offset, INT nseg, REAL tension)
 528 {
 529     TRACE("(%p, %p, %d, %d, %d, %.2f)\n", path, points, count, offset, nseg, tension);
 530
 531     if(!path || !points || offset + 1 >= count || count - offset < nseg + 1)
 532         return InvalidParameter;
 533
 534     return GdipAddPathCurve2(path, &points[offset], nseg + 1, tension);
 535 }
 536
 537 GpStatus WINGDIPAPI GdipAddPathCurve3I(GpPath *path, GDIPCONST GpPoint *points,
 538     INT count, INT offset, INT nseg, REAL tension)
 539 {
 540     TRACE("(%p, %p, %d, %d, %d, %.2f)\n", path, points, count, offset, nseg, tension);
 541
 542     if(!path || !points || offset + 1 >= count || count - offset < nseg + 1)
 543         return InvalidParameter;
 544
 545     return GdipAddPathCurve2I(path, &points[offset], nseg + 1, tension);
 546 }
 547
 548 GpStatus WINGDIPAPI GdipAddPathEllipse(GpPath *path, REAL x, REAL y, REAL width,
 549     REAL height)
 550 {
 551     INT old_count, numpts;
 552
 553     TRACE("(%p, %.2f, %.2f, %.2f, %.2f)\n", path, x, y, width, height);
 554
 555     if(!path)
 556         return InvalidParameter;
 557
 558     if(!lengthen_path(path, MAX_ARC_PTS))
 559         return OutOfMemory;
 560
 561     old_count = path->pathdata.Count;
 562     if((numpts = arc2polybezier(&path->pathdata.Points[old_count],  x, y, width,
 563                                height, 0.0, 360.0)) != MAX_ARC_PTS){
 564         ERR("expected %d points but got %d\n", MAX_ARC_PTS, numpts);
 565         return GenericError;
 566     }
 567
 568     memset(&path->pathdata.Types[old_count + 1], PathPointTypeBezier,
 569            MAX_ARC_PTS - 1);
 570
 571     /* An ellipse is an intrinsic figure (always is its own subpath). */
 572     path->pathdata.Types[old_count] = PathPointTypeStart;
 573     path->pathdata.Types[old_count + MAX_ARC_PTS - 1] |= PathPointTypeCloseSubpath;
 574     path->newfigure = TRUE;
 575     path->pathdata.Count += MAX_ARC_PTS;
 576
 577     return Ok;
 578 }
 579
 580 GpStatus WINGDIPAPI GdipAddPathEllipseI(GpPath *path, INT x, INT y, INT width,
 581     INT height)
 582 {
 583     TRACE("(%p, %d, %d, %d, %d)\n", path, x, y, width, height);
 584
 585     return GdipAddPathEllipse(path,(REAL)x,(REAL)y,(REAL)width,(REAL)height);
 586 }
 587
 588 GpStatus WINGDIPAPI GdipAddPathLine2(GpPath *path, GDIPCONST GpPointF *points,
 589     INT count)
 590 {
 591     INT i, old_count;
 592
 593     TRACE("(%p, %p, %d)\n", path, points, count);
 594
 595     if(!path || !points)
 596         return InvalidParameter;
 597
 598     if(!lengthen_path(path, count))
 599         return OutOfMemory;
 600
 601     old_count = path->pathdata.Count;
 602
 603     for(i = 0; i < count; i++){
 604         path->pathdata.Points[old_count + i].X = points[i].X;
 605         path->pathdata.Points[old_count + i].Y = points[i].Y;
 606         path->pathdata.Types[old_count + i] = PathPointTypeLine;
 607     }
 608
 609     if(path->newfigure){
 610         path->pathdata.Types[old_count] = PathPointTypeStart;
 611         path->newfigure = FALSE;
 612     }
 613
 614     path->pathdata.Count += count;
 615
 616     return Ok;
 617 }
 618
 619 GpStatus WINGDIPAPI GdipAddPathLine2I(GpPath *path, GDIPCONST GpPoint *points, INT count)
 620 {
 621     GpPointF *pointsF;
 622     INT i;
 623     GpStatus stat;
 624
 625     TRACE("(%p, %p, %d)\n", path, points, count);
 626
 627     if(count <= 0)
 628         return InvalidParameter;
 629
 630     pointsF = GdipAlloc(sizeof(GpPointF) * count);
 631     if(!pointsF)    return OutOfMemory;
 632
 633     for(i = 0;i < count; i++){
 634         pointsF[i].X = (REAL)points[i].X;
 635         pointsF[i].Y = (REAL)points[i].Y;
 636     }
 637
 638     stat = GdipAddPathLine2(path, pointsF, count);
 639
 640     GdipFree(pointsF);
 641
 642     return stat;
 643 }
 644
 645 GpStatus WINGDIPAPI GdipAddPathLine(GpPath *path, REAL x1, REAL y1, REAL x2, REAL y2)
 646 {
 647     INT old_count;
 648
 649     TRACE("(%p, %.2f, %.2f, %.2f, %.2f)\n", path, x1, y1, x2, y2);
 650
 651     if(!path)
 652         return InvalidParameter;
 653
 654     if(!lengthen_path(path, 2))
 655         return OutOfMemory;
 656
 657     old_count = path->pathdata.Count;
 658
 659     path->pathdata.Points[old_count].X = x1;
 660     path->pathdata.Points[old_count].Y = y1;
 661     path->pathdata.Points[old_count + 1].X = x2;
 662     path->pathdata.Points[old_count + 1].Y = y2;
 663
 664     path->pathdata.Types[old_count] =
 665         (path->newfigure ? PathPointTypeStart : PathPointTypeLine);
 666     path->pathdata.Types[old_count + 1] = PathPointTypeLine;
 667
 668     path->newfigure = FALSE;
 669     path->pathdata.Count += 2;
 670
 671     return Ok;
 672 }
 673
 674 GpStatus WINGDIPAPI GdipAddPathLineI(GpPath *path, INT x1, INT y1, INT x2, INT y2)
 675 {
 676     TRACE("(%p, %d, %d, %d, %d)\n", path, x1, y1, x2, y2);
 677
 678     return GdipAddPathLine(path, (REAL)x1, (REAL)y1, (REAL)x2, (REAL)y2);
 679 }
 680
 681 GpStatus WINGDIPAPI GdipAddPathPath(GpPath *path, GDIPCONST GpPath* addingPath,
 682     BOOL connect)
 683 {
 684     INT old_count, count;
 685
 686     TRACE("(%p, %p, %d)\n", path, addingPath, connect);
 687
 688     if(!path || !addingPath)
 689         return InvalidParameter;
 690
 691     old_count = path->pathdata.Count;
 692     count = addingPath->pathdata.Count;
 693
 694     if(!lengthen_path(path, count))
 695         return OutOfMemory;
 696
 697     memcpy(&path->pathdata.Points[old_count], addingPath->pathdata.Points,
 698            count * sizeof(GpPointF));
 699     memcpy(&path->pathdata.Types[old_count], addingPath->pathdata.Types, count);
 700
 701     if(path->newfigure || !connect)
 702         path->pathdata.Types[old_count] = PathPointTypeStart;
 703     else
 704         path->pathdata.Types[old_count] = PathPointTypeLine;
 705
 706     path->newfigure = FALSE;
 707     path->pathdata.Count += count;
 708
 709     return Ok;
 710 }
 711
 712 GpStatus WINGDIPAPI GdipAddPathPie(GpPath *path, REAL x, REAL y, REAL width, REAL height,
 713     REAL startAngle, REAL sweepAngle)
 714 {
 715     GpPointF *ptf;
 716     GpStatus status;
 717     INT i, count;
 718
 719     TRACE("(%p, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f)\n",
 720           path, x, y, width, height, startAngle, sweepAngle);
 721
 722     if(!path)
 723         return InvalidParameter;
 724
 725     /* on zero width/height only start point added */
 726     if(width <= 1e-7 || height <= 1e-7){
 727         if(!lengthen_path(path, 1))
 728             return OutOfMemory;
 729         path->pathdata.Points[0].X = x + width  / 2.0;
 730         path->pathdata.Points[0].Y = y + height / 2.0;
 731         path->pathdata.Types[0] = PathPointTypeStart | PathPointTypeCloseSubpath;
 732         path->pathdata.Count = 1;
 733         return InvalidParameter;
 734     }
 735
 736     count = arc2polybezier(NULL, x, y, width, height, startAngle, sweepAngle);
 737
 738     if(count == 0)
 739         return Ok;
 740
 741     ptf = GdipAlloc(sizeof(GpPointF)*count);
 742     if(!ptf)
 743         return OutOfMemory;
 744
 745     arc2polybezier(ptf, x, y, width, height, startAngle, sweepAngle);
 746
 747     status = GdipAddPathLine(path, x + width/2, y + height/2, ptf[0].X, ptf[0].Y);
 748     if(status != Ok){
 749         GdipFree(ptf);
 750         return status;
 751     }
 752     /* one spline is already added as a line endpoint */
 753     if(!lengthen_path(path, count - 1)){
 754         GdipFree(ptf);
 755         return OutOfMemory;
 756     }
 757
 758     memcpy(&(path->pathdata.Points[path->pathdata.Count]), &(ptf[1]),sizeof(GpPointF)*(count-1));
 759     for(i = 0; i < count-1; i++)
 760         path->pathdata.Types[path->pathdata.Count+i] = PathPointTypeBezier;
 761
 762     path->pathdata.Count += count-1;
 763
 764     GdipClosePathFigure(path);
 765
 766     GdipFree(ptf);
 767
 768     return status;
 769 }
 770
 771 GpStatus WINGDIPAPI GdipAddPathPieI(GpPath *path, INT x, INT y, INT width, INT height,
 772     REAL startAngle, REAL sweepAngle)
 773 {
 774     TRACE("(%p, %d, %d, %d, %d, %.2f, %.2f)\n",
 775           path, x, y, width, height, startAngle, sweepAngle);
 776
 777     return GdipAddPathPie(path, (REAL)x, (REAL)y, (REAL)width, (REAL)height, startAngle, sweepAngle);
 778 }
 779
 780 GpStatus WINGDIPAPI GdipAddPathPolygon(GpPath *path, GDIPCONST GpPointF *points, INT count)
 781 {
 782     INT old_count;
 783
 784     TRACE("(%p, %p, %d)\n", path, points, count);
 785
 786     if(!path || !points || count < 3)
 787         return InvalidParameter;
 788
 789     if(!lengthen_path(path, count))
 790         return OutOfMemory;
 791
 792     old_count = path->pathdata.Count;
 793
 794     memcpy(&path->pathdata.Points[old_count], points, count*sizeof(GpPointF));
 795     memset(&path->pathdata.Types[old_count + 1], PathPointTypeLine, count - 1);
 796
 797     /* A polygon is an intrinsic figure */
 798     path->pathdata.Types[old_count] = PathPointTypeStart;
 799     path->pathdata.Types[old_count + count - 1] |= PathPointTypeCloseSubpath;
 800     path->newfigure = TRUE;
 801     path->pathdata.Count += count;
 802
 803     return Ok;
 804 }
 805
 806 GpStatus WINGDIPAPI GdipAddPathPolygonI(GpPath *path, GDIPCONST GpPoint *points, INT count)
 807 {
 808     GpPointF *ptf;
 809     GpStatus status;
 810     INT i;
 811
 812     TRACE("(%p, %p, %d)\n", path, points, count);
 813
 814     if(!points || count < 3)
 815         return InvalidParameter;
 816
 817     ptf = GdipAlloc(sizeof(GpPointF) * count);
 818     if(!ptf)
 819         return OutOfMemory;
 820
 821     for(i = 0; i < count; i++){
 822         ptf[i].X = (REAL)points[i].X;
 823         ptf[i].Y = (REAL)points[i].Y;
 824     }
 825
 826     status = GdipAddPathPolygon(path, ptf, count);
 827
 828     GdipFree(ptf);
 829
 830     return status;
 831 }
 832
 833 static float fromfixedpoint(const FIXED v)
 834 {
 835     float f = ((float)v.fract) / (1<<(sizeof(v.fract)*8));
 836     f += v.value;
 837     return f;
 838 }
 839
 840 struct format_string_args
 841 {
 842     GpPath *path;
 843     float maxY;
 844     float scale;
 845     float ascent;
 846 };
 847
 848 static GpStatus format_string_callback(HDC dc,
 849     GDIPCONST WCHAR *string, INT index, INT length, GDIPCONST GpFont *font,
 850     GDIPCONST RectF *rect, GDIPCONST GpStringFormat *format,
 851     INT lineno, const RectF *bounds, INT *underlined_indexes,
 852     INT underlined_index_count, void *priv)
 853 {
 854     static const MAT2 identity = { {0,1}, {0,0}, {0,0}, {0,1} };
 855     struct format_string_args *args = priv;
 856     GpPath *path = args->path;
 857     GpStatus status = Ok;
 858     float x = rect->X + (bounds->X - rect->X) * args->scale;
 859     float y = rect->Y + (bounds->Y - rect->Y) * args->scale;
 860     int i;
 861
 862     if (underlined_index_count)
 863         FIXME("hotkey underlines not drawn yet\n");
 864
 865     if (y + bounds->Height * args->scale > args->maxY)
 866         args->maxY = y + bounds->Height * args->scale;
 867
 868     for (i = index; i < length; ++i)
 869     {
 870         GLYPHMETRICS gm;
 871         TTPOLYGONHEADER *ph = NULL, *origph;
 872         char *start;
 873         DWORD len, ofs = 0;
 874         len = GetGlyphOutlineW(dc, string[i], GGO_BEZIER, &gm, 0, NULL, &identity);
 875         if (len == GDI_ERROR)
 876         {
 877             status = GenericError;
 878             break;
 879         }
 880         origph = ph = GdipAlloc(len);
 881         start = (char *)ph;
 882         if (!ph || !lengthen_path(path, len / sizeof(POINTFX)))
 883         {
 884             status = OutOfMemory;
 885             break;
 886         }
 887         GetGlyphOutlineW(dc, string[i], GGO_BEZIER, &gm, len, start, &identity);
 888
 889         ofs = 0;
 890         while (ofs < len)
 891         {
 892             DWORD ofs_start = ofs;
 893             ph = (TTPOLYGONHEADER*)&start[ofs];
 894             path->pathdata.Types[path->pathdata.Count] = PathPointTypeStart;
 895             path->pathdata.Points[path->pathdata.Count].X = x + fromfixedpoint(ph->pfxStart.x) * args->scale;
 896             path->pathdata.Points[path->pathdata.Count++].Y = y + args->ascent - fromfixedpoint(ph->pfxStart.y) * args->scale;
 897             TRACE("Starting at count %i with pos %f, %f)\n", path->pathdata.Count, x, y);
 898             ofs += sizeof(*ph);
 899             while (ofs - ofs_start < ph->cb)
 900             {
 901                 TTPOLYCURVE *curve = (TTPOLYCURVE*)&start[ofs];
 902                 int j;
 903                 ofs += sizeof(TTPOLYCURVE) + (curve->cpfx - 1) * sizeof(POINTFX);
 904
 905                 switch (curve->wType)
 906                 {
 907                 case TT_PRIM_LINE:
 908                     for (j = 0; j < curve->cpfx; ++j)
 909                     {
 910                         path->pathdata.Types[path->pathdata.Count] = PathPointTypeLine;
 911                         path->pathdata.Points[path->pathdata.Count].X = x + fromfixedpoint(curve->apfx[j].x) * args->scale;
 912                         path->pathdata.Points[path->pathdata.Count++].Y = y + args->ascent - fromfixedpoint(curve->apfx[j].y) * args->scale;
 913                     }
 914                     break;
 915                 case TT_PRIM_CSPLINE:
 916                     for (j = 0; j < curve->cpfx; ++j)
 917                     {
 918                         path->pathdata.Types[path->pathdata.Count] = PathPointTypeBezier;
 919                         path->pathdata.Points[path->pathdata.Count].X = x + fromfixedpoint(curve->apfx[j].x) * args->scale;
 920                         path->pathdata.Points[path->pathdata.Count++].Y = y + args->ascent - fromfixedpoint(curve->apfx[j].y) * args->scale;
 921                     }
 922                     break;
 923                 default:
 924                     ERR("Unhandled type: %u\n", curve->wType);
 925                     status = GenericError;
 926                 }
 927             }
 928             path->pathdata.Types[path->pathdata.Count - 1] |= PathPointTypeCloseSubpath;
 929         }
 930         path->newfigure = TRUE;
 931         x += gm.gmCellIncX * args->scale;
 932         y += gm.gmCellIncY * args->scale;
 933
 934         GdipFree(origph);
 935         if (status != Ok)
 936             break;
 937     }
 938
 939     return status;
 940 }
 941
 942 GpStatus WINGDIPAPI GdipAddPathString(GpPath* path, GDIPCONST WCHAR* string, INT length, GDIPCONST GpFontFamily* family, INT style, REAL emSize, GDIPCONST RectF* layoutRect, GDIPCONST GpStringFormat* format)
 943 {
 944     GpFont *font;
 945     GpStatus status;
 946     LOGFONTW lfw;
 947     HANDLE hfont;
 948     HDC dc;
 949     GpGraphics *graphics;
 950     GpPath *backup;
 951     struct format_string_args args;
 952     int i;
 953     UINT16 native_height;
 954     RectF scaled_layout_rect;
 955     TEXTMETRICW textmetric;
 956
 957     TRACE("(%p, %s, %d, %p, %d, %f, %p, %p)\n", path, debugstr_w(string), length, family, style, emSize, layoutRect, format);
 958     if (!path || !string || !family || !emSize || !layoutRect || !format)
 959         return InvalidParameter;
 960
 961     status = GdipGetEmHeight(family, style, &native_height);
 962     if (status != Ok)
 963         return status;
 964
 965     scaled_layout_rect.X = layoutRect->X;
 966     scaled_layout_rect.Y = layoutRect->Y;
 967     scaled_layout_rect.Width = layoutRect->Width * native_height / emSize;
 968     scaled_layout_rect.Height = layoutRect->Height * native_height / emSize;
 969
 970     if ((status = GdipClonePath(path, &backup)) != Ok)
 971         return status;
 972
 973     dc = CreateCompatibleDC(0);
 974     status = GdipCreateFromHDC(dc, &graphics);
 975     if (status != Ok)
 976     {
 977         DeleteDC(dc);
 978         GdipDeletePath(backup);
 979         return status;
 980     }
 981
 982     status = GdipCreateFont(family, native_height, style, UnitPixel, &font);
 983     if (status != Ok)
 984     {
 985         GdipDeleteGraphics(graphics);
 986         DeleteDC(dc);
 987         GdipDeletePath(backup);
 988         return status;
 989     }
 990
 991     get_log_fontW(font, graphics, &lfw);
 992     GdipDeleteFont(font);
 993     GdipDeleteGraphics(graphics);
 994
 995     hfont = CreateFontIndirectW(&lfw);
 996     if (!hfont)
 997     {
 998         WARN("Failed to create font\n");
 999         DeleteDC(dc);
1000         GdipDeletePath(backup);
1001         return GenericError;
1002     }
1003
1004     SelectObject(dc, hfont);
1005
1006     GetTextMetricsW(dc, &textmetric);
1007
1008     args.path = path;
1009     args.maxY = 0;
1010     args.scale = emSize / native_height;
1011     args.ascent = textmetric.tmAscent * args.scale;
1012     status = gdip_format_string(dc, string, length, NULL, &scaled_layout_rect,
1013                                 format, TRUE, format_string_callback, &args);
1014
1015     DeleteDC(dc);
1016     DeleteObject(hfont);
1017
1018     if (status != Ok) /* free backup */
1019     {
1020         GdipFree(path->pathdata.Points);
1021         GdipFree(path->pathdata.Types);
1022         *path = *backup;
1023         GdipFree(backup);
1024         return status;
1025     }
1026     if (format && format->vertalign == StringAlignmentCenter && layoutRect->Y + args.maxY < layoutRect->Height)
1027     {
1028         float inc = layoutRect->Height + layoutRect->Y - args.maxY;
1029         inc /= 2;
1030         for (i = backup->pathdata.Count; i < path->pathdata.Count; ++i)
1031             path->pathdata.Points[i].Y += inc;
1032     } else if (format && format->vertalign == StringAlignmentFar) {
1033         float inc = layoutRect->Height + layoutRect->Y - args.maxY;
1034         for (i = backup->pathdata.Count; i < path->pathdata.Count; ++i)
1035             path->pathdata.Points[i].Y += inc;
1036     }
1037     GdipDeletePath(backup);
1038     return status;
1039 }
1040
1041 GpStatus WINGDIPAPI GdipAddPathStringI(GpPath* path, GDIPCONST WCHAR* string, INT length, GDIPCONST GpFontFamily* family, INT style, REAL emSize, GDIPCONST Rect* layoutRect, GDIPCONST GpStringFormat* format)
1042 {
1043     if (layoutRect)
1044     {
1045         RectF layoutRectF = {
1046             (REAL)layoutRect->X,
1047             (REAL)layoutRect->Y,
1048             (REAL)layoutRect->Width,
1049             (REAL)layoutRect->Height
1050         };
1051         return GdipAddPathString(path, string, length, family, style, emSize, &layoutRectF, format);
1052     }
1053     return InvalidParameter;
1054 }
1055
1056 GpStatus WINGDIPAPI GdipClonePath(GpPath* path, GpPath **clone)
1057 {
1058     TRACE("(%p, %p)\n", path, clone);
1059
1060     if(!path || !clone)
1061         return InvalidParameter;
1062
1063     *clone = GdipAlloc(sizeof(GpPath));
1064     if(!*clone) return OutOfMemory;
1065
1066     **clone = *path;
1067
1068     (*clone)->pathdata.Points = GdipAlloc(path->datalen * sizeof(PointF));
1069     (*clone)->pathdata.Types = GdipAlloc(path->datalen);
1070     if(!(*clone)->pathdata.Points || !(*clone)->pathdata.Types){
1071         GdipFree((*clone)->pathdata.Points);
1072         GdipFree((*clone)->pathdata.Types);
1073         GdipFree(*clone);
1074         return OutOfMemory;
1075     }
1076
1077     memcpy((*clone)->pathdata.Points, path->pathdata.Points,
1078            path->datalen * sizeof(PointF));
1079     memcpy((*clone)->pathdata.Types, path->pathdata.Types, path->datalen);
1080
1081     return Ok;
1082 }
1083
1084 GpStatus WINGDIPAPI GdipClosePathFigure(GpPath* path)
1085 {
1086     TRACE("(%p)\n", path);
1087
1088     if(!path)
1089         return InvalidParameter;
1090
1091     if(path->pathdata.Count > 0){
1092         path->pathdata.Types[path->pathdata.Count - 1] |= PathPointTypeCloseSubpath;
1093         path->newfigure = TRUE;
1094     }
1095
1096     return Ok;
1097 }
1098
1099 GpStatus WINGDIPAPI GdipClosePathFigures(GpPath* path)
1100 {
1101     INT i;
1102
1103     TRACE("(%p)\n", path);
1104
1105     if(!path)
1106         return InvalidParameter;
1107
1108     for(i = 1; i < path->pathdata.Count; i++){
1109         if(path->pathdata.Types[i] == PathPointTypeStart)
1110             path->pathdata.Types[i-1] |= PathPointTypeCloseSubpath;
1111     }
1112
1113     path->newfigure = TRUE;
1114
1115     return Ok;
1116 }
1117
1118 GpStatus WINGDIPAPI GdipCreatePath(GpFillMode fill, GpPath **path)
1119 {
1120     TRACE("(%d, %p)\n", fill, path);
1121
1122     if(!path)
1123         return InvalidParameter;
1124
1125     *path = GdipAlloc(sizeof(GpPath));
1126     if(!*path)  return OutOfMemory;
1127
1128     (*path)->fill = fill;
1129     (*path)->newfigure = TRUE;
1130
1131     return Ok;
1132 }
1133
1134 GpStatus WINGDIPAPI GdipCreatePath2(GDIPCONST GpPointF* points,
1135     GDIPCONST BYTE* types, INT count, GpFillMode fill, GpPath **path)
1136 {
1137     TRACE("(%p, %p, %d, %d, %p)\n", points, types, count, fill, path);
1138
1139     if(!path)
1140         return InvalidParameter;
1141
1142     *path = GdipAlloc(sizeof(GpPath));
1143     if(!*path)  return OutOfMemory;
1144
1145     (*path)->pathdata.Points = GdipAlloc(count * sizeof(PointF));
1146     (*path)->pathdata.Types = GdipAlloc(count);
1147
1148     if(!(*path)->pathdata.Points || !(*path)->pathdata.Types){
1149         GdipFree((*path)->pathdata.Points);
1150         GdipFree((*path)->pathdata.Types);
1151         GdipFree(*path);
1152         return OutOfMemory;
1153     }
1154
1155     memcpy((*path)->pathdata.Points, points, count * sizeof(PointF));
1156     memcpy((*path)->pathdata.Types, types, count);
1157     (*path)->pathdata.Count = count;
1158     (*path)->datalen = count;
1159
1160     (*path)->fill = fill;
1161     (*path)->newfigure = TRUE;
1162
1163     return Ok;
1164 }
1165
1166 GpStatus WINGDIPAPI GdipCreatePath2I(GDIPCONST GpPoint* points,
1167     GDIPCONST BYTE* types, INT count, GpFillMode fill, GpPath **path)
1168 {
1169     GpPointF *ptF;
1170     GpStatus ret;
1171     INT i;
1172
1173     TRACE("(%p, %p, %d, %d, %p)\n", points, types, count, fill, path);
1174
1175     ptF = GdipAlloc(sizeof(GpPointF)*count);
1176
1177     for(i = 0;i < count; i++){
1178         ptF[i].X = (REAL)points[i].X;
1179         ptF[i].Y = (REAL)points[i].Y;
1180     }
1181
1182     ret = GdipCreatePath2(ptF, types, count, fill, path);
1183
1184     GdipFree(ptF);
1185
1186     return ret;
1187 }
1188
1189 GpStatus WINGDIPAPI GdipDeletePath(GpPath *path)
1190 {
1191     TRACE("(%p)\n", path);
1192
1193     if(!path)
1194         return InvalidParameter;
1195
1196     GdipFree(path->pathdata.Points);
1197     GdipFree(path->pathdata.Types);
1198     GdipFree(path);
1199
1200     return Ok;
1201 }
1202
1203 GpStatus WINGDIPAPI GdipFlattenPath(GpPath *path, GpMatrix* matrix, REAL flatness)
1204 {
1205     path_list_node_t *list, *node;
1206     GpPointF pt;
1207     INT i = 1;
1208     INT startidx = 0;
1209     GpStatus stat;
1210
1211     TRACE("(%p, %p, %.2f)\n", path, matrix, flatness);
1212
1213     if(!path)
1214         return InvalidParameter;
1215
1216     if(path->pathdata.Count == 0)
1217         return Ok;
1218
1219     if(matrix){
1220         stat = GdipTransformPath(path, matrix);
1221         if (stat != Ok)
1222             return stat;
1223     }
1224
1225     pt = path->pathdata.Points[0];
1226     if(!init_path_list(&list, pt.X, pt.Y))
1227         return OutOfMemory;
1228
1229     node = list;
1230
1231     while(i < path->pathdata.Count){
1232
1233         BYTE type = path->pathdata.Types[i] & PathPointTypePathTypeMask;
1234         path_list_node_t *start;
1235
1236         pt = path->pathdata.Points[i];
1237
1238         /* save last start point index */
1239         if(type == PathPointTypeStart)
1240             startidx = i;
1241
1242         /* always add line points and start points */
1243         if((type == PathPointTypeStart) || (type == PathPointTypeLine)){
1244             if(!add_path_list_node(node, pt.X, pt.Y, path->pathdata.Types[i]))
1245                 goto memout;
1246
1247             node = node->next;
1248             ++i;
1249             continue;
1250         }
1251
1252         /* Bezier curve */
1253
1254         /* test for closed figure */
1255         if(path->pathdata.Types[i+1] & PathPointTypeCloseSubpath){
1256             pt = path->pathdata.Points[startidx];
1257             ++i;
1258         }
1259         else
1260         {
1261             i += 2;
1262             pt = path->pathdata.Points[i];
1263         };
1264
1265         start = node;
1266         /* add Bezier end point */
1267         type = (path->pathdata.Types[i] & ~PathPointTypePathTypeMask) | PathPointTypeLine;
1268         if(!add_path_list_node(node, pt.X, pt.Y, type))
1269             goto memout;
1270         node = node->next;
1271
1272         /* flatten curve */
1273         if(!flatten_bezier(start, path->pathdata.Points[i-2].X, path->pathdata.Points[i-2].Y,
1274                                   path->pathdata.Points[i-1].X, path->pathdata.Points[i-1].Y,
1275                            node, flatness))
1276             goto memout;
1277
1278         ++i;
1279     }/* while */
1280
1281     /* store path data back */
1282     i = path_list_count(list);
1283     if(!lengthen_path(path, i))
1284         goto memout;
1285     path->pathdata.Count = i;
1286
1287     node = list;
1288     for(i = 0; i < path->pathdata.Count; i++){
1289         path->pathdata.Points[i] = node->pt;
1290         path->pathdata.Types[i]  = node->type;
1291         node = node->next;
1292     }
1293
1294     free_path_list(list);
1295     return Ok;
1296
1297 memout:
1298     free_path_list(list);
1299     return OutOfMemory;
1300 }
1301
1302 GpStatus WINGDIPAPI GdipGetPathData(GpPath *path, GpPathData* pathData)
1303 {
1304     TRACE("(%p, %p)\n", path, pathData);
1305
1306     if(!path || !pathData)
1307         return InvalidParameter;
1308
1309     /* Only copy data. pathData allocation/freeing controlled by wrapper class.
1310        Assumed that pathData is enough wide to get all data - controlled by wrapper too. */
1311     memcpy(pathData->Points, path->pathdata.Points, sizeof(PointF) * pathData->Count);
1312     memcpy(pathData->Types , path->pathdata.Types , pathData->Count);
1313
1314     return Ok;
1315 }
1316
1317 GpStatus WINGDIPAPI GdipGetPathFillMode(GpPath *path, GpFillMode *fillmode)
1318 {
1319     TRACE("(%p, %p)\n", path, fillmode);
1320
1321     if(!path || !fillmode)
1322         return InvalidParameter;
1323
1324     *fillmode = path->fill;
1325
1326     return Ok;
1327 }
1328
1329 GpStatus WINGDIPAPI GdipGetPathLastPoint(GpPath* path, GpPointF* lastPoint)
1330 {
1331     INT count;
1332
1333     TRACE("(%p, %p)\n", path, lastPoint);
1334
1335     if(!path || !lastPoint)
1336         return InvalidParameter;
1337
1338     count = path->pathdata.Count;
1339     if(count > 0)
1340         *lastPoint = path->pathdata.Points[count-1];
1341
1342     return Ok;
1343 }
1344
1345 GpStatus WINGDIPAPI GdipGetPathPoints(GpPath *path, GpPointF* points, INT count)
1346 {
1347     TRACE("(%p, %p, %d)\n", path, points, count);
1348
1349     if(!path)
1350         return InvalidParameter;
1351
1352     if(count < path->pathdata.Count)
1353         return InsufficientBuffer;
1354
1355     memcpy(points, path->pathdata.Points, path->pathdata.Count * sizeof(GpPointF));
1356
1357     return Ok;
1358 }
1359
1360 GpStatus WINGDIPAPI GdipGetPathPointsI(GpPath *path, GpPoint* points, INT count)
1361 {
1362     GpStatus ret;
1363     GpPointF *ptf;
1364     INT i;
1365
1366     TRACE("(%p, %p, %d)\n", path, points, count);
1367
1368     if(count <= 0)
1369         return InvalidParameter;
1370
1371     ptf = GdipAlloc(sizeof(GpPointF)*count);
1372     if(!ptf)    return OutOfMemory;
1373
1374     ret = GdipGetPathPoints(path,ptf,count);
1375     if(ret == Ok)
1376         for(i = 0;i < count;i++){
1377             points[i].X = gdip_round(ptf[i].X);
1378             points[i].Y = gdip_round(ptf[i].Y);
1379         };
1380     GdipFree(ptf);
1381
1382     return ret;
1383 }
1384
1385 GpStatus WINGDIPAPI GdipGetPathTypes(GpPath *path, BYTE* types, INT count)
1386 {
1387     TRACE("(%p, %p, %d)\n", path, types, count);
1388
1389     if(!path)
1390         return InvalidParameter;
1391
1392     if(count < path->pathdata.Count)
1393         return InsufficientBuffer;
1394
1395     memcpy(types, path->pathdata.Types, path->pathdata.Count);
1396
1397     return Ok;
1398 }
1399
1400 /* Windows expands the bounding box to the maximum possible bounding box
1401  * for a given pen.  For example, if a line join can extend past the point
1402  * it's joining by x units, the bounding box is extended by x units in every
1403  * direction (even though this is too conservative for most cases). */
1404 GpStatus WINGDIPAPI GdipGetPathWorldBounds(GpPath* path, GpRectF* bounds,
1405     GDIPCONST GpMatrix *matrix, GDIPCONST GpPen *pen)
1406 {
1407     GpPointF * points, temp_pts[4];
1408     INT count, i;
1409     REAL path_width = 1.0, width, height, temp, low_x, low_y, high_x, high_y;
1410
1411     TRACE("(%p, %p, %p, %p)\n", path, bounds, matrix, pen);
1412
1413     /* Matrix and pen can be null. */
1414     if(!path || !bounds)
1415         return InvalidParameter;
1416
1417     /* If path is empty just return. */
1418     count = path->pathdata.Count;
1419     if(count == 0){
1420         bounds->X = bounds->Y = bounds->Width = bounds->Height = 0.0;
1421         return Ok;
1422     }
1423
1424     points = path->pathdata.Points;
1425
1426     low_x = high_x = points[0].X;
1427     low_y = high_y = points[0].Y;
1428
1429     for(i = 1; i < count; i++){
1430         low_x = min(low_x, points[i].X);
1431         low_y = min(low_y, points[i].Y);
1432         high_x = max(high_x, points[i].X);
1433         high_y = max(high_y, points[i].Y);
1434     }
1435
1436     width = high_x - low_x;
1437     height = high_y - low_y;
1438
1439     /* This looks unusual but it's the only way I can imitate windows. */
1440     if(matrix){
1441         temp_pts[0].X = low_x;
1442         temp_pts[0].Y = low_y;
1443         temp_pts[1].X = low_x;
1444         temp_pts[1].Y = high_y;
1445         temp_pts[2].X = high_x;
1446         temp_pts[2].Y = high_y;
1447         temp_pts[3].X = high_x;
1448         temp_pts[3].Y = low_y;
1449
1450         GdipTransformMatrixPoints((GpMatrix*)matrix, temp_pts, 4);
1451         low_x = temp_pts[0].X;
1452         low_y = temp_pts[0].Y;
1453
1454         for(i = 1; i < 4; i++){
1455             low_x = min(low_x, temp_pts[i].X);
1456             low_y = min(low_y, temp_pts[i].Y);
1457         }
1458
1459         temp = width;
1460         width = height * fabs(matrix->matrix[2]) + width * fabs(matrix->matrix[0]);
1461         height = height * fabs(matrix->matrix[3]) + temp * fabs(matrix->matrix[1]);
1462     }
1463
1464     if(pen){
1465         path_width = pen->width / 2.0;
1466
1467         if(count > 2)
1468             path_width = max(path_width,  pen->width * pen->miterlimit / 2.0);
1469         /* FIXME: this should probably also check for the startcap */
1470         if(pen->endcap & LineCapNoAnchor)
1471             path_width = max(path_width,  pen->width * 2.2);
1472
1473         low_x -= path_width;
1474         low_y -= path_width;
1475         width += 2.0 * path_width;
1476         height += 2.0 * path_width;
1477     }
1478
1479     bounds->X = low_x;
1480     bounds->Y = low_y;
1481     bounds->Width = width;
1482     bounds->Height = height;
1483
1484     return Ok;
1485 }
1486
1487 GpStatus WINGDIPAPI GdipGetPathWorldBoundsI(GpPath* path, GpRect* bounds,
1488     GDIPCONST GpMatrix *matrix, GDIPCONST GpPen *pen)
1489 {
1490     GpStatus ret;
1491     GpRectF boundsF;
1492
1493     TRACE("(%p, %p, %p, %p)\n", path, bounds, matrix, pen);
1494
1495     ret = GdipGetPathWorldBounds(path,&boundsF,matrix,pen);
1496
1497     if(ret == Ok){
1498         bounds->X      = gdip_round(boundsF.X);
1499         bounds->Y      = gdip_round(boundsF.Y);
1500         bounds->Width  = gdip_round(boundsF.Width);
1501         bounds->Height = gdip_round(boundsF.Height);
1502     }
1503
1504     return ret;
1505 }
1506
1507 GpStatus WINGDIPAPI GdipGetPointCount(GpPath *path, INT *count)
1508 {
1509     TRACE("(%p, %p)\n", path, count);
1510
1511     if(!path)
1512         return InvalidParameter;
1513
1514     *count = path->pathdata.Count;
1515
1516     return Ok;
1517 }
1518
1519 GpStatus WINGDIPAPI GdipReversePath(GpPath* path)
1520 {
1521     INT i, count;
1522     INT start = 0; /* position in reversed path */
1523     GpPathData revpath;
1524
1525     TRACE("(%p)\n", path);
1526
1527     if(!path)
1528         return InvalidParameter;
1529
1530     count = path->pathdata.Count;
1531
1532     if(count == 0) return Ok;
1533
1534     revpath.Points = GdipAlloc(sizeof(GpPointF)*count);
1535     revpath.Types  = GdipAlloc(sizeof(BYTE)*count);
1536     revpath.Count  = count;
1537     if(!revpath.Points || !revpath.Types){
1538         GdipFree(revpath.Points);
1539         GdipFree(revpath.Types);
1540         return OutOfMemory;
1541     }
1542
1543     for(i = 0; i < count; i++){
1544
1545         /* find next start point */
1546         if(path->pathdata.Types[count-i-1] == PathPointTypeStart){
1547             INT j;
1548             for(j = start; j <= i; j++){
1549                 revpath.Points[j] = path->pathdata.Points[count-j-1];
1550                 revpath.Types[j] = path->pathdata.Types[count-j-1];
1551             }
1552             /* mark start point */
1553             revpath.Types[start] = PathPointTypeStart;
1554             /* set 'figure' endpoint type */
1555             if(i-start > 1){
1556                 revpath.Types[i] = path->pathdata.Types[count-start-1] & ~PathPointTypePathTypeMask;
1557                 revpath.Types[i] |= revpath.Types[i-1];
1558             }
1559             else
1560                 revpath.Types[i] = path->pathdata.Types[start];
1561
1562             start = i+1;
1563         }
1564     }
1565
1566     memcpy(path->pathdata.Points, revpath.Points, sizeof(GpPointF)*count);
1567     memcpy(path->pathdata.Types,  revpath.Types,  sizeof(BYTE)*count);
1568
1569     GdipFree(revpath.Points);
1570     GdipFree(revpath.Types);
1571
1572     return Ok;
1573 }
1574
1575 GpStatus WINGDIPAPI GdipIsOutlineVisiblePathPointI(GpPath* path, INT x, INT y,
1576     GpPen *pen, GpGraphics *graphics, BOOL *result)
1577 {
1578     TRACE("(%p, %d, %d, %p, %p, %p)\n", path, x, y, pen, graphics, result);
1579
1580     return GdipIsOutlineVisiblePathPoint(path, x, y, pen, graphics, result);
1581 }
1582
1583 GpStatus WINGDIPAPI GdipIsOutlineVisiblePathPoint(GpPath* path, REAL x, REAL y,
1584     GpPen *pen, GpGraphics *graphics, BOOL *result)
1585 {
1586     static int calls;
1587
1588     TRACE("(%p,%0.2f,%0.2f,%p,%p,%p)\n", path, x, y, pen, graphics, result);
1589
1590     if(!path || !pen)
1591         return InvalidParameter;
1592
1593     if(!(calls++))
1594         FIXME("not implemented\n");
1595
1596     return NotImplemented;
1597 }
1598
1599 GpStatus WINGDIPAPI GdipIsVisiblePathPointI(GpPath* path, INT x, INT y, GpGraphics *graphics, BOOL *result)
1600 {
1601     TRACE("(%p, %d, %d, %p, %p)\n", path, x, y, graphics, result);
1602
1603     return GdipIsVisiblePathPoint(path, x, y, graphics, result);
1604 }
1605
1606 /*****************************************************************************
1607  * GdipIsVisiblePathPoint [GDIPLUS.@]
1608  */
1609 GpStatus WINGDIPAPI GdipIsVisiblePathPoint(GpPath* path, REAL x, REAL y, GpGraphics *graphics, BOOL *result)
1610 {
1611     GpRegion *region;
1612     HRGN hrgn;
1613     GpStatus status;
1614
1615     if(!path || !result) return InvalidParameter;
1616
1617     status = GdipCreateRegionPath(path, &region);
1618     if(status != Ok)
1619         return status;
1620
1621     status = GdipGetRegionHRgn(region, graphics, &hrgn);
1622     if(status != Ok){
1623         GdipDeleteRegion(region);
1624         return status;
1625     }
1626
1627     *result = PtInRegion(hrgn, gdip_round(x), gdip_round(y));
1628
1629     DeleteObject(hrgn);
1630     GdipDeleteRegion(region);
1631
1632     return Ok;
1633 }
1634
1635 GpStatus WINGDIPAPI GdipStartPathFigure(GpPath *path)
1636 {
1637     TRACE("(%p)\n", path);
1638
1639     if(!path)
1640         return InvalidParameter;
1641
1642     path->newfigure = TRUE;
1643
1644     return Ok;
1645 }
1646
1647 GpStatus WINGDIPAPI GdipResetPath(GpPath *path)
1648 {
1649     TRACE("(%p)\n", path);
1650
1651     if(!path)
1652         return InvalidParameter;
1653
1654     path->pathdata.Count = 0;
1655     path->newfigure = TRUE;
1656     path->fill = FillModeAlternate;
1657
1658     return Ok;
1659 }
1660
1661 GpStatus WINGDIPAPI GdipSetPathFillMode(GpPath *path, GpFillMode fill)
1662 {
1663     TRACE("(%p, %d)\n", path, fill);
1664
1665     if(!path)
1666         return InvalidParameter;
1667
1668     path->fill = fill;
1669
1670     return Ok;
1671 }
1672
1673 GpStatus WINGDIPAPI GdipTransformPath(GpPath *path, GpMatrix *matrix)
1674 {
1675     TRACE("(%p, %p)\n", path, matrix);
1676
1677     if(!path)
1678         return InvalidParameter;
1679
1680     if(path->pathdata.Count == 0)
1681         return Ok;
1682
1683     return GdipTransformMatrixPoints(matrix, path->pathdata.Points,
1684                                      path->pathdata.Count);
1685 }
1686
1687 GpStatus WINGDIPAPI GdipWarpPath(GpPath *path, GpMatrix* matrix,
1688     GDIPCONST GpPointF *points, INT count, REAL x, REAL y, REAL width,
1689     REAL height, WarpMode warpmode, REAL flatness)
1690 {
1691     FIXME("(%p,%p,%p,%i,%0.2f,%0.2f,%0.2f,%0.2f,%i,%0.2f)\n", path, matrix,
1692         points, count, x, y, width, height, warpmode, flatness);
1693
1694     return NotImplemented;
1695 }
1696
1697 static void add_bevel_point(const GpPointF *endpoint, const GpPointF *nextpoint,
1698     GpPen *pen, int right_side, path_list_node_t **last_point)
1699 {
1700     REAL segment_dy = nextpoint->Y-endpoint->Y;
1701     REAL segment_dx = nextpoint->X-endpoint->X;
1702     REAL segment_length = sqrtf(segment_dy*segment_dy + segment_dx*segment_dx);
1703     REAL distance = pen->width/2.0;
1704     REAL bevel_dx, bevel_dy;
1705
1706     if (segment_length == 0.0)
1707     {
1708         *last_point = add_path_list_node(*last_point, endpoint->X,
1709             endpoint->Y, PathPointTypeLine);
1710         return;
1711     }
1712
1713     if (right_side)
1714     {
1715         bevel_dx = -distance * segment_dy / segment_length;
1716         bevel_dy = distance * segment_dx / segment_length;
1717     }
1718     else
1719     {
1720         bevel_dx = distance * segment_dy / segment_length;
1721         bevel_dy = -distance * segment_dx / segment_length;
1722     }
1723
1724     *last_point = add_path_list_node(*last_point, endpoint->X + bevel_dx,
1725         endpoint->Y + bevel_dy, PathPointTypeLine);
1726 }
1727
1728 static void widen_joint(const GpPointF *p1, const GpPointF *p2, const GpPointF *p3,
1729     GpPen* pen, path_list_node_t **last_point)
1730 {
1731     switch (pen->join)
1732     {
1733     case LineJoinMiter:
1734     case LineJoinMiterClipped:
1735         if ((p2->X - p1->X) * (p3->Y - p1->Y) > (p2->Y - p1->Y) * (p3->X - p1->X))
1736         {
1737             float distance = pen->width/2.0;
1738             float length_0 = sqrtf((p2->X-p1->X)*(p2->X-p1->X)+(p2->Y-p1->Y)*(p2->Y-p1->Y));
1739             float length_1 = sqrtf((p3->X-p2->X)*(p3->X-p2->X)+(p3->Y-p2->Y)*(p3->Y-p2->Y));
1740             float dx0 = distance * (p2->X - p1->X) / length_0;
1741             float dy0 = distance * (p2->Y - p1->Y) / length_0;
1742             float dx1 = distance * (p3->X - p2->X) / length_1;
1743             float dy1 = distance * (p3->Y - p2->Y) / length_1;
1744             float det = (dy0*dx1 - dx0*dy1);
1745             float dx = (dx0*dx1*(dx0-dx1) + dy0*dy0*dx1 - dy1*dy1*dx0)/det;
1746             float dy = (dy0*dy1*(dy0-dy1) + dx0*dx0*dy1 - dx1*dx1*dy0)/det;
1747             if (dx*dx + dy*dy < pen->miterlimit*pen->miterlimit * distance*distance)
1748             {
1749                 *last_point = add_path_list_node(*last_point, p2->X + dx,
1750                     p2->Y + dy, PathPointTypeLine);
1751                 break;
1752             }
1753             else if (pen->join == LineJoinMiter)
1754             {
1755                 static int once;
1756                 if (!once++)
1757                     FIXME("should add a clipped corner\n");
1758             }
1759             /* else fall-through */
1760         }
1761         /* else fall-through */
1762     default:
1763     case LineJoinBevel:
1764         add_bevel_point(p2, p1, pen, 1, last_point);
1765         add_bevel_point(p2, p3, pen, 0, last_point);
1766         break;
1767     }
1768 }
1769
1770 static void widen_cap(const GpPointF *endpoint, const GpPointF *nextpoint,
1771     GpPen *pen, GpLineCap cap, GpCustomLineCap *custom, int add_first_points,
1772     int add_last_point, path_list_node_t **last_point)
1773 {
1774     switch (cap)
1775     {
1776     default:
1777     case LineCapFlat:
1778         if (add_first_points)
1779             add_bevel_point(endpoint, nextpoint, pen, 1, last_point);
1780         if (add_last_point)
1781             add_bevel_point(endpoint, nextpoint, pen, 0, last_point);
1782         break;
1783     case LineCapSquare:
1784     {
1785         REAL segment_dy = nextpoint->Y-endpoint->Y;
1786         REAL segment_dx = nextpoint->X-endpoint->X;
1787         REAL segment_length = sqrtf(segment_dy*segment_dy + segment_dx*segment_dx);
1788         REAL distance = pen->width/2.0;
1789         REAL bevel_dx, bevel_dy;
1790         REAL extend_dx, extend_dy;
1791
1792         extend_dx = -distance * segment_dx / segment_length;
1793         extend_dy = -distance * segment_dy / segment_length;
1794
1795         bevel_dx = -distance * segment_dy / segment_length;
1796         bevel_dy = distance * segment_dx / segment_length;
1797
1798         if (add_first_points)
1799             *last_point = add_path_list_node(*last_point, endpoint->X + extend_dx + bevel_dx,
1800                 endpoint->Y + extend_dy + bevel_dy, PathPointTypeLine);
1801
1802         if (add_last_point)
1803             *last_point = add_path_list_node(*last_point, endpoint->X + extend_dx - bevel_dx,
1804                 endpoint->Y + extend_dy - bevel_dy, PathPointTypeLine);
1805
1806         break;
1807     }
1808     case LineCapRound:
1809     {
1810         REAL segment_dy = nextpoint->Y-endpoint->Y;
1811         REAL segment_dx = nextpoint->X-endpoint->X;
1812         REAL segment_length = sqrtf(segment_dy*segment_dy + segment_dx*segment_dx);
1813         REAL distance = pen->width/2.0;
1814         REAL dx, dy, dx2, dy2;
1815         const REAL control_point_distance = 0.5522847498307935; /* 4/3 * (sqrt(2) - 1) */
1816
1817         if (add_first_points)
1818         {
1819             dx = -distance * segment_dx / segment_length;
1820             dy = -distance * segment_dy / segment_length;
1821
1822             dx2 = dx * control_point_distance;
1823             dy2 = dy * control_point_distance;
1824
1825             /* first 90-degree arc */
1826             *last_point = add_path_list_node(*last_point, endpoint->X + dy,
1827                 endpoint->Y - dx, PathPointTypeLine);
1828
1829             *last_point = add_path_list_node(*last_point, endpoint->X + dy + dx2,
1830                 endpoint->Y - dx + dy2, PathPointTypeBezier);
1831
1832             *last_point = add_path_list_node(*last_point, endpoint->X + dx + dy2,
1833                 endpoint->Y + dy - dx2, PathPointTypeBezier);
1834
1835             /* midpoint */
1836             *last_point = add_path_list_node(*last_point, endpoint->X + dx,
1837                 endpoint->Y + dy, PathPointTypeBezier);
1838
1839             /* second 90-degree arc */
1840             *last_point = add_path_list_node(*last_point, endpoint->X + dx - dy2,
1841                 endpoint->Y + dy + dx2, PathPointTypeBezier);
1842
1843             *last_point = add_path_list_node(*last_point, endpoint->X - dy + dx2,
1844                 endpoint->Y + dx + dy2, PathPointTypeBezier);
1845
1846             *last_point = add_path_list_node(*last_point, endpoint->X - dy,
1847                 endpoint->Y + dx, PathPointTypeBezier);
1848         }
1849         break;
1850     }
1851     }
1852 }
1853
1854 static void widen_open_figure(const GpPointF *points, GpPen *pen, int start, int end,
1855     GpLineCap start_cap, GpCustomLineCap *start_custom, GpLineCap end_cap,
1856     GpCustomLineCap *end_custom, path_list_node_t **last_point)
1857 {
1858     int i;
1859     path_list_node_t *prev_point;
1860
1861     if (end <= start)
1862         return;
1863
1864     prev_point = *last_point;
1865
1866     widen_cap(&points[start], &points[start+1],
1867         pen, start_cap, start_custom, FALSE, TRUE, last_point);
1868
1869     for (i=start+1; i<end; i++)
1870         widen_joint(&points[i-1], &points[i],
1871             &points[i+1], pen, last_point);
1872
1873     widen_cap(&points[end], &points[end-1],
1874         pen, end_cap, end_custom, TRUE, TRUE, last_point);
1875
1876     for (i=end-1; i>start; i--)
1877         widen_joint(&points[i+1], &points[i],
1878             &points[i-1], pen, last_point);
1879
1880     widen_cap(&points[start], &points[start+1],
1881         pen, start_cap, start_custom, TRUE, FALSE, last_point);
1882
1883     prev_point->next->type = PathPointTypeStart;
1884     (*last_point)->type |= PathPointTypeCloseSubpath;
1885 }
1886
1887 static void widen_closed_figure(GpPath *path, GpPen *pen, int start, int end,
1888     path_list_node_t **last_point)
1889 {
1890     int i;
1891     path_list_node_t *prev_point;
1892
1893     if (end <= start+1)
1894         return;
1895
1896     /* left outline */
1897     prev_point = *last_point;
1898
1899     widen_joint(&path->pathdata.Points[end], &path->pathdata.Points[start],
1900         &path->pathdata.Points[start+1], pen, last_point);
1901
1902     for (i=start+1; i<end; i++)
1903         widen_joint(&path->pathdata.Points[i-1], &path->pathdata.Points[i],
1904             &path->pathdata.Points[i+1], pen, last_point);
1905
1906     widen_joint(&path->pathdata.Points[end-1], &path->pathdata.Points[end],
1907         &path->pathdata.Points[start], pen, last_point);
1908
1909     prev_point->next->type = PathPointTypeStart;
1910     (*last_point)->type |= PathPointTypeCloseSubpath;
1911
1912     /* right outline */
1913     prev_point = *last_point;
1914
1915     widen_joint(&path->pathdata.Points[start], &path->pathdata.Points[end],
1916         &path->pathdata.Points[end-1], pen, last_point);
1917
1918     for (i=end-1; i>start; i--)
1919         widen_joint(&path->pathdata.Points[i+1], &path->pathdata.Points[i],
1920             &path->pathdata.Points[i-1], pen, last_point);
1921
1922     widen_joint(&path->pathdata.Points[start+1], &path->pathdata.Points[start],
1923         &path->pathdata.Points[end], pen, last_point);
1924
1925     prev_point->next->type = PathPointTypeStart;
1926     (*last_point)->type |= PathPointTypeCloseSubpath;
1927 }
1928
1929 static void widen_dashed_figure(GpPath *path, GpPen *pen, int start, int end,
1930     int closed, path_list_node_t **last_point)
1931 {
1932     int i, j;
1933     REAL dash_pos=0.0;
1934     int dash_index=0;
1935     const REAL *dash_pattern;
1936     int dash_count;
1937     GpPointF *tmp_points;
1938     REAL segment_dy;
1939     REAL segment_dx;
1940     REAL segment_length;
1941     REAL segment_pos;
1942     int num_tmp_points=0;
1943     int draw_start_cap=0;
1944     static const REAL dash_dot_dot[6] = { 3.0, 1.0, 1.0, 1.0, 1.0, 1.0 };
1945
1946     if (end <= start)
1947         return;
1948
1949     switch (pen->dash)
1950     {
1951     case DashStyleDash:
1952     default:
1953         dash_pattern = dash_dot_dot;
1954         dash_count = 2;
1955         break;
1956     case DashStyleDot:
1957         dash_pattern = &dash_dot_dot[2];
1958         dash_count = 2;
1959         break;
1960     case DashStyleDashDot:
1961         dash_pattern = dash_dot_dot;
1962         dash_count = 4;
1963         break;
1964     case DashStyleDashDotDot:
1965         dash_pattern = dash_dot_dot;
1966         dash_count = 6;
1967         break;
1968     case DashStyleCustom:
1969         dash_pattern = pen->dashes;
1970         dash_count = pen->numdashes;
1971         break;
1972     }
1973
1974     tmp_points = GdipAlloc((end - start + 2) * sizeof(GpPoint));
1975     if (!tmp_points) return; /* FIXME */
1976
1977     if (!closed)
1978         draw_start_cap = 1;
1979
1980     for (j=start; j <= end; j++)
1981     {
1982         if (j == start)
1983         {
1984             if (closed)
1985                 i = end;
1986             else
1987                 continue;
1988         }
1989         else
1990             i = j-1;
1991
1992         segment_dy = path->pathdata.Points[j].Y - path->pathdata.Points[i].Y;
1993         segment_dx = path->pathdata.Points[j].X - path->pathdata.Points[i].X;
1994         segment_length = sqrtf(segment_dy*segment_dy + segment_dx*segment_dx);
1995         segment_pos = 0.0;
1996
1997         while (1)
1998         {
1999             if (dash_pos == 0.0)
2000             {
2001                 if ((dash_index % 2) == 0)
2002                 {
2003                     /* start dash */
2004                     num_tmp_points = 1;
2005                     tmp_points[0].X = path->pathdata.Points[i].X + segment_dx * segment_pos / segment_length;
2006                     tmp_points[0].Y = path->pathdata.Points[i].Y + segment_dy * segment_pos / segment_length;
2007                 }
2008                 else
2009                 {
2010                     /* end dash */
2011                     tmp_points[num_tmp_points].X = path->pathdata.Points[i].X + segment_dx * segment_pos / segment_length;
2012                     tmp_points[num_tmp_points].Y = path->pathdata.Points[i].Y + segment_dy * segment_pos / segment_length;
2013
2014                     widen_open_figure(tmp_points, pen, 0, num_tmp_points,
2015                         draw_start_cap ? pen->startcap : LineCapFlat, pen->customstart,
2016                         LineCapFlat, NULL, last_point);
2017                     draw_start_cap = 0;
2018                     num_tmp_points = 0;
2019                 }
2020             }
2021
2022             if (dash_pattern[dash_index] - dash_pos > segment_length - segment_pos)
2023             {
2024                 /* advance to next segment */
2025                 if ((dash_index % 2) == 0)
2026                 {
2027                     tmp_points[num_tmp_points] = path->pathdata.Points[j];
2028                     num_tmp_points++;
2029                 }
2030                 dash_pos += segment_length - segment_pos;
2031                 break;
2032             }
2033             else
2034             {
2035                 /* advance to next dash in pattern */
2036                 segment_pos += dash_pattern[dash_index] - dash_pos;
2037                 dash_pos = 0.0;
2038                 if (++dash_index == dash_count)
2039                     dash_index = 0;
2040                 continue;
2041             }
2042         }
2043     }
2044
2045     if (dash_index % 2 == 0 && num_tmp_points != 0)
2046     {
2047         /* last dash overflows last segment */
2048         tmp_points[num_tmp_points] = path->pathdata.Points[end];
2049         widen_open_figure(tmp_points, pen, 0, num_tmp_points,
2050             draw_start_cap ? pen->startcap : LineCapFlat, pen->customstart,
2051             closed ? LineCapFlat : pen->endcap, pen->customend, last_point);
2052     }
2053
2054     GdipFree(tmp_points);
2055 }
2056
2057 GpStatus WINGDIPAPI GdipWidenPath(GpPath *path, GpPen *pen, GpMatrix *matrix,
2058     REAL flatness)
2059 {
2060     GpPath *flat_path=NULL;
2061     GpStatus status;
2062     path_list_node_t *points=NULL, *last_point=NULL;
2063     int i, subpath_start=0, new_length;
2064     BYTE type;
2065
2066     TRACE("(%p,%p,%p,%0.2f)\n", path, pen, matrix, flatness);
2067
2068     if (!path || !pen)
2069         return InvalidParameter;
2070
2071     if (path->pathdata.Count <= 1)
2072         return OutOfMemory;
2073
2074     status = GdipClonePath(path, &flat_path);
2075
2076     if (status == Ok)
2077         status = GdipFlattenPath(flat_path, matrix, flatness);
2078
2079     if (status == Ok && !init_path_list(&points, 314.0, 22.0))
2080         status = OutOfMemory;
2081
2082     if (status == Ok)
2083     {
2084         last_point = points;
2085
2086         if (pen->endcap > LineCapRound)
2087             FIXME("unimplemented end cap %x\n", pen->endcap);
2088
2089         if (pen->startcap > LineCapRound)
2090             FIXME("unimplemented start cap %x\n", pen->startcap);
2091
2092         if (pen->dashcap != DashCapFlat)
2093             FIXME("unimplemented dash cap %d\n", pen->dashcap);
2094
2095         if (pen->join == LineJoinRound)
2096             FIXME("unimplemented line join %d\n", pen->join);
2097
2098         if (pen->align != PenAlignmentCenter)
2099             FIXME("unimplemented pen alignment %d\n", pen->align);
2100
2101         for (i=0; i < flat_path->pathdata.Count; i++)
2102         {
2103             type = flat_path->pathdata.Types[i];
2104
2105             if ((type&PathPointTypePathTypeMask) == PathPointTypeStart)
2106                 subpath_start = i;
2107
2108             if ((type&PathPointTypeCloseSubpath) == PathPointTypeCloseSubpath)
2109             {
2110                 if (pen->dash != DashStyleSolid)
2111                     widen_dashed_figure(flat_path, pen, subpath_start, i, 1, &last_point);
2112                 else
2113                     widen_closed_figure(flat_path, pen, subpath_start, i, &last_point);
2114             }
2115             else if (i == flat_path->pathdata.Count-1 ||
2116                 (flat_path->pathdata.Types[i+1]&PathPointTypePathTypeMask) == PathPointTypeStart)
2117             {
2118                 if (pen->dash != DashStyleSolid)
2119                     widen_dashed_figure(flat_path, pen, subpath_start, i, 0, &last_point);
2120                 else
2121                     widen_open_figure(flat_path->pathdata.Points, pen, subpath_start, i, pen->startcap, pen->customstart, pen->endcap, pen->customend, &last_point);
2122             }
2123         }
2124
2125         new_length = path_list_count(points)-1;
2126
2127         if (!lengthen_path(path, new_length))
2128             status = OutOfMemory;
2129     }
2130
2131     if (status == Ok)
2132     {
2133         path->pathdata.Count = new_length;
2134
2135         last_point = points->next;
2136         for (i = 0; i < new_length; i++)
2137         {
2138             path->pathdata.Points[i] = last_point->pt;
2139             path->pathdata.Types[i] = last_point->type;
2140             last_point = last_point->next;
2141         }
2142
2143         path->fill = FillModeWinding;
2144     }
2145
2146     free_path_list(points);
2147
2148     GdipDeletePath(flat_path);
2149
2150     return status;
2151 }
2152
2153 GpStatus WINGDIPAPI GdipAddPathRectangle(GpPath *path, REAL x, REAL y,
2154     REAL width, REAL height)
2155 {
2156     GpPath *backup;
2157     GpPointF ptf[2];
2158     GpStatus retstat;
2159     BOOL old_new;
2160
2161     TRACE("(%p, %.2f, %.2f, %.2f, %.2f)\n", path, x, y, width, height);
2162
2163     if(!path)
2164         return InvalidParameter;
2165
2166     /* make a backup copy of path data */
2167     if((retstat = GdipClonePath(path, &backup)) != Ok)
2168         return retstat;
2169
2170     /* rectangle should start as new path */
2171     old_new = path->newfigure;
2172     path->newfigure = TRUE;
2173     if((retstat = GdipAddPathLine(path,x,y,x+width,y)) != Ok){
2174         path->newfigure = old_new;
2175         goto fail;
2176     }
2177
2178     ptf[0].X = x+width;
2179     ptf[0].Y = y+height;
2180     ptf[1].X = x;
2181     ptf[1].Y = y+height;
2182
2183     if((retstat = GdipAddPathLine2(path, ptf, 2)) != Ok)  goto fail;
2184     path->pathdata.Types[path->pathdata.Count-1] |= PathPointTypeCloseSubpath;
2185
2186     /* free backup */
2187     GdipDeletePath(backup);
2188     return Ok;
2189
2190 fail:
2191     /* reverting */
2192     GdipFree(path->pathdata.Points);
2193     GdipFree(path->pathdata.Types);
2194     memcpy(path, backup, sizeof(*path));
2195     GdipFree(backup);
2196
2197     return retstat;
2198 }
2199
2200 GpStatus WINGDIPAPI GdipAddPathRectangleI(GpPath *path, INT x, INT y,
2201     INT width, INT height)
2202 {
2203     TRACE("(%p, %d, %d, %d, %d)\n", path, x, y, width, height);
2204
2205     return GdipAddPathRectangle(path,(REAL)x,(REAL)y,(REAL)width,(REAL)height);
2206 }
2207
2208 GpStatus WINGDIPAPI GdipAddPathRectangles(GpPath *path, GDIPCONST GpRectF *rects, INT count)
2209 {
2210     GpPath *backup;
2211     GpStatus retstat;
2212     INT i;
2213
2214     TRACE("(%p, %p, %d)\n", path, rects, count);
2215
2216     /* count == 0 - verified condition  */
2217     if(!path || !rects || count == 0)
2218         return InvalidParameter;
2219
2220     if(count < 0)
2221         return OutOfMemory;
2222
2223     /* make a backup copy */
2224     if((retstat = GdipClonePath(path, &backup)) != Ok)
2225         return retstat;
2226
2227     for(i = 0; i < count; i++){
2228         if((retstat = GdipAddPathRectangle(path,rects[i].X,rects[i].Y,rects[i].Width,rects[i].Height)) != Ok)
2229             goto fail;
2230     }
2231
2232     /* free backup */
2233     GdipDeletePath(backup);
2234     return Ok;
2235
2236 fail:
2237     /* reverting */
2238     GdipFree(path->pathdata.Points);
2239     GdipFree(path->pathdata.Types);
2240     memcpy(path, backup, sizeof(*path));
2241     GdipFree(backup);
2242
2243     return retstat;
2244 }
2245
2246 GpStatus WINGDIPAPI GdipAddPathRectanglesI(GpPath *path, GDIPCONST GpRect *rects, INT count)
2247 {
2248     GpRectF *rectsF;
2249     GpStatus retstat;
2250     INT i;
2251
2252     TRACE("(%p, %p, %d)\n", path, rects, count);
2253
2254     if(!rects || count == 0)
2255         return InvalidParameter;
2256
2257     if(count < 0)
2258         return OutOfMemory;
2259
2260     rectsF = GdipAlloc(sizeof(GpRectF)*count);
2261
2262     for(i = 0;i < count;i++){
2263         rectsF[i].X      = (REAL)rects[i].X;
2264         rectsF[i].Y      = (REAL)rects[i].Y;
2265         rectsF[i].Width  = (REAL)rects[i].Width;
2266         rectsF[i].Height = (REAL)rects[i].Height;
2267     }
2268
2269     retstat = GdipAddPathRectangles(path, rectsF, count);
2270     GdipFree(rectsF);
2271
2272     return retstat;
2273 }
2274
2275 GpStatus WINGDIPAPI GdipSetPathMarker(GpPath* path)
2276 {
2277     INT count;
2278
2279     TRACE("(%p)\n", path);
2280
2281     if(!path)
2282         return InvalidParameter;
2283
2284     count = path->pathdata.Count;
2285
2286     /* set marker flag */
2287     if(count > 0)
2288         path->pathdata.Types[count-1] |= PathPointTypePathMarker;
2289
2290     return Ok;
2291 }
2292
2293 GpStatus WINGDIPAPI GdipClearPathMarkers(GpPath* path)
2294 {
2295     INT count;
2296     INT i;
2297
2298     TRACE("(%p)\n", path);
2299
2300     if(!path)
2301         return InvalidParameter;
2302
2303     count = path->pathdata.Count;
2304
2305     for(i = 0; i < count - 1; i++){
2306         path->pathdata.Types[i] &= ~PathPointTypePathMarker;
2307     }
2308
2309     return Ok;
2310 }
2311
2312 GpStatus WINGDIPAPI GdipWindingModeOutline(GpPath *path, GpMatrix *matrix, REAL flatness)
2313 {
2314    FIXME("stub: %p, %p, %.2f\n", path, matrix, flatness);
2315    return NotImplemented;
2316 }