Autosyncing with Wine HEAD
[reactos.git] / reactos / dll / win32 / 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 GdipAddPathEllipse(GpPath *path, REAL x, REAL y, REAL width,
200 REAL height)
201 {
202 INT old_count, numpts;
203
204 if(!path)
205 return InvalidParameter;
206
207 if(!lengthen_path(path, MAX_ARC_PTS))
208 return OutOfMemory;
209
210 old_count = path->pathdata.Count;
211 if((numpts = arc2polybezier(&path->pathdata.Points[old_count], x, y, width,
212 height, 0.0, 360.0)) != MAX_ARC_PTS){
213 ERR("expected %d points but got %d\n", MAX_ARC_PTS, numpts);
214 return GenericError;
215 }
216
217 memset(&path->pathdata.Types[old_count + 1], PathPointTypeBezier,
218 MAX_ARC_PTS - 1);
219
220 /* An ellipse is an intrinsic figure (always is its own subpath). */
221 path->pathdata.Types[old_count] = PathPointTypeStart;
222 path->pathdata.Types[old_count + MAX_ARC_PTS - 1] |= PathPointTypeCloseSubpath;
223 path->newfigure = TRUE;
224 path->pathdata.Count += MAX_ARC_PTS;
225
226 return Ok;
227 }
228
229 GpStatus WINGDIPAPI GdipAddPathEllipseI(GpPath *path, INT x, INT y, INT width,
230 INT height)
231 {
232 return GdipAddPathEllipse(path,(REAL)x,(REAL)y,(REAL)width,(REAL)height);
233 }
234
235 GpStatus WINGDIPAPI GdipAddPathLine2(GpPath *path, GDIPCONST GpPointF *points,
236 INT count)
237 {
238 INT i, old_count;
239
240 if(!path || !points)
241 return InvalidParameter;
242
243 if(!lengthen_path(path, count))
244 return OutOfMemory;
245
246 old_count = path->pathdata.Count;
247
248 for(i = 0; i < count; i++){
249 path->pathdata.Points[old_count + i].X = points[i].X;
250 path->pathdata.Points[old_count + i].Y = points[i].Y;
251 path->pathdata.Types[old_count + i] = PathPointTypeLine;
252 }
253
254 if(path->newfigure){
255 path->pathdata.Types[old_count] = PathPointTypeStart;
256 path->newfigure = FALSE;
257 }
258
259 path->pathdata.Count += count;
260
261 return Ok;
262 }
263
264 GpStatus WINGDIPAPI GdipAddPathLine2I(GpPath *path, GDIPCONST GpPoint *points, INT count)
265 {
266 GpPointF *pointsF;
267 INT i;
268 GpStatus stat;
269
270 if(count <= 0)
271 return InvalidParameter;
272
273 pointsF = GdipAlloc(sizeof(GpPointF) * count);
274 if(!pointsF) return OutOfMemory;
275
276 for(i = 0;i < count; i++){
277 pointsF[i].X = (REAL)points[i].X;
278 pointsF[i].Y = (REAL)points[i].Y;
279 }
280
281 stat = GdipAddPathLine2(path, pointsF, count);
282
283 GdipFree(pointsF);
284
285 return stat;
286 }
287
288 GpStatus WINGDIPAPI GdipAddPathLine(GpPath *path, REAL x1, REAL y1, REAL x2, REAL y2)
289 {
290 INT old_count;
291
292 if(!path)
293 return InvalidParameter;
294
295 if(!lengthen_path(path, 2))
296 return OutOfMemory;
297
298 old_count = path->pathdata.Count;
299
300 path->pathdata.Points[old_count].X = x1;
301 path->pathdata.Points[old_count].Y = y1;
302 path->pathdata.Points[old_count + 1].X = x2;
303 path->pathdata.Points[old_count + 1].Y = y2;
304
305 path->pathdata.Types[old_count] =
306 (path->newfigure ? PathPointTypeStart : PathPointTypeLine);
307 path->pathdata.Types[old_count + 1] = PathPointTypeLine;
308
309 path->newfigure = FALSE;
310 path->pathdata.Count += 2;
311
312 return Ok;
313 }
314
315 GpStatus WINGDIPAPI GdipAddPathLineI(GpPath *path, INT x1, INT y1, INT x2, INT y2)
316 {
317 return GdipAddPathLine(path, (REAL)x1, (REAL)y1, (REAL)x2, (REAL)y2);
318 }
319
320 GpStatus WINGDIPAPI GdipAddPathPath(GpPath *path, GDIPCONST GpPath* addingPath,
321 BOOL connect)
322 {
323 INT old_count, count;
324
325 if(!path || !addingPath)
326 return InvalidParameter;
327
328 old_count = path->pathdata.Count;
329 count = addingPath->pathdata.Count;
330
331 if(!lengthen_path(path, count))
332 return OutOfMemory;
333
334 memcpy(&path->pathdata.Points[old_count], addingPath->pathdata.Points,
335 count * sizeof(GpPointF));
336 memcpy(&path->pathdata.Types[old_count], addingPath->pathdata.Types, count);
337
338 if(path->newfigure || !connect)
339 path->pathdata.Types[old_count] = PathPointTypeStart;
340 else
341 path->pathdata.Types[old_count] = PathPointTypeLine;
342
343 path->newfigure = FALSE;
344 path->pathdata.Count += count;
345
346 return Ok;
347 }
348
349 GpStatus WINGDIPAPI GdipAddPathPolygon(GpPath *path, GDIPCONST GpPointF *points, INT count)
350 {
351 INT old_count;
352
353 if(!path || !points || count < 3)
354 return InvalidParameter;
355
356 if(!lengthen_path(path, count))
357 return OutOfMemory;
358
359 old_count = path->pathdata.Count;
360
361 memcpy(&path->pathdata.Points[old_count], points, count*sizeof(GpPointF));
362 memset(&path->pathdata.Types[old_count + 1], PathPointTypeLine, count - 1);
363
364 /* A polygon is an intrinsic figure */
365 path->pathdata.Types[old_count] = PathPointTypeStart;
366 path->pathdata.Types[old_count + count - 1] |= PathPointTypeCloseSubpath;
367 path->newfigure = TRUE;
368 path->pathdata.Count += count;
369
370 return Ok;
371 }
372
373 GpStatus WINGDIPAPI GdipAddPathPolygonI(GpPath *path, GDIPCONST GpPoint *points, INT count)
374 {
375 GpPointF *ptf;
376 GpStatus status;
377 INT i;
378
379 if(!points || count < 3)
380 return InvalidParameter;
381
382 ptf = GdipAlloc(sizeof(GpPointF) * count);
383 if(!ptf)
384 return OutOfMemory;
385
386 for(i = 0; i < count; i++){
387 ptf[i].X = (REAL)points[i].X;
388 ptf[i].Y = (REAL)points[i].Y;
389 }
390
391 status = GdipAddPathPolygon(path, ptf, count);
392
393 GdipFree(ptf);
394
395 return status;
396 }
397
398 GpStatus WINGDIPAPI GdipClonePath(GpPath* path, GpPath **clone)
399 {
400 if(!path || !clone)
401 return InvalidParameter;
402
403 *clone = GdipAlloc(sizeof(GpPath));
404 if(!*clone) return OutOfMemory;
405
406 **clone = *path;
407
408 (*clone)->pathdata.Points = GdipAlloc(path->datalen * sizeof(PointF));
409 (*clone)->pathdata.Types = GdipAlloc(path->datalen);
410 if(!(*clone)->pathdata.Points || !(*clone)->pathdata.Types){
411 GdipFree(*clone);
412 GdipFree((*clone)->pathdata.Points);
413 GdipFree((*clone)->pathdata.Types);
414 return OutOfMemory;
415 }
416
417 memcpy((*clone)->pathdata.Points, path->pathdata.Points,
418 path->datalen * sizeof(PointF));
419 memcpy((*clone)->pathdata.Types, path->pathdata.Types, path->datalen);
420
421 return Ok;
422 }
423
424 GpStatus WINGDIPAPI GdipClosePathFigure(GpPath* path)
425 {
426 if(!path)
427 return InvalidParameter;
428
429 if(path->pathdata.Count > 0){
430 path->pathdata.Types[path->pathdata.Count - 1] |= PathPointTypeCloseSubpath;
431 path->newfigure = TRUE;
432 }
433
434 return Ok;
435 }
436
437 GpStatus WINGDIPAPI GdipClosePathFigures(GpPath* path)
438 {
439 INT i;
440
441 if(!path)
442 return InvalidParameter;
443
444 for(i = 1; i < path->pathdata.Count; i++){
445 if(path->pathdata.Types[i] == PathPointTypeStart)
446 path->pathdata.Types[i-1] |= PathPointTypeCloseSubpath;
447 }
448
449 path->newfigure = TRUE;
450
451 return Ok;
452 }
453
454 GpStatus WINGDIPAPI GdipCreatePath(GpFillMode fill, GpPath **path)
455 {
456 if(!path)
457 return InvalidParameter;
458
459 *path = GdipAlloc(sizeof(GpPath));
460 if(!*path) return OutOfMemory;
461
462 (*path)->fill = fill;
463 (*path)->newfigure = TRUE;
464
465 return Ok;
466 }
467
468 GpStatus WINGDIPAPI GdipCreatePath2(GDIPCONST GpPointF* points,
469 GDIPCONST BYTE* types, INT count, GpFillMode fill, GpPath **path)
470 {
471 if(!path)
472 return InvalidParameter;
473
474 *path = GdipAlloc(sizeof(GpPath));
475 if(!*path) return OutOfMemory;
476
477 (*path)->pathdata.Points = GdipAlloc(count * sizeof(PointF));
478 (*path)->pathdata.Types = GdipAlloc(count);
479
480 if(!(*path)->pathdata.Points || !(*path)->pathdata.Types){
481 GdipFree((*path)->pathdata.Points);
482 GdipFree((*path)->pathdata.Types);
483 GdipFree(*path);
484 return OutOfMemory;
485 }
486
487 memcpy((*path)->pathdata.Points, points, count * sizeof(PointF));
488 memcpy((*path)->pathdata.Types, types, count);
489 (*path)->pathdata.Count = count;
490 (*path)->datalen = count;
491
492 (*path)->fill = fill;
493 (*path)->newfigure = TRUE;
494
495 return Ok;
496 }
497
498 GpStatus WINGDIPAPI GdipCreatePath2I(GDIPCONST GpPoint* points,
499 GDIPCONST BYTE* types, INT count, GpFillMode fill, GpPath **path)
500 {
501 GpPointF *ptF;
502 GpStatus ret;
503 INT i;
504
505 ptF = GdipAlloc(sizeof(GpPointF)*count);
506
507 for(i = 0;i < count; i++){
508 ptF[i].X = (REAL)points[i].X;
509 ptF[i].Y = (REAL)points[i].Y;
510 }
511
512 ret = GdipCreatePath2(ptF, types, count, fill, path);
513
514 GdipFree(ptF);
515
516 return ret;
517 }
518
519 GpStatus WINGDIPAPI GdipDeletePath(GpPath *path)
520 {
521 if(!path)
522 return InvalidParameter;
523
524 GdipFree(path->pathdata.Points);
525 GdipFree(path->pathdata.Types);
526 GdipFree(path);
527
528 return Ok;
529 }
530
531 GpStatus WINGDIPAPI GdipGetPathData(GpPath *path, GpPathData* pathData)
532 {
533 if(!path || !pathData)
534 return InvalidParameter;
535
536 /* Only copy data. pathData allocation/freeing controlled by wrapper class.
537 Assumed that pathData is enough wide to get all data - controlled by wrapper too. */
538 memcpy(pathData->Points, path->pathdata.Points, sizeof(PointF) * pathData->Count);
539 memcpy(pathData->Types , path->pathdata.Types , pathData->Count);
540
541 return Ok;
542 }
543
544 GpStatus WINGDIPAPI GdipGetPathFillMode(GpPath *path, GpFillMode *fillmode)
545 {
546 if(!path || !fillmode)
547 return InvalidParameter;
548
549 *fillmode = path->fill;
550
551 return Ok;
552 }
553
554 GpStatus WINGDIPAPI GdipGetPathLastPoint(GpPath* path, GpPointF* lastPoint)
555 {
556 INT count;
557
558 if(!path || !lastPoint)
559 return InvalidParameter;
560
561 count = path->pathdata.Count;
562 if(count > 0)
563 *lastPoint = path->pathdata.Points[count-1];
564
565 return Ok;
566 }
567
568 GpStatus WINGDIPAPI GdipGetPathPoints(GpPath *path, GpPointF* points, INT count)
569 {
570 if(!path)
571 return InvalidParameter;
572
573 if(count < path->pathdata.Count)
574 return InsufficientBuffer;
575
576 memcpy(points, path->pathdata.Points, path->pathdata.Count * sizeof(GpPointF));
577
578 return Ok;
579 }
580
581 GpStatus WINGDIPAPI GdipGetPathPointsI(GpPath *path, GpPoint* points, INT count)
582 {
583 GpStatus ret;
584 GpPointF *ptf;
585 INT i;
586
587 if(count <= 0)
588 return InvalidParameter;
589
590 ptf = GdipAlloc(sizeof(GpPointF)*count);
591 if(!ptf) return OutOfMemory;
592
593 ret = GdipGetPathPoints(path,ptf,count);
594 if(ret == Ok)
595 for(i = 0;i < count;i++){
596 points[i].X = roundr(ptf[i].X);
597 points[i].Y = roundr(ptf[i].Y);
598 };
599 GdipFree(ptf);
600
601 return ret;
602 }
603
604 GpStatus WINGDIPAPI GdipGetPathTypes(GpPath *path, BYTE* types, INT count)
605 {
606 if(!path)
607 return InvalidParameter;
608
609 if(count < path->pathdata.Count)
610 return InsufficientBuffer;
611
612 memcpy(types, path->pathdata.Types, path->pathdata.Count);
613
614 return Ok;
615 }
616
617 /* Windows expands the bounding box to the maximum possible bounding box
618 * for a given pen. For example, if a line join can extend past the point
619 * it's joining by x units, the bounding box is extended by x units in every
620 * direction (even though this is too conservative for most cases). */
621 GpStatus WINGDIPAPI GdipGetPathWorldBounds(GpPath* path, GpRectF* bounds,
622 GDIPCONST GpMatrix *matrix, GDIPCONST GpPen *pen)
623 {
624 GpPointF * points, temp_pts[4];
625 INT count, i;
626 REAL path_width = 1.0, width, height, temp, low_x, low_y, high_x, high_y;
627
628 /* Matrix and pen can be null. */
629 if(!path || !bounds)
630 return InvalidParameter;
631
632 /* If path is empty just return. */
633 count = path->pathdata.Count;
634 if(count == 0){
635 bounds->X = bounds->Y = bounds->Width = bounds->Height = 0.0;
636 return Ok;
637 }
638
639 points = path->pathdata.Points;
640
641 low_x = high_x = points[0].X;
642 low_y = high_y = points[0].Y;
643
644 for(i = 1; i < count; i++){
645 low_x = min(low_x, points[i].X);
646 low_y = min(low_y, points[i].Y);
647 high_x = max(high_x, points[i].X);
648 high_y = max(high_y, points[i].Y);
649 }
650
651 width = high_x - low_x;
652 height = high_y - low_y;
653
654 /* This looks unusual but it's the only way I can imitate windows. */
655 if(matrix){
656 temp_pts[0].X = low_x;
657 temp_pts[0].Y = low_y;
658 temp_pts[1].X = low_x;
659 temp_pts[1].Y = high_y;
660 temp_pts[2].X = high_x;
661 temp_pts[2].Y = high_y;
662 temp_pts[3].X = high_x;
663 temp_pts[3].Y = low_y;
664
665 GdipTransformMatrixPoints((GpMatrix*)matrix, temp_pts, 4);
666 low_x = temp_pts[0].X;
667 low_y = temp_pts[0].Y;
668
669 for(i = 1; i < 4; i++){
670 low_x = min(low_x, temp_pts[i].X);
671 low_y = min(low_y, temp_pts[i].Y);
672 }
673
674 temp = width;
675 width = height * fabs(matrix->matrix[2]) + width * fabs(matrix->matrix[0]);
676 height = height * fabs(matrix->matrix[3]) + temp * fabs(matrix->matrix[1]);
677 }
678
679 if(pen){
680 path_width = pen->width / 2.0;
681
682 if(count > 2)
683 path_width = max(path_width, pen->width * pen->miterlimit / 2.0);
684 /* FIXME: this should probably also check for the startcap */
685 if(pen->endcap & LineCapNoAnchor)
686 path_width = max(path_width, pen->width * 2.2);
687
688 low_x -= path_width;
689 low_y -= path_width;
690 width += 2.0 * path_width;
691 height += 2.0 * path_width;
692 }
693
694 bounds->X = low_x;
695 bounds->Y = low_y;
696 bounds->Width = width;
697 bounds->Height = height;
698
699 return Ok;
700 }
701
702 GpStatus WINGDIPAPI GdipGetPathWorldBoundsI(GpPath* path, GpRect* bounds,
703 GDIPCONST GpMatrix *matrix, GDIPCONST GpPen *pen)
704 {
705 GpStatus ret;
706 GpRectF boundsF;
707
708 ret = GdipGetPathWorldBounds(path,&boundsF,matrix,pen);
709
710 if(ret == Ok){
711 bounds->X = roundr(boundsF.X);
712 bounds->Y = roundr(boundsF.Y);
713 bounds->Width = roundr(boundsF.Width);
714 bounds->Height = roundr(boundsF.Height);
715 }
716
717 return ret;
718 }
719
720 GpStatus WINGDIPAPI GdipGetPointCount(GpPath *path, INT *count)
721 {
722 if(!path)
723 return InvalidParameter;
724
725 *count = path->pathdata.Count;
726
727 return Ok;
728 }
729
730 GpStatus WINGDIPAPI GdipIsOutlineVisiblePathPointI(GpPath* path, INT x, INT y,
731 GpPen *pen, GpGraphics *graphics, BOOL *result)
732 {
733 static int calls;
734
735 if(!path || !pen)
736 return InvalidParameter;
737
738 if(!(calls++))
739 FIXME("not implemented\n");
740
741 return NotImplemented;
742 }
743
744 GpStatus WINGDIPAPI GdipStartPathFigure(GpPath *path)
745 {
746 if(!path)
747 return InvalidParameter;
748
749 path->newfigure = TRUE;
750
751 return Ok;
752 }
753
754 GpStatus WINGDIPAPI GdipResetPath(GpPath *path)
755 {
756 if(!path)
757 return InvalidParameter;
758
759 path->pathdata.Count = 0;
760 path->newfigure = TRUE;
761 path->fill = FillModeAlternate;
762
763 return Ok;
764 }
765
766 GpStatus WINGDIPAPI GdipSetPathFillMode(GpPath *path, GpFillMode fill)
767 {
768 if(!path)
769 return InvalidParameter;
770
771 path->fill = fill;
772
773 return Ok;
774 }
775
776 GpStatus WINGDIPAPI GdipTransformPath(GpPath *path, GpMatrix *matrix)
777 {
778 if(!path)
779 return InvalidParameter;
780
781 if(path->pathdata.Count == 0)
782 return Ok;
783
784 return GdipTransformMatrixPoints(matrix, path->pathdata.Points,
785 path->pathdata.Count);
786 }
787
788 GpStatus WINGDIPAPI GdipAddPathRectangle(GpPath *path, REAL x, REAL y,
789 REAL width, REAL height)
790 {
791 GpPath *backup;
792 GpPointF ptf[2];
793 GpStatus retstat;
794 BOOL old_new;
795
796 if(!path || width < 0.0 || height < 0.0)
797 return InvalidParameter;
798
799 /* make a backup copy of path data */
800 if((retstat = GdipClonePath(path, &backup)) != Ok)
801 return retstat;
802
803 /* rectangle should start as new path */
804 old_new = path->newfigure;
805 path->newfigure = TRUE;
806 if((retstat = GdipAddPathLine(path,x,y,x+width,y)) != Ok){
807 path->newfigure = old_new;
808 goto fail;
809 }
810
811 ptf[0].X = x+width;
812 ptf[0].Y = y+height;
813 ptf[1].X = x;
814 ptf[1].Y = y+height;
815
816 if((retstat = GdipAddPathLine2(path, ptf, 2)) != Ok) goto fail;
817 path->pathdata.Types[path->pathdata.Count-1] |= PathPointTypeCloseSubpath;
818
819 /* free backup */
820 GdipDeletePath(backup);
821 return Ok;
822
823 fail:
824 /* reverting */
825 GdipDeletePath(path);
826 GdipClonePath(backup, &path);
827 GdipDeletePath(backup);
828
829 return retstat;
830 }
831
832 GpStatus WINGDIPAPI GdipAddPathRectangleI(GpPath *path, INT x, INT y,
833 INT width, INT height)
834 {
835 return GdipAddPathRectangle(path,(REAL)x,(REAL)y,(REAL)width,(REAL)height);
836 }
837
838 GpStatus WINGDIPAPI GdipAddPathRectangles(GpPath *path, GDIPCONST GpRectF *rects, INT count)
839 {
840 GpPath *backup;
841 GpStatus retstat;
842 INT i;
843
844 /* count == 0 - verified condition */
845 if(!path || !rects || count == 0)
846 return InvalidParameter;
847
848 if(count < 0)
849 return OutOfMemory;
850
851 /* make a backup copy */
852 if((retstat = GdipClonePath(path, &backup)) != Ok)
853 return retstat;
854
855 for(i = 0; i < count; i++){
856 if((retstat = GdipAddPathRectangle(path,rects[i].X,rects[i].Y,rects[i].Width,rects[i].Height)) != Ok)
857 goto fail;
858 }
859
860 /* free backup */
861 GdipDeletePath(backup);
862 return Ok;
863
864 fail:
865 /* reverting */
866 GdipDeletePath(path);
867 GdipClonePath(backup, &path);
868 GdipDeletePath(backup);
869
870 return retstat;
871 }
872
873 GpStatus WINGDIPAPI GdipAddPathRectanglesI(GpPath *path, GDIPCONST GpRect *rects, INT count)
874 {
875 GpRectF *rectsF;
876 GpStatus retstat;
877 INT i;
878
879 if(!rects || count == 0)
880 return InvalidParameter;
881
882 if(count < 0)
883 return OutOfMemory;
884
885 rectsF = GdipAlloc(sizeof(GpRectF)*count);
886
887 for(i = 0;i < count;i++){
888 rectsF[i].X = (REAL)rects[i].X;
889 rectsF[i].Y = (REAL)rects[i].Y;
890 rectsF[i].Width = (REAL)rects[i].Width;
891 rectsF[i].Height = (REAL)rects[i].Height;
892 }
893
894 retstat = GdipAddPathRectangles(path, rectsF, count);
895 GdipFree(rectsF);
896
897 return retstat;
898 }
899
900 GpStatus WINGDIPAPI GdipSetPathMarker(GpPath* path)
901 {
902 INT count;
903
904 if(!path)
905 return InvalidParameter;
906
907 count = path->pathdata.Count;
908
909 /* set marker flag */
910 if(count > 0)
911 path->pathdata.Types[count-1] |= PathPointTypePathMarker;
912
913 return Ok;
914 }
915
916 GpStatus WINGDIPAPI GdipClearPathMarkers(GpPath* path)
917 {
918 INT count;
919 INT i;
920
921 if(!path)
922 return InvalidParameter;
923
924 count = path->pathdata.Count;
925
926 for(i = 0; i < count - 1; i++){
927 path->pathdata.Types[i] &= ~PathPointTypePathMarker;
928 }
929
930 return Ok;
931 }