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 GpStatus WINGDIPAPI GdipAddPathArc(GpPath *path, REAL x1, REAL y1, REAL x2,
  37     REAL y2, REAL startAngle, REAL sweepAngle)
  38 {
  39     INT count, old_count, i;
  40
  41     if(!path)
  42         return InvalidParameter;
  43
  44     count = arc2polybezier(NULL, x1, y1, x2, y2, startAngle, sweepAngle);
  45
  46     if(count == 0)
  47         return Ok;
  48     if(!lengthen_path(path, count))
  49         return OutOfMemory;
  50
  51     old_count = path->pathdata.Count;
  52     arc2polybezier(&path->pathdata.Points[old_count], x1, y1, x2, y2,
  53                    startAngle, sweepAngle);
  54
  55     for(i = 0; i < count; i++){
  56         path->pathdata.Types[old_count + i] = PathPointTypeBezier;
  57     }
  58
  59     path->pathdata.Types[old_count] =
  60         (path->newfigure ? PathPointTypeStart : PathPointTypeLine);
  61     path->newfigure = FALSE;
  62     path->pathdata.Count += count;
  63
  64     return Ok;
  65 }
  66
  67 GpStatus WINGDIPAPI GdipAddPathArcI(GpPath *path, INT x1, INT y1, INT x2,
  68    INT y2, REAL startAngle, REAL sweepAngle)
  69 {
  70     return GdipAddPathArc(path,(REAL)x1,(REAL)y1,(REAL)x2,(REAL)y2,startAngle,sweepAngle);
  71 }
  72
  73 GpStatus WINGDIPAPI GdipAddPathBezier(GpPath *path, REAL x1, REAL y1, REAL x2,
  74     REAL y2, REAL x3, REAL y3, REAL x4, REAL y4)
  75 {
  76     INT old_count;
  77
  78     if(!path)
  79         return InvalidParameter;
  80
  81     if(!lengthen_path(path, 4))
  82         return OutOfMemory;
  83
  84     old_count = path->pathdata.Count;
  85
  86     path->pathdata.Points[old_count].X = x1;
  87     path->pathdata.Points[old_count].Y = y1;
  88     path->pathdata.Points[old_count + 1].X = x2;
  89     path->pathdata.Points[old_count + 1].Y = y2;
  90     path->pathdata.Points[old_count + 2].X = x3;
  91     path->pathdata.Points[old_count + 2].Y = y3;
  92     path->pathdata.Points[old_count + 3].X = x4;
  93     path->pathdata.Points[old_count + 3].Y = y4;
  94
  95     path->pathdata.Types[old_count] =
  96         (path->newfigure ? PathPointTypeStart : PathPointTypeLine);
  97     path->pathdata.Types[old_count + 1] = PathPointTypeBezier;
  98     path->pathdata.Types[old_count + 2] = PathPointTypeBezier;
  99     path->pathdata.Types[old_count + 3] = PathPointTypeBezier;
 100
 101     path->newfigure = FALSE;
 102     path->pathdata.Count += 4;
 103
 104     return Ok;
 105 }
 106
 107 GpStatus WINGDIPAPI GdipAddPathBezierI(GpPath *path, INT x1, INT y1, INT x2,
 108     INT y2, INT x3, INT y3, INT x4, INT y4)
 109 {
 110     return GdipAddPathBezier(path,(REAL)x1,(REAL)y1,(REAL)x2,(REAL)y2,(REAL)x3,(REAL)y3,
 111                                   (REAL)x4,(REAL)y4);
 112 }
 113
 114 GpStatus WINGDIPAPI GdipAddPathBeziers(GpPath *path, GDIPCONST GpPointF *points,
 115     INT count)
 116 {
 117     INT i, old_count;
 118
 119     if(!path || !points || ((count - 1) % 3))
 120         return InvalidParameter;
 121
 122     if(!lengthen_path(path, count))
 123         return OutOfMemory;
 124
 125     old_count = path->pathdata.Count;
 126
 127     for(i = 0; i < count; i++){
 128         path->pathdata.Points[old_count + i].X = points[i].X;
 129         path->pathdata.Points[old_count + i].Y = points[i].Y;
 130         path->pathdata.Types[old_count + i] = PathPointTypeBezier;
 131     }
 132
 133     path->pathdata.Types[old_count] =
 134         (path->newfigure ? PathPointTypeStart : PathPointTypeLine);
 135     path->newfigure = FALSE;
 136     path->pathdata.Count += count;
 137
 138     return Ok;
 139 }
 140
 141 GpStatus WINGDIPAPI GdipAddPathBeziersI(GpPath *path, GDIPCONST GpPoint *points,
 142     INT count)
 143 {
 144     GpPointF *ptsF;
 145     GpStatus ret;
 146     INT i;
 147
 148     if(!points || ((count - 1) % 3))
 149         return InvalidParameter;
 150
 151     ptsF = GdipAlloc(sizeof(GpPointF) * count);
 152     if(!ptsF)
 153         return OutOfMemory;
 154
 155     for(i = 0; i < count; i++){
 156         ptsF[i].X = (REAL)points[i].X;
 157         ptsF[i].Y = (REAL)points[i].Y;
 158     }
 159
 160     ret = GdipAddPathBeziers(path, ptsF, count);
 161     GdipFree(ptsF);
 162
 163     return ret;
 164 }
 165
 166 GpStatus WINGDIPAPI GdipAddPathClosedCurve(GpPath *path, GDIPCONST GpPointF *points,
 167     INT count)
 168 {
 169     return GdipAddPathClosedCurve2(path, points, count, 1.0);
 170 }
 171
 172 GpStatus WINGDIPAPI GdipAddPathClosedCurveI(GpPath *path, GDIPCONST GpPoint *points,
 173     INT count)
 174 {
 175     return GdipAddPathClosedCurve2I(path, points, count, 1.0);
 176 }
 177
 178 GpStatus WINGDIPAPI GdipAddPathClosedCurve2(GpPath *path, GDIPCONST GpPointF *points,
 179     INT count, REAL tension)
 180 {
 181     INT i, len_pt = (count + 1)*3-2;
 182     GpPointF *pt;
 183     GpPointF *pts;
 184     REAL x1, x2, y1, y2;
 185     GpStatus stat;
 186
 187     if(!path || !points || count <= 1)
 188         return InvalidParameter;
 189
 190     pt = GdipAlloc(len_pt * sizeof(GpPointF));
 191     pts = GdipAlloc((count + 1)*sizeof(GpPointF));
 192     if(!pt || !pts){
 193         GdipFree(pt);
 194         GdipFree(pts);
 195         return OutOfMemory;
 196     }
 197
 198     /* copy source points to extend with the last one */
 199     memcpy(pts, points, sizeof(GpPointF)*count);
 200     pts[count] = pts[0];
 201
 202     tension = tension * TENSION_CONST;
 203
 204     for(i = 0; i < count-1; i++){
 205         calc_curve_bezier(&(pts[i]), tension, &x1, &y1, &x2, &y2);
 206
 207         pt[3*i+2].X = x1;
 208         pt[3*i+2].Y = y1;
 209         pt[3*i+3].X = pts[i+1].X;
 210         pt[3*i+3].Y = pts[i+1].Y;
 211         pt[3*i+4].X = x2;
 212         pt[3*i+4].Y = y2;
 213     }
 214
 215     /* points [len_pt-2] and [0] are calculated
 216        separetely to connect splines properly */
 217     pts[0] = points[count-1];
 218     pts[1] = points[0]; /* equals to start and end of a resulting path */
 219     pts[2] = points[1];
 220
 221     calc_curve_bezier(pts, tension, &x1, &y1, &x2, &y2);
 222     pt[len_pt-2].X = x1;
 223     pt[len_pt-2].Y = y1;
 224     pt[0].X = pts[1].X;
 225     pt[0].Y = pts[1].Y;
 226     pt[1].X = x2;
 227     pt[1].Y = y2;
 228     /* close path */
 229     pt[len_pt-1].X = pt[0].X;
 230     pt[len_pt-1].Y = pt[0].Y;
 231
 232     stat = GdipAddPathBeziers(path, pt, len_pt);
 233
 234     /* close figure */
 235     if(stat == Ok){
 236         INT count = path->pathdata.Count;
 237         path->pathdata.Types[count - 1] |= PathPointTypeCloseSubpath;
 238         path->newfigure = TRUE;
 239     }
 240
 241     GdipFree(pts);
 242     GdipFree(pt);
 243
 244     return stat;
 245 }
 246
 247 GpStatus WINGDIPAPI GdipAddPathClosedCurve2I(GpPath *path, GDIPCONST GpPoint *points,
 248     INT count, REAL tension)
 249 {
 250     GpPointF *ptf;
 251     INT i;
 252     GpStatus stat;
 253
 254     if(!path || !points || count <= 1)
 255         return InvalidParameter;
 256
 257     ptf = GdipAlloc(sizeof(GpPointF)*count);
 258     if(!ptf)
 259         return OutOfMemory;
 260
 261     for(i = 0; i < count; i++){
 262         ptf[i].X = (REAL)points[i].X;
 263         ptf[i].Y = (REAL)points[i].Y;
 264     }
 265
 266     stat = GdipAddPathClosedCurve2(path, ptf, count, tension);
 267
 268     GdipFree(ptf);
 269
 270     return stat;
 271 }
 272
 273 GpStatus WINGDIPAPI GdipAddPathCurve(GpPath *path, GDIPCONST GpPointF *points, INT count)
 274 {
 275     if(!path || !points || count <= 1)
 276         return InvalidParameter;
 277
 278    return GdipAddPathCurve2(path, points, count, 1.0);
 279 }
 280
 281 GpStatus WINGDIPAPI GdipAddPathCurveI(GpPath *path, GDIPCONST GpPoint *points, INT count)
 282 {
 283     if(!path || !points || count <= 1)
 284         return InvalidParameter;
 285
 286    return GdipAddPathCurve2I(path, points, count, 1.0);
 287 }
 288
 289 GpStatus WINGDIPAPI GdipAddPathCurve2(GpPath *path, GDIPCONST GpPointF *points, INT count,
 290     REAL tension)
 291 {
 292     INT i, len_pt = count*3-2;
 293     GpPointF *pt;
 294     REAL x1, x2, y1, y2;
 295     GpStatus stat;
 296
 297     if(!path || !points || count <= 1)
 298         return InvalidParameter;
 299
 300     pt = GdipAlloc(len_pt * sizeof(GpPointF));
 301     if(!pt)
 302         return OutOfMemory;
 303
 304     tension = tension * TENSION_CONST;
 305
 306     calc_curve_bezier_endp(points[0].X, points[0].Y, points[1].X, points[1].Y,
 307         tension, &x1, &y1);
 308
 309     pt[0].X = points[0].X;
 310     pt[0].Y = points[0].Y;
 311     pt[1].X = x1;
 312     pt[1].Y = y1;
 313
 314     for(i = 0; i < count-2; i++){
 315         calc_curve_bezier(&(points[i]), tension, &x1, &y1, &x2, &y2);
 316
 317         pt[3*i+2].X = x1;
 318         pt[3*i+2].Y = y1;
 319         pt[3*i+3].X = points[i+1].X;
 320         pt[3*i+3].Y = points[i+1].Y;
 321         pt[3*i+4].X = x2;
 322         pt[3*i+4].Y = y2;
 323     }
 324
 325     calc_curve_bezier_endp(points[count-1].X, points[count-1].Y,
 326         points[count-2].X, points[count-2].Y, tension, &x1, &y1);
 327
 328     pt[len_pt-2].X = x1;
 329     pt[len_pt-2].Y = y1;
 330     pt[len_pt-1].X = points[count-1].X;
 331     pt[len_pt-1].Y = points[count-1].Y;
 332
 333     stat = GdipAddPathBeziers(path, pt, len_pt);
 334
 335     GdipFree(pt);
 336
 337     return stat;
 338 }
 339
 340 GpStatus WINGDIPAPI GdipAddPathCurve2I(GpPath *path, GDIPCONST GpPoint *points,
 341     INT count, REAL tension)
 342 {
 343     GpPointF *ptf;
 344     INT i;
 345     GpStatus stat;
 346
 347     if(!path || !points || count <= 1)
 348         return InvalidParameter;
 349
 350     ptf = GdipAlloc(sizeof(GpPointF)*count);
 351     if(!ptf)
 352         return OutOfMemory;
 353
 354     for(i = 0; i < count; i++){
 355         ptf[i].X = (REAL)points[i].X;
 356         ptf[i].Y = (REAL)points[i].Y;
 357     }
 358
 359     stat = GdipAddPathCurve2(path, ptf, count, tension);
 360
 361     GdipFree(ptf);
 362
 363     return stat;
 364 }
 365
 366 GpStatus WINGDIPAPI GdipAddPathEllipse(GpPath *path, REAL x, REAL y, REAL width,
 367     REAL height)
 368 {
 369     INT old_count, numpts;
 370
 371     if(!path)
 372         return InvalidParameter;
 373
 374     if(!lengthen_path(path, MAX_ARC_PTS))
 375         return OutOfMemory;
 376
 377     old_count = path->pathdata.Count;
 378     if((numpts = arc2polybezier(&path->pathdata.Points[old_count],  x, y, width,
 379                                height, 0.0, 360.0)) != MAX_ARC_PTS){
 380         ERR("expected %d points but got %d\n", MAX_ARC_PTS, numpts);
 381         return GenericError;
 382     }
 383
 384     memset(&path->pathdata.Types[old_count + 1], PathPointTypeBezier,
 385            MAX_ARC_PTS - 1);
 386
 387     /* An ellipse is an intrinsic figure (always is its own subpath). */
 388     path->pathdata.Types[old_count] = PathPointTypeStart;
 389     path->pathdata.Types[old_count + MAX_ARC_PTS - 1] |= PathPointTypeCloseSubpath;
 390     path->newfigure = TRUE;
 391     path->pathdata.Count += MAX_ARC_PTS;
 392
 393     return Ok;
 394 }
 395
 396 GpStatus WINGDIPAPI GdipAddPathEllipseI(GpPath *path, INT x, INT y, INT width,
 397     INT height)
 398 {
 399     return GdipAddPathEllipse(path,(REAL)x,(REAL)y,(REAL)width,(REAL)height);
 400 }
 401
 402 GpStatus WINGDIPAPI GdipAddPathLine2(GpPath *path, GDIPCONST GpPointF *points,
 403     INT count)
 404 {
 405     INT i, old_count;
 406
 407     if(!path || !points)
 408         return InvalidParameter;
 409
 410     if(!lengthen_path(path, count))
 411         return OutOfMemory;
 412
 413     old_count = path->pathdata.Count;
 414
 415     for(i = 0; i < count; i++){
 416         path->pathdata.Points[old_count + i].X = points[i].X;
 417         path->pathdata.Points[old_count + i].Y = points[i].Y;
 418         path->pathdata.Types[old_count + i] = PathPointTypeLine;
 419     }
 420
 421     if(path->newfigure){
 422         path->pathdata.Types[old_count] = PathPointTypeStart;
 423         path->newfigure = FALSE;
 424     }
 425
 426     path->pathdata.Count += count;
 427
 428     return Ok;
 429 }
 430
 431 GpStatus WINGDIPAPI GdipAddPathLine2I(GpPath *path, GDIPCONST GpPoint *points, INT count)
 432 {
 433     GpPointF *pointsF;
 434     INT i;
 435     GpStatus stat;
 436
 437     if(count <= 0)
 438         return InvalidParameter;
 439
 440     pointsF = GdipAlloc(sizeof(GpPointF) * count);
 441     if(!pointsF)    return OutOfMemory;
 442
 443     for(i = 0;i < count; i++){
 444         pointsF[i].X = (REAL)points[i].X;
 445         pointsF[i].Y = (REAL)points[i].Y;
 446     }
 447
 448     stat = GdipAddPathLine2(path, pointsF, count);
 449
 450     GdipFree(pointsF);
 451
 452     return stat;
 453 }
 454
 455 GpStatus WINGDIPAPI GdipAddPathLine(GpPath *path, REAL x1, REAL y1, REAL x2, REAL y2)
 456 {
 457     INT old_count;
 458
 459     if(!path)
 460         return InvalidParameter;
 461
 462     if(!lengthen_path(path, 2))
 463         return OutOfMemory;
 464
 465     old_count = path->pathdata.Count;
 466
 467     path->pathdata.Points[old_count].X = x1;
 468     path->pathdata.Points[old_count].Y = y1;
 469     path->pathdata.Points[old_count + 1].X = x2;
 470     path->pathdata.Points[old_count + 1].Y = y2;
 471
 472     path->pathdata.Types[old_count] =
 473         (path->newfigure ? PathPointTypeStart : PathPointTypeLine);
 474     path->pathdata.Types[old_count + 1] = PathPointTypeLine;
 475
 476     path->newfigure = FALSE;
 477     path->pathdata.Count += 2;
 478
 479     return Ok;
 480 }
 481
 482 GpStatus WINGDIPAPI GdipAddPathLineI(GpPath *path, INT x1, INT y1, INT x2, INT y2)
 483 {
 484     return GdipAddPathLine(path, (REAL)x1, (REAL)y1, (REAL)x2, (REAL)y2);
 485 }
 486
 487 GpStatus WINGDIPAPI GdipAddPathPath(GpPath *path, GDIPCONST GpPath* addingPath,
 488     BOOL connect)
 489 {
 490     INT old_count, count;
 491
 492     if(!path || !addingPath)
 493         return InvalidParameter;
 494
 495     old_count = path->pathdata.Count;
 496     count = addingPath->pathdata.Count;
 497
 498     if(!lengthen_path(path, count))
 499         return OutOfMemory;
 500
 501     memcpy(&path->pathdata.Points[old_count], addingPath->pathdata.Points,
 502            count * sizeof(GpPointF));
 503     memcpy(&path->pathdata.Types[old_count], addingPath->pathdata.Types, count);
 504
 505     if(path->newfigure || !connect)
 506         path->pathdata.Types[old_count] = PathPointTypeStart;
 507     else
 508         path->pathdata.Types[old_count] = PathPointTypeLine;
 509
 510     path->newfigure = FALSE;
 511     path->pathdata.Count += count;
 512
 513     return Ok;
 514 }
 515
 516 GpStatus WINGDIPAPI GdipAddPathPie(GpPath *path, REAL x, REAL y, REAL width, REAL height,
 517     REAL startAngle, REAL sweepAngle)
 518 {
 519     GpPointF *ptf;
 520     GpStatus status;
 521     INT i, count;
 522
 523     if(!path)
 524         return InvalidParameter;
 525
 526     count = arc2polybezier(NULL, x, y, width, height, startAngle, sweepAngle);
 527
 528     if(count == 0)
 529         return Ok;
 530
 531     ptf = GdipAlloc(sizeof(GpPointF)*count);
 532     if(!ptf)
 533         return OutOfMemory;
 534
 535     arc2polybezier(ptf, x, y, width, height, startAngle, sweepAngle);
 536
 537     status = GdipAddPathLine(path, (width - x)/2, (height - y)/2, ptf[0].X, ptf[0].Y);
 538     if(status != Ok){
 539         GdipFree(ptf);
 540         return status;
 541     }
 542     /* one spline is already added as a line endpoint */
 543     if(!lengthen_path(path, count - 1)){
 544         GdipFree(ptf);
 545         return OutOfMemory;
 546     }
 547
 548     memcpy(&(path->pathdata.Points[path->pathdata.Count]), &(ptf[1]),sizeof(GpPointF)*(count-1));
 549     for(i = 0; i < count-1; i++)
 550         path->pathdata.Types[path->pathdata.Count+i] = PathPointTypeBezier;
 551
 552     path->pathdata.Count += count-1;
 553
 554     GdipClosePathFigure(path);
 555
 556     GdipFree(ptf);
 557
 558     return status;
 559 }
 560
 561 GpStatus WINGDIPAPI GdipAddPathPieI(GpPath *path, INT x, INT y, INT width, INT height,
 562     REAL startAngle, REAL sweepAngle)
 563 {
 564     return GdipAddPathPieI(path, (REAL)x, (REAL)y, (REAL)width, (REAL)height, startAngle, sweepAngle);
 565 }
 566
 567 GpStatus WINGDIPAPI GdipAddPathPolygon(GpPath *path, GDIPCONST GpPointF *points, INT count)
 568 {
 569     INT old_count;
 570
 571     if(!path || !points || count < 3)
 572         return InvalidParameter;
 573
 574     if(!lengthen_path(path, count))
 575         return OutOfMemory;
 576
 577     old_count = path->pathdata.Count;
 578
 579     memcpy(&path->pathdata.Points[old_count], points, count*sizeof(GpPointF));
 580     memset(&path->pathdata.Types[old_count + 1], PathPointTypeLine, count - 1);
 581
 582     /* A polygon is an intrinsic figure */
 583     path->pathdata.Types[old_count] = PathPointTypeStart;
 584     path->pathdata.Types[old_count + count - 1] |= PathPointTypeCloseSubpath;
 585     path->newfigure = TRUE;
 586     path->pathdata.Count += count;
 587
 588     return Ok;
 589 }
 590
 591 GpStatus WINGDIPAPI GdipAddPathPolygonI(GpPath *path, GDIPCONST GpPoint *points, INT count)
 592 {
 593     GpPointF *ptf;
 594     GpStatus status;
 595     INT i;
 596
 597     if(!points || count < 3)
 598         return InvalidParameter;
 599
 600     ptf = GdipAlloc(sizeof(GpPointF) * count);
 601     if(!ptf)
 602         return OutOfMemory;
 603
 604     for(i = 0; i < count; i++){
 605         ptf[i].X = (REAL)points[i].X;
 606         ptf[i].Y = (REAL)points[i].Y;
 607     }
 608
 609     status = GdipAddPathPolygon(path, ptf, count);
 610
 611     GdipFree(ptf);
 612
 613     return status;
 614 }
 615
 616 GpStatus WINGDIPAPI GdipClonePath(GpPath* path, GpPath **clone)
 617 {
 618     if(!path || !clone)
 619         return InvalidParameter;
 620
 621     *clone = GdipAlloc(sizeof(GpPath));
 622     if(!*clone) return OutOfMemory;
 623
 624     **clone = *path;
 625
 626     (*clone)->pathdata.Points = GdipAlloc(path->datalen * sizeof(PointF));
 627     (*clone)->pathdata.Types = GdipAlloc(path->datalen);
 628     if(!(*clone)->pathdata.Points || !(*clone)->pathdata.Types){
 629         GdipFree(*clone);
 630         GdipFree((*clone)->pathdata.Points);
 631         GdipFree((*clone)->pathdata.Types);
 632         return OutOfMemory;
 633     }
 634
 635     memcpy((*clone)->pathdata.Points, path->pathdata.Points,
 636            path->datalen * sizeof(PointF));
 637     memcpy((*clone)->pathdata.Types, path->pathdata.Types, path->datalen);
 638
 639     return Ok;
 640 }
 641
 642 GpStatus WINGDIPAPI GdipClosePathFigure(GpPath* path)
 643 {
 644     if(!path)
 645         return InvalidParameter;
 646
 647     if(path->pathdata.Count > 0){
 648         path->pathdata.Types[path->pathdata.Count - 1] |= PathPointTypeCloseSubpath;
 649         path->newfigure = TRUE;
 650     }
 651
 652     return Ok;
 653 }
 654
 655 GpStatus WINGDIPAPI GdipClosePathFigures(GpPath* path)
 656 {
 657     INT i;
 658
 659     if(!path)
 660         return InvalidParameter;
 661
 662     for(i = 1; i < path->pathdata.Count; i++){
 663         if(path->pathdata.Types[i] == PathPointTypeStart)
 664             path->pathdata.Types[i-1] |= PathPointTypeCloseSubpath;
 665     }
 666
 667     path->newfigure = TRUE;
 668
 669     return Ok;
 670 }
 671
 672 GpStatus WINGDIPAPI GdipCreatePath(GpFillMode fill, GpPath **path)
 673 {
 674     if(!path)
 675         return InvalidParameter;
 676
 677     *path = GdipAlloc(sizeof(GpPath));
 678     if(!*path)  return OutOfMemory;
 679
 680     (*path)->fill = fill;
 681     (*path)->newfigure = TRUE;
 682
 683     return Ok;
 684 }
 685
 686 GpStatus WINGDIPAPI GdipCreatePath2(GDIPCONST GpPointF* points,
 687     GDIPCONST BYTE* types, INT count, GpFillMode fill, GpPath **path)
 688 {
 689     if(!path)
 690         return InvalidParameter;
 691
 692     *path = GdipAlloc(sizeof(GpPath));
 693     if(!*path)  return OutOfMemory;
 694
 695     (*path)->pathdata.Points = GdipAlloc(count * sizeof(PointF));
 696     (*path)->pathdata.Types = GdipAlloc(count);
 697
 698     if(!(*path)->pathdata.Points || !(*path)->pathdata.Types){
 699         GdipFree((*path)->pathdata.Points);
 700         GdipFree((*path)->pathdata.Types);
 701         GdipFree(*path);
 702         return OutOfMemory;
 703     }
 704
 705     memcpy((*path)->pathdata.Points, points, count * sizeof(PointF));
 706     memcpy((*path)->pathdata.Types, types, count);
 707     (*path)->pathdata.Count = count;
 708     (*path)->datalen = count;
 709
 710     (*path)->fill = fill;
 711     (*path)->newfigure = TRUE;
 712
 713     return Ok;
 714 }
 715
 716 GpStatus WINGDIPAPI GdipCreatePath2I(GDIPCONST GpPoint* points,
 717     GDIPCONST BYTE* types, INT count, GpFillMode fill, GpPath **path)
 718 {
 719     GpPointF *ptF;
 720     GpStatus ret;
 721     INT i;
 722
 723     ptF = GdipAlloc(sizeof(GpPointF)*count);
 724
 725     for(i = 0;i < count; i++){
 726         ptF[i].X = (REAL)points[i].X;
 727         ptF[i].Y = (REAL)points[i].Y;
 728     }
 729
 730     ret = GdipCreatePath2(ptF, types, count, fill, path);
 731
 732     GdipFree(ptF);
 733
 734     return ret;
 735 }
 736
 737 GpStatus WINGDIPAPI GdipDeletePath(GpPath *path)
 738 {
 739     if(!path)
 740         return InvalidParameter;
 741
 742     GdipFree(path->pathdata.Points);
 743     GdipFree(path->pathdata.Types);
 744     GdipFree(path);
 745
 746     return Ok;
 747 }
 748
 749 GpStatus WINGDIPAPI GdipGetPathData(GpPath *path, GpPathData* pathData)
 750 {
 751     if(!path || !pathData)
 752         return InvalidParameter;
 753
 754     /* Only copy data. pathData allocation/freeing controlled by wrapper class.
 755        Assumed that pathData is enough wide to get all data - controlled by wrapper too. */
 756     memcpy(pathData->Points, path->pathdata.Points, sizeof(PointF) * pathData->Count);
 757     memcpy(pathData->Types , path->pathdata.Types , pathData->Count);
 758
 759     return Ok;
 760 }
 761
 762 GpStatus WINGDIPAPI GdipGetPathFillMode(GpPath *path, GpFillMode *fillmode)
 763 {
 764     if(!path || !fillmode)
 765         return InvalidParameter;
 766
 767     *fillmode = path->fill;
 768
 769     return Ok;
 770 }
 771
 772 GpStatus WINGDIPAPI GdipGetPathLastPoint(GpPath* path, GpPointF* lastPoint)
 773 {
 774     INT count;
 775
 776     if(!path || !lastPoint)
 777         return InvalidParameter;
 778
 779     count = path->pathdata.Count;
 780     if(count > 0)
 781         *lastPoint = path->pathdata.Points[count-1];
 782
 783     return Ok;
 784 }
 785
 786 GpStatus WINGDIPAPI GdipGetPathPoints(GpPath *path, GpPointF* points, INT count)
 787 {
 788     if(!path)
 789         return InvalidParameter;
 790
 791     if(count < path->pathdata.Count)
 792         return InsufficientBuffer;
 793
 794     memcpy(points, path->pathdata.Points, path->pathdata.Count * sizeof(GpPointF));
 795
 796     return Ok;
 797 }
 798
 799 GpStatus WINGDIPAPI GdipGetPathPointsI(GpPath *path, GpPoint* points, INT count)
 800 {
 801     GpStatus ret;
 802     GpPointF *ptf;
 803     INT i;
 804
 805     if(count <= 0)
 806         return InvalidParameter;
 807
 808     ptf = GdipAlloc(sizeof(GpPointF)*count);
 809     if(!ptf)    return OutOfMemory;
 810
 811     ret = GdipGetPathPoints(path,ptf,count);
 812     if(ret == Ok)
 813         for(i = 0;i < count;i++){
 814             points[i].X = roundr(ptf[i].X);
 815             points[i].Y = roundr(ptf[i].Y);
 816         };
 817     GdipFree(ptf);
 818
 819     return ret;
 820 }
 821
 822 GpStatus WINGDIPAPI GdipGetPathTypes(GpPath *path, BYTE* types, INT count)
 823 {
 824     if(!path)
 825         return InvalidParameter;
 826
 827     if(count < path->pathdata.Count)
 828         return InsufficientBuffer;
 829
 830     memcpy(types, path->pathdata.Types, path->pathdata.Count);
 831
 832     return Ok;
 833 }
 834
 835 /* Windows expands the bounding box to the maximum possible bounding box
 836  * for a given pen.  For example, if a line join can extend past the point
 837  * it's joining by x units, the bounding box is extended by x units in every
 838  * direction (even though this is too conservative for most cases). */
 839 GpStatus WINGDIPAPI GdipGetPathWorldBounds(GpPath* path, GpRectF* bounds,
 840     GDIPCONST GpMatrix *matrix, GDIPCONST GpPen *pen)
 841 {
 842     GpPointF * points, temp_pts[4];
 843     INT count, i;
 844     REAL path_width = 1.0, width, height, temp, low_x, low_y, high_x, high_y;
 845
 846     /* Matrix and pen can be null. */
 847     if(!path || !bounds)
 848         return InvalidParameter;
 849
 850     /* If path is empty just return. */
 851     count = path->pathdata.Count;
 852     if(count == 0){
 853         bounds->X = bounds->Y = bounds->Width = bounds->Height = 0.0;
 854         return Ok;
 855     }
 856
 857     points = path->pathdata.Points;
 858
 859     low_x = high_x = points[0].X;
 860     low_y = high_y = points[0].Y;
 861
 862     for(i = 1; i < count; i++){
 863         low_x = min(low_x, points[i].X);
 864         low_y = min(low_y, points[i].Y);
 865         high_x = max(high_x, points[i].X);
 866         high_y = max(high_y, points[i].Y);
 867     }
 868
 869     width = high_x - low_x;
 870     height = high_y - low_y;
 871
 872     /* This looks unusual but it's the only way I can imitate windows. */
 873     if(matrix){
 874         temp_pts[0].X = low_x;
 875         temp_pts[0].Y = low_y;
 876         temp_pts[1].X = low_x;
 877         temp_pts[1].Y = high_y;
 878         temp_pts[2].X = high_x;
 879         temp_pts[2].Y = high_y;
 880         temp_pts[3].X = high_x;
 881         temp_pts[3].Y = low_y;
 882
 883         GdipTransformMatrixPoints((GpMatrix*)matrix, temp_pts, 4);
 884         low_x = temp_pts[0].X;
 885         low_y = temp_pts[0].Y;
 886
 887         for(i = 1; i < 4; i++){
 888             low_x = min(low_x, temp_pts[i].X);
 889             low_y = min(low_y, temp_pts[i].Y);
 890         }
 891
 892         temp = width;
 893         width = height * fabs(matrix->matrix[2]) + width * fabs(matrix->matrix[0]);
 894         height = height * fabs(matrix->matrix[3]) + temp * fabs(matrix->matrix[1]);
 895     }
 896
 897     if(pen){
 898         path_width = pen->width / 2.0;
 899
 900         if(count > 2)
 901             path_width = max(path_width,  pen->width * pen->miterlimit / 2.0);
 902         /* FIXME: this should probably also check for the startcap */
 903         if(pen->endcap & LineCapNoAnchor)
 904             path_width = max(path_width,  pen->width * 2.2);
 905
 906         low_x -= path_width;
 907         low_y -= path_width;
 908         width += 2.0 * path_width;
 909         height += 2.0 * path_width;
 910     }
 911
 912     bounds->X = low_x;
 913     bounds->Y = low_y;
 914     bounds->Width = width;
 915     bounds->Height = height;
 916
 917     return Ok;
 918 }
 919
 920 GpStatus WINGDIPAPI GdipGetPathWorldBoundsI(GpPath* path, GpRect* bounds,
 921     GDIPCONST GpMatrix *matrix, GDIPCONST GpPen *pen)
 922 {
 923     GpStatus ret;
 924     GpRectF boundsF;
 925
 926     ret = GdipGetPathWorldBounds(path,&boundsF,matrix,pen);
 927
 928     if(ret == Ok){
 929         bounds->X      = roundr(boundsF.X);
 930         bounds->Y      = roundr(boundsF.Y);
 931         bounds->Width  = roundr(boundsF.Width);
 932         bounds->Height = roundr(boundsF.Height);
 933     }
 934
 935     return ret;
 936 }
 937
 938 GpStatus WINGDIPAPI GdipGetPointCount(GpPath *path, INT *count)
 939 {
 940     if(!path)
 941         return InvalidParameter;
 942
 943     *count = path->pathdata.Count;
 944
 945     return Ok;
 946 }
 947
 948 GpStatus WINGDIPAPI GdipReversePath(GpPath* path)
 949 {
 950     INT i, count;
 951     INT start = 0; /* position in reversed path */
 952     GpPathData revpath;
 953
 954     if(!path)
 955         return InvalidParameter;
 956
 957     count = path->pathdata.Count;
 958
 959     if(count == 0) return Ok;
 960
 961     revpath.Points = GdipAlloc(sizeof(GpPointF)*count);
 962     revpath.Types  = GdipAlloc(sizeof(BYTE)*count);
 963     revpath.Count  = count;
 964     if(!revpath.Points || !revpath.Types){
 965         GdipFree(revpath.Points);
 966         GdipFree(revpath.Types);
 967         return OutOfMemory;
 968     }
 969
 970     for(i = 0; i < count; i++){
 971
 972         /* find next start point */
 973         if(path->pathdata.Types[count-i-1] == PathPointTypeStart){
 974             INT j;
 975             for(j = start; j <= i; j++){
 976                 revpath.Points[j] = path->pathdata.Points[count-j-1];
 977                 revpath.Types[j] = path->pathdata.Types[count-j-1];
 978             }
 979             /* mark start point */
 980             revpath.Types[start] = PathPointTypeStart;
 981             /* set 'figure' endpoint type */
 982             if(i-start > 1){
 983                 revpath.Types[i] = path->pathdata.Types[count-start-1] & ~PathPointTypePathTypeMask;
 984                 revpath.Types[i] |= revpath.Types[i-1];
 985             }
 986             else
 987                 revpath.Types[i] = path->pathdata.Types[start];
 988
 989             start = i+1;
 990         }
 991     }
 992
 993     memcpy(path->pathdata.Points, revpath.Points, sizeof(GpPointF)*count);
 994     memcpy(path->pathdata.Types,  revpath.Types,  sizeof(BYTE)*count);
 995
 996     GdipFree(revpath.Points);
 997     GdipFree(revpath.Types);
 998
 999     return Ok;
1000 }
1001
1002 GpStatus WINGDIPAPI GdipIsOutlineVisiblePathPointI(GpPath* path, INT x, INT y,
1003     GpPen *pen, GpGraphics *graphics, BOOL *result)
1004 {
1005     return GdipIsOutlineVisiblePathPoint(path, x, y, pen, graphics, result);
1006 }
1007
1008 GpStatus WINGDIPAPI GdipIsOutlineVisiblePathPoint(GpPath* path, REAL x, REAL y,
1009     GpPen *pen, GpGraphics *graphics, BOOL *result)
1010 {
1011     static int calls;
1012
1013     if(!path || !pen)
1014         return InvalidParameter;
1015
1016     if(!(calls++))
1017         FIXME("not implemented\n");
1018
1019     return NotImplemented;
1020 }
1021
1022 GpStatus WINGDIPAPI GdipIsVisiblePathPointI(GpPath* path, INT x, INT y, GpGraphics *graphics, BOOL *result)
1023 {
1024     return GdipIsVisiblePathPoint(path, x, y, graphics, result);
1025 }
1026
1027 GpStatus WINGDIPAPI GdipIsVisiblePathPoint(GpPath* path, REAL x, REAL y, GpGraphics *graphics, BOOL *result)
1028 {
1029     static int calls;
1030
1031     if(!path) return InvalidParameter;
1032
1033     if(!(calls++))
1034         FIXME("not implemented\n");
1035
1036     return NotImplemented;
1037 }
1038
1039 GpStatus WINGDIPAPI GdipStartPathFigure(GpPath *path)
1040 {
1041     if(!path)
1042         return InvalidParameter;
1043
1044     path->newfigure = TRUE;
1045
1046     return Ok;
1047 }
1048
1049 GpStatus WINGDIPAPI GdipResetPath(GpPath *path)
1050 {
1051     if(!path)
1052         return InvalidParameter;
1053
1054     path->pathdata.Count = 0;
1055     path->newfigure = TRUE;
1056     path->fill = FillModeAlternate;
1057
1058     return Ok;
1059 }
1060
1061 GpStatus WINGDIPAPI GdipSetPathFillMode(GpPath *path, GpFillMode fill)
1062 {
1063     if(!path)
1064         return InvalidParameter;
1065
1066     path->fill = fill;
1067
1068     return Ok;
1069 }
1070
1071 GpStatus WINGDIPAPI GdipTransformPath(GpPath *path, GpMatrix *matrix)
1072 {
1073     if(!path)
1074         return InvalidParameter;
1075
1076     if(path->pathdata.Count == 0)
1077         return Ok;
1078
1079     return GdipTransformMatrixPoints(matrix, path->pathdata.Points,
1080                                      path->pathdata.Count);
1081 }
1082
1083 GpStatus WINGDIPAPI GdipAddPathRectangle(GpPath *path, REAL x, REAL y,
1084     REAL width, REAL height)
1085 {
1086     GpPath *backup;
1087     GpPointF ptf[2];
1088     GpStatus retstat;
1089     BOOL old_new;
1090
1091     if(!path || width < 0.0 || height < 0.0)
1092         return InvalidParameter;
1093
1094     /* make a backup copy of path data */
1095     if((retstat = GdipClonePath(path, &backup)) != Ok)
1096         return retstat;
1097
1098     /* rectangle should start as new path */
1099     old_new = path->newfigure;
1100     path->newfigure = TRUE;
1101     if((retstat = GdipAddPathLine(path,x,y,x+width,y)) != Ok){
1102         path->newfigure = old_new;
1103         goto fail;
1104     }
1105
1106     ptf[0].X = x+width;
1107     ptf[0].Y = y+height;
1108     ptf[1].X = x;
1109     ptf[1].Y = y+height;
1110
1111     if((retstat = GdipAddPathLine2(path, ptf, 2)) != Ok)  goto fail;
1112     path->pathdata.Types[path->pathdata.Count-1] |= PathPointTypeCloseSubpath;
1113
1114     /* free backup */
1115     GdipDeletePath(backup);
1116     return Ok;
1117
1118 fail:
1119     /* reverting */
1120     GdipDeletePath(path);
1121     GdipClonePath(backup, &path);
1122     GdipDeletePath(backup);
1123
1124     return retstat;
1125 }
1126
1127 GpStatus WINGDIPAPI GdipAddPathRectangleI(GpPath *path, INT x, INT y,
1128     INT width, INT height)
1129 {
1130     return GdipAddPathRectangle(path,(REAL)x,(REAL)y,(REAL)width,(REAL)height);
1131 }
1132
1133 GpStatus WINGDIPAPI GdipAddPathRectangles(GpPath *path, GDIPCONST GpRectF *rects, INT count)
1134 {
1135     GpPath *backup;
1136     GpStatus retstat;
1137     INT i;
1138
1139     /* count == 0 - verified condition  */
1140     if(!path || !rects || count == 0)
1141         return InvalidParameter;
1142
1143     if(count < 0)
1144         return OutOfMemory;
1145
1146     /* make a backup copy */
1147     if((retstat = GdipClonePath(path, &backup)) != Ok)
1148         return retstat;
1149
1150     for(i = 0; i < count; i++){
1151         if((retstat = GdipAddPathRectangle(path,rects[i].X,rects[i].Y,rects[i].Width,rects[i].Height)) != Ok)
1152             goto fail;
1153     }
1154
1155     /* free backup */
1156     GdipDeletePath(backup);
1157     return Ok;
1158
1159 fail:
1160     /* reverting */
1161     GdipDeletePath(path);
1162     GdipClonePath(backup, &path);
1163     GdipDeletePath(backup);
1164
1165     return retstat;
1166 }
1167
1168 GpStatus WINGDIPAPI GdipAddPathRectanglesI(GpPath *path, GDIPCONST GpRect *rects, INT count)
1169 {
1170     GpRectF *rectsF;
1171     GpStatus retstat;
1172     INT i;
1173
1174     if(!rects || count == 0)
1175         return InvalidParameter;
1176
1177     if(count < 0)
1178         return OutOfMemory;
1179
1180     rectsF = GdipAlloc(sizeof(GpRectF)*count);
1181
1182     for(i = 0;i < count;i++){
1183         rectsF[i].X      = (REAL)rects[i].X;
1184         rectsF[i].Y      = (REAL)rects[i].Y;
1185         rectsF[i].Width  = (REAL)rects[i].Width;
1186         rectsF[i].Height = (REAL)rects[i].Height;
1187     }
1188
1189     retstat = GdipAddPathRectangles(path, rectsF, count);
1190     GdipFree(rectsF);
1191
1192     return retstat;
1193 }
1194
1195 GpStatus WINGDIPAPI GdipSetPathMarker(GpPath* path)
1196 {
1197     INT count;
1198
1199     if(!path)
1200         return InvalidParameter;
1201
1202     count = path->pathdata.Count;
1203
1204     /* set marker flag */
1205     if(count > 0)
1206         path->pathdata.Types[count-1] |= PathPointTypePathMarker;
1207
1208     return Ok;
1209 }
1210
1211 GpStatus WINGDIPAPI GdipClearPathMarkers(GpPath* path)
1212 {
1213     INT count;
1214     INT i;
1215
1216     if(!path)
1217         return InvalidParameter;
1218
1219     count = path->pathdata.Count;
1220
1221     for(i = 0; i < count - 1; i++){
1222         path->pathdata.Types[i] &= ~PathPointTypePathMarker;
1223     }
1224
1225     return Ok;
1226 }