ntdll: Fix race in NtRead/WriteFile.
[wine/testsucceed.git] / dlls / gdiplus / graphicspath.c
blob60ddda1d7b54c72cb1bc09a39d19c386ae9d45a0
1 /*
2 * Copyright (C) 2007 Google (Evan Stade)
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.
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.
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
20 #include <stdarg.h>
21 #include <math.h>
23 #include "windef.h"
24 #include "winbase.h"
25 #include "winuser.h"
26 #include "wingdi.h"
28 #include "objbase.h"
30 #include "gdiplus.h"
31 #include "gdiplus_private.h"
32 #include "wine/debug.h"
34 WINE_DEFAULT_DEBUG_CHANNEL(gdiplus);
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;
43 /* init list */
44 static BOOL init_path_list(path_list_node_t **node, REAL x, REAL y)
46 *node = GdipAlloc(sizeof(path_list_node_t));
47 if(!*node)
48 return FALSE;
50 (*node)->pt.X = x;
51 (*node)->pt.Y = y;
52 (*node)->type = PathPointTypeStart;
53 (*node)->next = NULL;
55 return TRUE;
58 /* free all nodes including argument */
59 static void free_path_list(path_list_node_t *node)
61 path_list_node_t *n = node;
63 while(n){
64 n = n->next;
65 GdipFree(node);
66 node = n;
70 /* Add a node after 'node' */
72 * Returns
73 * pointer on success
74 * NULL on allocation problems
76 static path_list_node_t* add_path_list_node(path_list_node_t *node, REAL x, REAL y, BOOL type)
78 path_list_node_t *new;
80 new = GdipAlloc(sizeof(path_list_node_t));
81 if(!new)
82 return NULL;
84 new->pt.X = x;
85 new->pt.Y = y;
86 new->type = type;
87 new->next = node->next;
88 node->next = new;
90 return new;
93 /* returns element count */
94 static INT path_list_count(path_list_node_t *node)
96 INT count = 1;
98 while((node = node->next))
99 ++count;
101 return count;
104 /* GdipFlattenPath helper */
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.
114 * Return value:
115 * TRUE : success
116 * FALSE: out of memory
118 * TODO: used quality criteria should be revised to match native as
119 * closer as possible.
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)
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;
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;
142 mp[2].X = (mp[1].X + mp[3].X) / 2.0;
143 mp[2].Y = (mp[1].Y + mp[3].Y) / 2.0;
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;
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;
158 /* do the same with halfs */
159 flatten_bezier(start, mp[0].X, mp[0].Y, mp[1].X, mp[1].Y, node, flatness);
160 flatten_bezier(node, mp[3].X, mp[3].Y, mp[4].X, mp[4].Y, end, flatness);
162 return TRUE;
165 GpStatus WINGDIPAPI GdipAddPathArc(GpPath *path, REAL x1, REAL y1, REAL x2,
166 REAL y2, REAL startAngle, REAL sweepAngle)
168 INT count, old_count, i;
170 TRACE("(%p, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f)\n",
171 path, x1, y1, x2, y2, startAngle, sweepAngle);
173 if(!path)
174 return InvalidParameter;
176 count = arc2polybezier(NULL, x1, y1, x2, y2, startAngle, sweepAngle);
178 if(count == 0)
179 return Ok;
180 if(!lengthen_path(path, count))
181 return OutOfMemory;
183 old_count = path->pathdata.Count;
184 arc2polybezier(&path->pathdata.Points[old_count], x1, y1, x2, y2,
185 startAngle, sweepAngle);
187 for(i = 0; i < count; i++){
188 path->pathdata.Types[old_count + i] = PathPointTypeBezier;
191 path->pathdata.Types[old_count] =
192 (path->newfigure ? PathPointTypeStart : PathPointTypeLine);
193 path->newfigure = FALSE;
194 path->pathdata.Count += count;
196 return Ok;
199 GpStatus WINGDIPAPI GdipAddPathArcI(GpPath *path, INT x1, INT y1, INT x2,
200 INT y2, REAL startAngle, REAL sweepAngle)
202 TRACE("(%p, %d, %d, %d, %d, %.2f, %.2f)\n",
203 path, x1, y1, x2, y2, startAngle, sweepAngle);
205 return GdipAddPathArc(path,(REAL)x1,(REAL)y1,(REAL)x2,(REAL)y2,startAngle,sweepAngle);
208 GpStatus WINGDIPAPI GdipAddPathBezier(GpPath *path, REAL x1, REAL y1, REAL x2,
209 REAL y2, REAL x3, REAL y3, REAL x4, REAL y4)
211 INT old_count;
213 TRACE("(%p, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f)\n",
214 path, x1, y1, x2, y2, x3, y3, x4, y4);
216 if(!path)
217 return InvalidParameter;
219 if(!lengthen_path(path, 4))
220 return OutOfMemory;
222 old_count = path->pathdata.Count;
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;
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;
239 path->newfigure = FALSE;
240 path->pathdata.Count += 4;
242 return Ok;
245 GpStatus WINGDIPAPI GdipAddPathBezierI(GpPath *path, INT x1, INT y1, INT x2,
246 INT y2, INT x3, INT y3, INT x4, INT y4)
248 TRACE("(%p, %d, %d, %d, %d, %d, %d, %d, %d)\n",
249 path, x1, y1, x2, y2, x3, y3, x4, y4);
251 return GdipAddPathBezier(path,(REAL)x1,(REAL)y1,(REAL)x2,(REAL)y2,(REAL)x3,(REAL)y3,
252 (REAL)x4,(REAL)y4);
255 GpStatus WINGDIPAPI GdipAddPathBeziers(GpPath *path, GDIPCONST GpPointF *points,
256 INT count)
258 INT i, old_count;
260 TRACE("(%p, %p, %d)\n", path, points, count);
262 if(!path || !points || ((count - 1) % 3))
263 return InvalidParameter;
265 if(!lengthen_path(path, count))
266 return OutOfMemory;
268 old_count = path->pathdata.Count;
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;
276 path->pathdata.Types[old_count] =
277 (path->newfigure ? PathPointTypeStart : PathPointTypeLine);
278 path->newfigure = FALSE;
279 path->pathdata.Count += count;
281 return Ok;
284 GpStatus WINGDIPAPI GdipAddPathBeziersI(GpPath *path, GDIPCONST GpPoint *points,
285 INT count)
287 GpPointF *ptsF;
288 GpStatus ret;
289 INT i;
291 TRACE("(%p, %p, %d)\n", path, points, count);
293 if(!points || ((count - 1) % 3))
294 return InvalidParameter;
296 ptsF = GdipAlloc(sizeof(GpPointF) * count);
297 if(!ptsF)
298 return OutOfMemory;
300 for(i = 0; i < count; i++){
301 ptsF[i].X = (REAL)points[i].X;
302 ptsF[i].Y = (REAL)points[i].Y;
305 ret = GdipAddPathBeziers(path, ptsF, count);
306 GdipFree(ptsF);
308 return ret;
311 GpStatus WINGDIPAPI GdipAddPathClosedCurve(GpPath *path, GDIPCONST GpPointF *points,
312 INT count)
314 TRACE("(%p, %p, %d)\n", path, points, count);
316 return GdipAddPathClosedCurve2(path, points, count, 1.0);
319 GpStatus WINGDIPAPI GdipAddPathClosedCurveI(GpPath *path, GDIPCONST GpPoint *points,
320 INT count)
322 TRACE("(%p, %p, %d)\n", path, points, count);
324 return GdipAddPathClosedCurve2I(path, points, count, 1.0);
327 GpStatus WINGDIPAPI GdipAddPathClosedCurve2(GpPath *path, GDIPCONST GpPointF *points,
328 INT count, REAL tension)
330 INT i, len_pt = (count + 1)*3-2;
331 GpPointF *pt;
332 GpPointF *pts;
333 REAL x1, x2, y1, y2;
334 GpStatus stat;
336 TRACE("(%p, %p, %d, %.2f)\n", path, points, count, tension);
338 if(!path || !points || count <= 1)
339 return InvalidParameter;
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;
349 /* copy source points to extend with the last one */
350 memcpy(pts, points, sizeof(GpPointF)*count);
351 pts[count] = pts[0];
353 tension = tension * TENSION_CONST;
355 for(i = 0; i < count-1; i++){
356 calc_curve_bezier(&(pts[i]), tension, &x1, &y1, &x2, &y2);
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;
366 /* points [len_pt-2] and [0] are calculated
367 separetely 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];
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;
383 stat = GdipAddPathBeziers(path, pt, len_pt);
385 /* close figure */
386 if(stat == Ok){
387 INT count = path->pathdata.Count;
388 path->pathdata.Types[count - 1] |= PathPointTypeCloseSubpath;
389 path->newfigure = TRUE;
392 GdipFree(pts);
393 GdipFree(pt);
395 return stat;
398 GpStatus WINGDIPAPI GdipAddPathClosedCurve2I(GpPath *path, GDIPCONST GpPoint *points,
399 INT count, REAL tension)
401 GpPointF *ptf;
402 INT i;
403 GpStatus stat;
405 TRACE("(%p, %p, %d, %.2f)\n", path, points, count, tension);
407 if(!path || !points || count <= 1)
408 return InvalidParameter;
410 ptf = GdipAlloc(sizeof(GpPointF)*count);
411 if(!ptf)
412 return OutOfMemory;
414 for(i = 0; i < count; i++){
415 ptf[i].X = (REAL)points[i].X;
416 ptf[i].Y = (REAL)points[i].Y;
419 stat = GdipAddPathClosedCurve2(path, ptf, count, tension);
421 GdipFree(ptf);
423 return stat;
426 GpStatus WINGDIPAPI GdipAddPathCurve(GpPath *path, GDIPCONST GpPointF *points, INT count)
428 TRACE("(%p, %p, %d)\n", path, points, count);
430 if(!path || !points || count <= 1)
431 return InvalidParameter;
433 return GdipAddPathCurve2(path, points, count, 1.0);
436 GpStatus WINGDIPAPI GdipAddPathCurveI(GpPath *path, GDIPCONST GpPoint *points, INT count)
438 TRACE("(%p, %p, %d)\n", path, points, count);
440 if(!path || !points || count <= 1)
441 return InvalidParameter;
443 return GdipAddPathCurve2I(path, points, count, 1.0);
446 GpStatus WINGDIPAPI GdipAddPathCurve2(GpPath *path, GDIPCONST GpPointF *points, INT count,
447 REAL tension)
449 INT i, len_pt = count*3-2;
450 GpPointF *pt;
451 REAL x1, x2, y1, y2;
452 GpStatus stat;
454 TRACE("(%p, %p, %d, %.2f)\n", path, points, count, tension);
456 if(!path || !points || count <= 1)
457 return InvalidParameter;
459 pt = GdipAlloc(len_pt * sizeof(GpPointF));
460 if(!pt)
461 return OutOfMemory;
463 tension = tension * TENSION_CONST;
465 calc_curve_bezier_endp(points[0].X, points[0].Y, points[1].X, points[1].Y,
466 tension, &x1, &y1);
468 pt[0].X = points[0].X;
469 pt[0].Y = points[0].Y;
470 pt[1].X = x1;
471 pt[1].Y = y1;
473 for(i = 0; i < count-2; i++){
474 calc_curve_bezier(&(points[i]), tension, &x1, &y1, &x2, &y2);
476 pt[3*i+2].X = x1;
477 pt[3*i+2].Y = y1;
478 pt[3*i+3].X = points[i+1].X;
479 pt[3*i+3].Y = points[i+1].Y;
480 pt[3*i+4].X = x2;
481 pt[3*i+4].Y = y2;
484 calc_curve_bezier_endp(points[count-1].X, points[count-1].Y,
485 points[count-2].X, points[count-2].Y, tension, &x1, &y1);
487 pt[len_pt-2].X = x1;
488 pt[len_pt-2].Y = y1;
489 pt[len_pt-1].X = points[count-1].X;
490 pt[len_pt-1].Y = points[count-1].Y;
492 stat = GdipAddPathBeziers(path, pt, len_pt);
494 GdipFree(pt);
496 return stat;
499 GpStatus WINGDIPAPI GdipAddPathCurve2I(GpPath *path, GDIPCONST GpPoint *points,
500 INT count, REAL tension)
502 GpPointF *ptf;
503 INT i;
504 GpStatus stat;
506 TRACE("(%p, %p, %d, %.2f)\n", path, points, count, tension);
508 if(!path || !points || count <= 1)
509 return InvalidParameter;
511 ptf = GdipAlloc(sizeof(GpPointF)*count);
512 if(!ptf)
513 return OutOfMemory;
515 for(i = 0; i < count; i++){
516 ptf[i].X = (REAL)points[i].X;
517 ptf[i].Y = (REAL)points[i].Y;
520 stat = GdipAddPathCurve2(path, ptf, count, tension);
522 GdipFree(ptf);
524 return stat;
527 GpStatus WINGDIPAPI GdipAddPathCurve3(GpPath *path, GDIPCONST GpPointF *points,
528 INT count, INT offset, INT nseg, REAL tension)
530 TRACE("(%p, %p, %d, %d, %d, %.2f)\n", path, points, count, offset, nseg, tension);
532 if(!path || !points || offset + 1 >= count || count - offset < nseg + 1)
533 return InvalidParameter;
535 return GdipAddPathCurve2(path, &points[offset], nseg + 1, tension);
538 GpStatus WINGDIPAPI GdipAddPathCurve3I(GpPath *path, GDIPCONST GpPoint *points,
539 INT count, INT offset, INT nseg, REAL tension)
541 TRACE("(%p, %p, %d, %d, %d, %.2f)\n", path, points, count, offset, nseg, tension);
543 if(!path || !points || offset + 1 >= count || count - offset < nseg + 1)
544 return InvalidParameter;
546 return GdipAddPathCurve2I(path, &points[offset], nseg + 1, tension);
549 GpStatus WINGDIPAPI GdipAddPathEllipse(GpPath *path, REAL x, REAL y, REAL width,
550 REAL height)
552 INT old_count, numpts;
554 TRACE("(%p, %.2f, %.2f, %.2f, %.2f)\n", path, x, y, width, height);
556 if(!path)
557 return InvalidParameter;
559 if(!lengthen_path(path, MAX_ARC_PTS))
560 return OutOfMemory;
562 old_count = path->pathdata.Count;
563 if((numpts = arc2polybezier(&path->pathdata.Points[old_count], x, y, width,
564 height, 0.0, 360.0)) != MAX_ARC_PTS){
565 ERR("expected %d points but got %d\n", MAX_ARC_PTS, numpts);
566 return GenericError;
569 memset(&path->pathdata.Types[old_count + 1], PathPointTypeBezier,
570 MAX_ARC_PTS - 1);
572 /* An ellipse is an intrinsic figure (always is its own subpath). */
573 path->pathdata.Types[old_count] = PathPointTypeStart;
574 path->pathdata.Types[old_count + MAX_ARC_PTS - 1] |= PathPointTypeCloseSubpath;
575 path->newfigure = TRUE;
576 path->pathdata.Count += MAX_ARC_PTS;
578 return Ok;
581 GpStatus WINGDIPAPI GdipAddPathEllipseI(GpPath *path, INT x, INT y, INT width,
582 INT height)
584 TRACE("(%p, %d, %d, %d, %d)\n", path, x, y, width, height);
586 return GdipAddPathEllipse(path,(REAL)x,(REAL)y,(REAL)width,(REAL)height);
589 GpStatus WINGDIPAPI GdipAddPathLine2(GpPath *path, GDIPCONST GpPointF *points,
590 INT count)
592 INT i, old_count;
594 TRACE("(%p, %p, %d)\n", path, points, count);
596 if(!path || !points)
597 return InvalidParameter;
599 if(!lengthen_path(path, count))
600 return OutOfMemory;
602 old_count = path->pathdata.Count;
604 for(i = 0; i < count; i++){
605 path->pathdata.Points[old_count + i].X = points[i].X;
606 path->pathdata.Points[old_count + i].Y = points[i].Y;
607 path->pathdata.Types[old_count + i] = PathPointTypeLine;
610 if(path->newfigure){
611 path->pathdata.Types[old_count] = PathPointTypeStart;
612 path->newfigure = FALSE;
615 path->pathdata.Count += count;
617 return Ok;
620 GpStatus WINGDIPAPI GdipAddPathLine2I(GpPath *path, GDIPCONST GpPoint *points, INT count)
622 GpPointF *pointsF;
623 INT i;
624 GpStatus stat;
626 TRACE("(%p, %p, %d)\n", path, points, count);
628 if(count <= 0)
629 return InvalidParameter;
631 pointsF = GdipAlloc(sizeof(GpPointF) * count);
632 if(!pointsF) return OutOfMemory;
634 for(i = 0;i < count; i++){
635 pointsF[i].X = (REAL)points[i].X;
636 pointsF[i].Y = (REAL)points[i].Y;
639 stat = GdipAddPathLine2(path, pointsF, count);
641 GdipFree(pointsF);
643 return stat;
646 GpStatus WINGDIPAPI GdipAddPathLine(GpPath *path, REAL x1, REAL y1, REAL x2, REAL y2)
648 INT old_count;
650 TRACE("(%p, %.2f, %.2f, %.2f, %.2f)\n", path, x1, y1, x2, y2);
652 if(!path)
653 return InvalidParameter;
655 if(!lengthen_path(path, 2))
656 return OutOfMemory;
658 old_count = path->pathdata.Count;
660 path->pathdata.Points[old_count].X = x1;
661 path->pathdata.Points[old_count].Y = y1;
662 path->pathdata.Points[old_count + 1].X = x2;
663 path->pathdata.Points[old_count + 1].Y = y2;
665 path->pathdata.Types[old_count] =
666 (path->newfigure ? PathPointTypeStart : PathPointTypeLine);
667 path->pathdata.Types[old_count + 1] = PathPointTypeLine;
669 path->newfigure = FALSE;
670 path->pathdata.Count += 2;
672 return Ok;
675 GpStatus WINGDIPAPI GdipAddPathLineI(GpPath *path, INT x1, INT y1, INT x2, INT y2)
677 TRACE("(%p, %d, %d, %d, %d)\n", path, x1, y1, x2, y2);
679 return GdipAddPathLine(path, (REAL)x1, (REAL)y1, (REAL)x2, (REAL)y2);
682 GpStatus WINGDIPAPI GdipAddPathPath(GpPath *path, GDIPCONST GpPath* addingPath,
683 BOOL connect)
685 INT old_count, count;
687 TRACE("(%p, %p, %d)\n", path, addingPath, connect);
689 if(!path || !addingPath)
690 return InvalidParameter;
692 old_count = path->pathdata.Count;
693 count = addingPath->pathdata.Count;
695 if(!lengthen_path(path, count))
696 return OutOfMemory;
698 memcpy(&path->pathdata.Points[old_count], addingPath->pathdata.Points,
699 count * sizeof(GpPointF));
700 memcpy(&path->pathdata.Types[old_count], addingPath->pathdata.Types, count);
702 if(path->newfigure || !connect)
703 path->pathdata.Types[old_count] = PathPointTypeStart;
704 else
705 path->pathdata.Types[old_count] = PathPointTypeLine;
707 path->newfigure = FALSE;
708 path->pathdata.Count += count;
710 return Ok;
713 GpStatus WINGDIPAPI GdipAddPathPie(GpPath *path, REAL x, REAL y, REAL width, REAL height,
714 REAL startAngle, REAL sweepAngle)
716 GpPointF *ptf;
717 GpStatus status;
718 INT i, count;
720 TRACE("(%p, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f)\n",
721 path, x, y, width, height, startAngle, sweepAngle);
723 if(!path)
724 return InvalidParameter;
726 /* on zero width/height only start point added */
727 if(width <= 1e-7 || height <= 1e-7){
728 if(!lengthen_path(path, 1))
729 return OutOfMemory;
730 path->pathdata.Points[0].X = x + width / 2.0;
731 path->pathdata.Points[0].Y = y + height / 2.0;
732 path->pathdata.Types[0] = PathPointTypeStart | PathPointTypeCloseSubpath;
733 path->pathdata.Count = 1;
734 return InvalidParameter;
737 count = arc2polybezier(NULL, x, y, width, height, startAngle, sweepAngle);
739 if(count == 0)
740 return Ok;
742 ptf = GdipAlloc(sizeof(GpPointF)*count);
743 if(!ptf)
744 return OutOfMemory;
746 arc2polybezier(ptf, x, y, width, height, startAngle, sweepAngle);
748 status = GdipAddPathLine(path, (width - x)/2, (height - y)/2, ptf[0].X, ptf[0].Y);
749 if(status != Ok){
750 GdipFree(ptf);
751 return status;
753 /* one spline is already added as a line endpoint */
754 if(!lengthen_path(path, count - 1)){
755 GdipFree(ptf);
756 return OutOfMemory;
759 memcpy(&(path->pathdata.Points[path->pathdata.Count]), &(ptf[1]),sizeof(GpPointF)*(count-1));
760 for(i = 0; i < count-1; i++)
761 path->pathdata.Types[path->pathdata.Count+i] = PathPointTypeBezier;
763 path->pathdata.Count += count-1;
765 GdipClosePathFigure(path);
767 GdipFree(ptf);
769 return status;
772 GpStatus WINGDIPAPI GdipAddPathPieI(GpPath *path, INT x, INT y, INT width, INT height,
773 REAL startAngle, REAL sweepAngle)
775 TRACE("(%p, %d, %d, %d, %d, %.2f, %.2f)\n",
776 path, x, y, width, height, startAngle, sweepAngle);
778 return GdipAddPathPie(path, (REAL)x, (REAL)y, (REAL)width, (REAL)height, startAngle, sweepAngle);
781 GpStatus WINGDIPAPI GdipAddPathPolygon(GpPath *path, GDIPCONST GpPointF *points, INT count)
783 INT old_count;
785 TRACE("(%p, %p, %d)\n", path, points, count);
787 if(!path || !points || count < 3)
788 return InvalidParameter;
790 if(!lengthen_path(path, count))
791 return OutOfMemory;
793 old_count = path->pathdata.Count;
795 memcpy(&path->pathdata.Points[old_count], points, count*sizeof(GpPointF));
796 memset(&path->pathdata.Types[old_count + 1], PathPointTypeLine, count - 1);
798 /* A polygon is an intrinsic figure */
799 path->pathdata.Types[old_count] = PathPointTypeStart;
800 path->pathdata.Types[old_count + count - 1] |= PathPointTypeCloseSubpath;
801 path->newfigure = TRUE;
802 path->pathdata.Count += count;
804 return Ok;
807 GpStatus WINGDIPAPI GdipAddPathPolygonI(GpPath *path, GDIPCONST GpPoint *points, INT count)
809 GpPointF *ptf;
810 GpStatus status;
811 INT i;
813 TRACE("(%p, %p, %d)\n", path, points, count);
815 if(!points || count < 3)
816 return InvalidParameter;
818 ptf = GdipAlloc(sizeof(GpPointF) * count);
819 if(!ptf)
820 return OutOfMemory;
822 for(i = 0; i < count; i++){
823 ptf[i].X = (REAL)points[i].X;
824 ptf[i].Y = (REAL)points[i].Y;
827 status = GdipAddPathPolygon(path, ptf, count);
829 GdipFree(ptf);
831 return status;
834 GpStatus WINGDIPAPI GdipAddPathString(GpPath* path, GDIPCONST WCHAR* string, INT length, GDIPCONST GpFontFamily* family, INT style, REAL emSize, GDIPCONST RectF* layoutRect, GDIPCONST GpStringFormat* format)
836 FIXME("(%p, %p, %d, %p, %d, %f, %p, %p): stub\n", path, string, length, family, style, emSize, layoutRect, format);
837 return NotImplemented;
840 GpStatus WINGDIPAPI GdipAddPathStringI(GpPath* path, GDIPCONST WCHAR* string, INT length, GDIPCONST GpFontFamily* family, INT style, REAL emSize, GDIPCONST Rect* layoutRect, GDIPCONST GpStringFormat* format)
842 FIXME("(%p, %p, %d, %p, %d, %f, %p, %p): stub\n", path, string, length, family, style, emSize, layoutRect, format);
843 return NotImplemented;
846 GpStatus WINGDIPAPI GdipClonePath(GpPath* path, GpPath **clone)
848 TRACE("(%p, %p)\n", path, clone);
850 if(!path || !clone)
851 return InvalidParameter;
853 *clone = GdipAlloc(sizeof(GpPath));
854 if(!*clone) return OutOfMemory;
856 **clone = *path;
858 (*clone)->pathdata.Points = GdipAlloc(path->datalen * sizeof(PointF));
859 (*clone)->pathdata.Types = GdipAlloc(path->datalen);
860 if(!(*clone)->pathdata.Points || !(*clone)->pathdata.Types){
861 GdipFree(*clone);
862 GdipFree((*clone)->pathdata.Points);
863 GdipFree((*clone)->pathdata.Types);
864 return OutOfMemory;
867 memcpy((*clone)->pathdata.Points, path->pathdata.Points,
868 path->datalen * sizeof(PointF));
869 memcpy((*clone)->pathdata.Types, path->pathdata.Types, path->datalen);
871 return Ok;
874 GpStatus WINGDIPAPI GdipClosePathFigure(GpPath* path)
876 TRACE("(%p)\n", path);
878 if(!path)
879 return InvalidParameter;
881 if(path->pathdata.Count > 0){
882 path->pathdata.Types[path->pathdata.Count - 1] |= PathPointTypeCloseSubpath;
883 path->newfigure = TRUE;
886 return Ok;
889 GpStatus WINGDIPAPI GdipClosePathFigures(GpPath* path)
891 INT i;
893 TRACE("(%p)\n", path);
895 if(!path)
896 return InvalidParameter;
898 for(i = 1; i < path->pathdata.Count; i++){
899 if(path->pathdata.Types[i] == PathPointTypeStart)
900 path->pathdata.Types[i-1] |= PathPointTypeCloseSubpath;
903 path->newfigure = TRUE;
905 return Ok;
908 GpStatus WINGDIPAPI GdipCreatePath(GpFillMode fill, GpPath **path)
910 TRACE("(%d, %p)\n", fill, path);
912 if(!path)
913 return InvalidParameter;
915 *path = GdipAlloc(sizeof(GpPath));
916 if(!*path) return OutOfMemory;
918 (*path)->fill = fill;
919 (*path)->newfigure = TRUE;
921 return Ok;
924 GpStatus WINGDIPAPI GdipCreatePath2(GDIPCONST GpPointF* points,
925 GDIPCONST BYTE* types, INT count, GpFillMode fill, GpPath **path)
927 TRACE("(%p, %p, %d, %d, %p)\n", points, types, count, fill, path);
929 if(!path)
930 return InvalidParameter;
932 *path = GdipAlloc(sizeof(GpPath));
933 if(!*path) return OutOfMemory;
935 (*path)->pathdata.Points = GdipAlloc(count * sizeof(PointF));
936 (*path)->pathdata.Types = GdipAlloc(count);
938 if(!(*path)->pathdata.Points || !(*path)->pathdata.Types){
939 GdipFree((*path)->pathdata.Points);
940 GdipFree((*path)->pathdata.Types);
941 GdipFree(*path);
942 return OutOfMemory;
945 memcpy((*path)->pathdata.Points, points, count * sizeof(PointF));
946 memcpy((*path)->pathdata.Types, types, count);
947 (*path)->pathdata.Count = count;
948 (*path)->datalen = count;
950 (*path)->fill = fill;
951 (*path)->newfigure = TRUE;
953 return Ok;
956 GpStatus WINGDIPAPI GdipCreatePath2I(GDIPCONST GpPoint* points,
957 GDIPCONST BYTE* types, INT count, GpFillMode fill, GpPath **path)
959 GpPointF *ptF;
960 GpStatus ret;
961 INT i;
963 TRACE("(%p, %p, %d, %d, %p)\n", points, types, count, fill, path);
965 ptF = GdipAlloc(sizeof(GpPointF)*count);
967 for(i = 0;i < count; i++){
968 ptF[i].X = (REAL)points[i].X;
969 ptF[i].Y = (REAL)points[i].Y;
972 ret = GdipCreatePath2(ptF, types, count, fill, path);
974 GdipFree(ptF);
976 return ret;
979 GpStatus WINGDIPAPI GdipDeletePath(GpPath *path)
981 TRACE("(%p)\n", path);
983 if(!path)
984 return InvalidParameter;
986 GdipFree(path->pathdata.Points);
987 GdipFree(path->pathdata.Types);
988 GdipFree(path);
990 return Ok;
993 GpStatus WINGDIPAPI GdipFlattenPath(GpPath *path, GpMatrix* matrix, REAL flatness)
995 path_list_node_t *list, *node;
996 GpPointF pt;
997 INT i = 1;
998 INT startidx = 0;
1000 TRACE("(%p, %p, %.2f)\n", path, matrix, flatness);
1002 if(!path)
1003 return InvalidParameter;
1005 if(matrix){
1006 WARN("transformation not supported yet!\n");
1007 return NotImplemented;
1010 if(path->pathdata.Count == 0)
1011 return Ok;
1013 pt = path->pathdata.Points[0];
1014 if(!init_path_list(&list, pt.X, pt.Y))
1015 return OutOfMemory;
1017 node = list;
1019 while(i < path->pathdata.Count){
1021 BYTE type = path->pathdata.Types[i] & PathPointTypePathTypeMask;
1022 path_list_node_t *start;
1024 pt = path->pathdata.Points[i];
1026 /* save last start point index */
1027 if(type == PathPointTypeStart)
1028 startidx = i;
1030 /* always add line points and start points */
1031 if((type == PathPointTypeStart) || (type == PathPointTypeLine)){
1032 if(!add_path_list_node(node, pt.X, pt.Y, path->pathdata.Types[i]))
1033 goto memout;
1035 node = node->next;
1036 ++i;
1037 continue;
1040 /* Bezier curve always stored as 4 points */
1041 if((path->pathdata.Types[i-1] & PathPointTypePathTypeMask) != PathPointTypeStart){
1042 type = (path->pathdata.Types[i] & ~PathPointTypePathTypeMask) | PathPointTypeLine;
1043 if(!add_path_list_node(node, pt.X, pt.Y, type))
1044 goto memout;
1046 node = node->next;
1049 /* test for closed figure */
1050 if(path->pathdata.Types[i+1] & PathPointTypeCloseSubpath){
1051 pt = path->pathdata.Points[startidx];
1052 ++i;
1054 else
1056 i += 2;
1057 pt = path->pathdata.Points[i];
1060 start = node;
1061 /* add Bezier end point */
1062 type = (path->pathdata.Types[i] & ~PathPointTypePathTypeMask) | PathPointTypeLine;
1063 if(!add_path_list_node(node, pt.X, pt.Y, type))
1064 goto memout;
1065 node = node->next;
1067 /* flatten curve */
1068 if(!flatten_bezier(start, path->pathdata.Points[i-2].X, path->pathdata.Points[i-2].Y,
1069 path->pathdata.Points[i-1].X, path->pathdata.Points[i-1].Y,
1070 node, flatness))
1071 goto memout;
1073 ++i;
1074 }/* while */
1076 /* store path data back */
1077 i = path_list_count(list);
1078 if(!lengthen_path(path, i))
1079 goto memout;
1080 path->pathdata.Count = i;
1082 node = list;
1083 for(i = 0; i < path->pathdata.Count; i++){
1084 path->pathdata.Points[i] = node->pt;
1085 path->pathdata.Types[i] = node->type;
1086 node = node->next;
1089 free_path_list(list);
1090 return Ok;
1092 memout:
1093 free_path_list(list);
1094 return OutOfMemory;
1097 GpStatus WINGDIPAPI GdipGetPathData(GpPath *path, GpPathData* pathData)
1099 TRACE("(%p, %p)\n", path, pathData);
1101 if(!path || !pathData)
1102 return InvalidParameter;
1104 /* Only copy data. pathData allocation/freeing controlled by wrapper class.
1105 Assumed that pathData is enough wide to get all data - controlled by wrapper too. */
1106 memcpy(pathData->Points, path->pathdata.Points, sizeof(PointF) * pathData->Count);
1107 memcpy(pathData->Types , path->pathdata.Types , pathData->Count);
1109 return Ok;
1112 GpStatus WINGDIPAPI GdipGetPathFillMode(GpPath *path, GpFillMode *fillmode)
1114 TRACE("(%p, %p)\n", path, fillmode);
1116 if(!path || !fillmode)
1117 return InvalidParameter;
1119 *fillmode = path->fill;
1121 return Ok;
1124 GpStatus WINGDIPAPI GdipGetPathLastPoint(GpPath* path, GpPointF* lastPoint)
1126 INT count;
1128 TRACE("(%p, %p)\n", path, lastPoint);
1130 if(!path || !lastPoint)
1131 return InvalidParameter;
1133 count = path->pathdata.Count;
1134 if(count > 0)
1135 *lastPoint = path->pathdata.Points[count-1];
1137 return Ok;
1140 GpStatus WINGDIPAPI GdipGetPathPoints(GpPath *path, GpPointF* points, INT count)
1142 TRACE("(%p, %p, %d)\n", path, points, count);
1144 if(!path)
1145 return InvalidParameter;
1147 if(count < path->pathdata.Count)
1148 return InsufficientBuffer;
1150 memcpy(points, path->pathdata.Points, path->pathdata.Count * sizeof(GpPointF));
1152 return Ok;
1155 GpStatus WINGDIPAPI GdipGetPathPointsI(GpPath *path, GpPoint* points, INT count)
1157 GpStatus ret;
1158 GpPointF *ptf;
1159 INT i;
1161 TRACE("(%p, %p, %d)\n", path, points, count);
1163 if(count <= 0)
1164 return InvalidParameter;
1166 ptf = GdipAlloc(sizeof(GpPointF)*count);
1167 if(!ptf) return OutOfMemory;
1169 ret = GdipGetPathPoints(path,ptf,count);
1170 if(ret == Ok)
1171 for(i = 0;i < count;i++){
1172 points[i].X = roundr(ptf[i].X);
1173 points[i].Y = roundr(ptf[i].Y);
1175 GdipFree(ptf);
1177 return ret;
1180 GpStatus WINGDIPAPI GdipGetPathTypes(GpPath *path, BYTE* types, INT count)
1182 TRACE("(%p, %p, %d)\n", path, types, count);
1184 if(!path)
1185 return InvalidParameter;
1187 if(count < path->pathdata.Count)
1188 return InsufficientBuffer;
1190 memcpy(types, path->pathdata.Types, path->pathdata.Count);
1192 return Ok;
1195 /* Windows expands the bounding box to the maximum possible bounding box
1196 * for a given pen. For example, if a line join can extend past the point
1197 * it's joining by x units, the bounding box is extended by x units in every
1198 * direction (even though this is too conservative for most cases). */
1199 GpStatus WINGDIPAPI GdipGetPathWorldBounds(GpPath* path, GpRectF* bounds,
1200 GDIPCONST GpMatrix *matrix, GDIPCONST GpPen *pen)
1202 GpPointF * points, temp_pts[4];
1203 INT count, i;
1204 REAL path_width = 1.0, width, height, temp, low_x, low_y, high_x, high_y;
1206 TRACE("(%p, %p, %p, %p)\n", path, bounds, matrix, pen);
1208 /* Matrix and pen can be null. */
1209 if(!path || !bounds)
1210 return InvalidParameter;
1212 /* If path is empty just return. */
1213 count = path->pathdata.Count;
1214 if(count == 0){
1215 bounds->X = bounds->Y = bounds->Width = bounds->Height = 0.0;
1216 return Ok;
1219 points = path->pathdata.Points;
1221 low_x = high_x = points[0].X;
1222 low_y = high_y = points[0].Y;
1224 for(i = 1; i < count; i++){
1225 low_x = min(low_x, points[i].X);
1226 low_y = min(low_y, points[i].Y);
1227 high_x = max(high_x, points[i].X);
1228 high_y = max(high_y, points[i].Y);
1231 width = high_x - low_x;
1232 height = high_y - low_y;
1234 /* This looks unusual but it's the only way I can imitate windows. */
1235 if(matrix){
1236 temp_pts[0].X = low_x;
1237 temp_pts[0].Y = low_y;
1238 temp_pts[1].X = low_x;
1239 temp_pts[1].Y = high_y;
1240 temp_pts[2].X = high_x;
1241 temp_pts[2].Y = high_y;
1242 temp_pts[3].X = high_x;
1243 temp_pts[3].Y = low_y;
1245 GdipTransformMatrixPoints((GpMatrix*)matrix, temp_pts, 4);
1246 low_x = temp_pts[0].X;
1247 low_y = temp_pts[0].Y;
1249 for(i = 1; i < 4; i++){
1250 low_x = min(low_x, temp_pts[i].X);
1251 low_y = min(low_y, temp_pts[i].Y);
1254 temp = width;
1255 width = height * fabs(matrix->matrix[2]) + width * fabs(matrix->matrix[0]);
1256 height = height * fabs(matrix->matrix[3]) + temp * fabs(matrix->matrix[1]);
1259 if(pen){
1260 path_width = pen->width / 2.0;
1262 if(count > 2)
1263 path_width = max(path_width, pen->width * pen->miterlimit / 2.0);
1264 /* FIXME: this should probably also check for the startcap */
1265 if(pen->endcap & LineCapNoAnchor)
1266 path_width = max(path_width, pen->width * 2.2);
1268 low_x -= path_width;
1269 low_y -= path_width;
1270 width += 2.0 * path_width;
1271 height += 2.0 * path_width;
1274 bounds->X = low_x;
1275 bounds->Y = low_y;
1276 bounds->Width = width;
1277 bounds->Height = height;
1279 return Ok;
1282 GpStatus WINGDIPAPI GdipGetPathWorldBoundsI(GpPath* path, GpRect* bounds,
1283 GDIPCONST GpMatrix *matrix, GDIPCONST GpPen *pen)
1285 GpStatus ret;
1286 GpRectF boundsF;
1288 TRACE("(%p, %p, %p, %p)\n", path, bounds, matrix, pen);
1290 ret = GdipGetPathWorldBounds(path,&boundsF,matrix,pen);
1292 if(ret == Ok){
1293 bounds->X = roundr(boundsF.X);
1294 bounds->Y = roundr(boundsF.Y);
1295 bounds->Width = roundr(boundsF.Width);
1296 bounds->Height = roundr(boundsF.Height);
1299 return ret;
1302 GpStatus WINGDIPAPI GdipGetPointCount(GpPath *path, INT *count)
1304 TRACE("(%p, %p)\n", path, count);
1306 if(!path)
1307 return InvalidParameter;
1309 *count = path->pathdata.Count;
1311 return Ok;
1314 GpStatus WINGDIPAPI GdipReversePath(GpPath* path)
1316 INT i, count;
1317 INT start = 0; /* position in reversed path */
1318 GpPathData revpath;
1320 TRACE("(%p)\n", path);
1322 if(!path)
1323 return InvalidParameter;
1325 count = path->pathdata.Count;
1327 if(count == 0) return Ok;
1329 revpath.Points = GdipAlloc(sizeof(GpPointF)*count);
1330 revpath.Types = GdipAlloc(sizeof(BYTE)*count);
1331 revpath.Count = count;
1332 if(!revpath.Points || !revpath.Types){
1333 GdipFree(revpath.Points);
1334 GdipFree(revpath.Types);
1335 return OutOfMemory;
1338 for(i = 0; i < count; i++){
1340 /* find next start point */
1341 if(path->pathdata.Types[count-i-1] == PathPointTypeStart){
1342 INT j;
1343 for(j = start; j <= i; j++){
1344 revpath.Points[j] = path->pathdata.Points[count-j-1];
1345 revpath.Types[j] = path->pathdata.Types[count-j-1];
1347 /* mark start point */
1348 revpath.Types[start] = PathPointTypeStart;
1349 /* set 'figure' endpoint type */
1350 if(i-start > 1){
1351 revpath.Types[i] = path->pathdata.Types[count-start-1] & ~PathPointTypePathTypeMask;
1352 revpath.Types[i] |= revpath.Types[i-1];
1354 else
1355 revpath.Types[i] = path->pathdata.Types[start];
1357 start = i+1;
1361 memcpy(path->pathdata.Points, revpath.Points, sizeof(GpPointF)*count);
1362 memcpy(path->pathdata.Types, revpath.Types, sizeof(BYTE)*count);
1364 GdipFree(revpath.Points);
1365 GdipFree(revpath.Types);
1367 return Ok;
1370 GpStatus WINGDIPAPI GdipIsOutlineVisiblePathPointI(GpPath* path, INT x, INT y,
1371 GpPen *pen, GpGraphics *graphics, BOOL *result)
1373 TRACE("(%p, %d, %d, %p, %p, %p)\n", path, x, y, pen, graphics, result);
1375 return GdipIsOutlineVisiblePathPoint(path, x, y, pen, graphics, result);
1378 GpStatus WINGDIPAPI GdipIsOutlineVisiblePathPoint(GpPath* path, REAL x, REAL y,
1379 GpPen *pen, GpGraphics *graphics, BOOL *result)
1381 static int calls;
1383 TRACE("(%p,%0.2f,%0.2f,%p,%p,%p)\n", path, x, y, pen, graphics, result);
1385 if(!path || !pen)
1386 return InvalidParameter;
1388 if(!(calls++))
1389 FIXME("not implemented\n");
1391 return NotImplemented;
1394 GpStatus WINGDIPAPI GdipIsVisiblePathPointI(GpPath* path, INT x, INT y, GpGraphics *graphics, BOOL *result)
1396 TRACE("(%p, %d, %d, %p, %p)\n", path, x, y, graphics, result);
1398 return GdipIsVisiblePathPoint(path, x, y, graphics, result);
1401 /*****************************************************************************
1402 * GdipIsVisiblePathPoint [GDIPLUS.@]
1404 GpStatus WINGDIPAPI GdipIsVisiblePathPoint(GpPath* path, REAL x, REAL y, GpGraphics *graphics, BOOL *result)
1406 GpRegion *region;
1407 HRGN hrgn;
1408 GpStatus status;
1410 if(!path || !result) return InvalidParameter;
1412 status = GdipCreateRegionPath(path, &region);
1413 if(status != Ok)
1414 return status;
1416 status = GdipGetRegionHRgn(region, graphics, &hrgn);
1417 if(status != Ok){
1418 GdipDeleteRegion(region);
1419 return status;
1422 *result = PtInRegion(hrgn, roundr(x), roundr(y));
1424 DeleteObject(hrgn);
1425 GdipDeleteRegion(region);
1427 return Ok;
1430 GpStatus WINGDIPAPI GdipStartPathFigure(GpPath *path)
1432 TRACE("(%p)\n", path);
1434 if(!path)
1435 return InvalidParameter;
1437 path->newfigure = TRUE;
1439 return Ok;
1442 GpStatus WINGDIPAPI GdipResetPath(GpPath *path)
1444 TRACE("(%p)\n", path);
1446 if(!path)
1447 return InvalidParameter;
1449 path->pathdata.Count = 0;
1450 path->newfigure = TRUE;
1451 path->fill = FillModeAlternate;
1453 return Ok;
1456 GpStatus WINGDIPAPI GdipSetPathFillMode(GpPath *path, GpFillMode fill)
1458 TRACE("(%p, %d)\n", path, fill);
1460 if(!path)
1461 return InvalidParameter;
1463 path->fill = fill;
1465 return Ok;
1468 GpStatus WINGDIPAPI GdipTransformPath(GpPath *path, GpMatrix *matrix)
1470 TRACE("(%p, %p)\n", path, matrix);
1472 if(!path)
1473 return InvalidParameter;
1475 if(path->pathdata.Count == 0)
1476 return Ok;
1478 return GdipTransformMatrixPoints(matrix, path->pathdata.Points,
1479 path->pathdata.Count);
1482 GpStatus WINGDIPAPI GdipWarpPath(GpPath *path, GpMatrix* matrix,
1483 GDIPCONST GpPointF *points, INT count, REAL x, REAL y, REAL width,
1484 REAL height, WarpMode warpmode, REAL flatness)
1486 FIXME("(%p,%p,%p,%i,%0.2f,%0.2f,%0.2f,%0.2f,%i,%0.2f)\n", path, matrix,
1487 points, count, x, y, width, height, warpmode, flatness);
1489 return NotImplemented;
1492 GpStatus WINGDIPAPI GdipWidenPath(GpPath *path, GpPen *pen, GpMatrix *matrix,
1493 REAL flatness)
1495 FIXME("(%p,%p,%p,%0.2f)\n", path, pen, matrix, flatness);
1497 return NotImplemented;
1500 GpStatus WINGDIPAPI GdipAddPathRectangle(GpPath *path, REAL x, REAL y,
1501 REAL width, REAL height)
1503 GpPath *backup;
1504 GpPointF ptf[2];
1505 GpStatus retstat;
1506 BOOL old_new;
1508 TRACE("(%p, %.2f, %.2f, %.2f, %.2f)\n", path, x, y, width, height);
1510 if(!path || width < 0.0 || height < 0.0)
1511 return InvalidParameter;
1513 /* make a backup copy of path data */
1514 if((retstat = GdipClonePath(path, &backup)) != Ok)
1515 return retstat;
1517 /* rectangle should start as new path */
1518 old_new = path->newfigure;
1519 path->newfigure = TRUE;
1520 if((retstat = GdipAddPathLine(path,x,y,x+width,y)) != Ok){
1521 path->newfigure = old_new;
1522 goto fail;
1525 ptf[0].X = x+width;
1526 ptf[0].Y = y+height;
1527 ptf[1].X = x;
1528 ptf[1].Y = y+height;
1530 if((retstat = GdipAddPathLine2(path, ptf, 2)) != Ok) goto fail;
1531 path->pathdata.Types[path->pathdata.Count-1] |= PathPointTypeCloseSubpath;
1533 /* free backup */
1534 GdipDeletePath(backup);
1535 return Ok;
1537 fail:
1538 /* reverting */
1539 GdipDeletePath(path);
1540 GdipClonePath(backup, &path);
1541 GdipDeletePath(backup);
1543 return retstat;
1546 GpStatus WINGDIPAPI GdipAddPathRectangleI(GpPath *path, INT x, INT y,
1547 INT width, INT height)
1549 TRACE("(%p, %d, %d, %d, %d)\n", path, x, y, width, height);
1551 return GdipAddPathRectangle(path,(REAL)x,(REAL)y,(REAL)width,(REAL)height);
1554 GpStatus WINGDIPAPI GdipAddPathRectangles(GpPath *path, GDIPCONST GpRectF *rects, INT count)
1556 GpPath *backup;
1557 GpStatus retstat;
1558 INT i;
1560 TRACE("(%p, %p, %d)\n", path, rects, count);
1562 /* count == 0 - verified condition */
1563 if(!path || !rects || count == 0)
1564 return InvalidParameter;
1566 if(count < 0)
1567 return OutOfMemory;
1569 /* make a backup copy */
1570 if((retstat = GdipClonePath(path, &backup)) != Ok)
1571 return retstat;
1573 for(i = 0; i < count; i++){
1574 if((retstat = GdipAddPathRectangle(path,rects[i].X,rects[i].Y,rects[i].Width,rects[i].Height)) != Ok)
1575 goto fail;
1578 /* free backup */
1579 GdipDeletePath(backup);
1580 return Ok;
1582 fail:
1583 /* reverting */
1584 GdipDeletePath(path);
1585 GdipClonePath(backup, &path);
1586 GdipDeletePath(backup);
1588 return retstat;
1591 GpStatus WINGDIPAPI GdipAddPathRectanglesI(GpPath *path, GDIPCONST GpRect *rects, INT count)
1593 GpRectF *rectsF;
1594 GpStatus retstat;
1595 INT i;
1597 TRACE("(%p, %p, %d)\n", path, rects, count);
1599 if(!rects || count == 0)
1600 return InvalidParameter;
1602 if(count < 0)
1603 return OutOfMemory;
1605 rectsF = GdipAlloc(sizeof(GpRectF)*count);
1607 for(i = 0;i < count;i++){
1608 rectsF[i].X = (REAL)rects[i].X;
1609 rectsF[i].Y = (REAL)rects[i].Y;
1610 rectsF[i].Width = (REAL)rects[i].Width;
1611 rectsF[i].Height = (REAL)rects[i].Height;
1614 retstat = GdipAddPathRectangles(path, rectsF, count);
1615 GdipFree(rectsF);
1617 return retstat;
1620 GpStatus WINGDIPAPI GdipSetPathMarker(GpPath* path)
1622 INT count;
1624 TRACE("(%p)\n", path);
1626 if(!path)
1627 return InvalidParameter;
1629 count = path->pathdata.Count;
1631 /* set marker flag */
1632 if(count > 0)
1633 path->pathdata.Types[count-1] |= PathPointTypePathMarker;
1635 return Ok;
1638 GpStatus WINGDIPAPI GdipClearPathMarkers(GpPath* path)
1640 INT count;
1641 INT i;
1643 TRACE("(%p)\n", path);
1645 if(!path)
1646 return InvalidParameter;
1648 count = path->pathdata.Count;
1650 for(i = 0; i < count - 1; i++){
1651 path->pathdata.Types[i] &= ~PathPointTypePathMarker;
1654 return Ok;