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