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
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
{
39 BYTE type
; /* PathPointTypeStart or PathPointTypeLine */
40 path_list_node_t
*next
;
44 static BOOL
init_path_list(path_list_node_t
**node
, REAL x
, REAL y
)
46 *node
= GdipAlloc(sizeof(path_list_node_t
));
52 (*node
)->type
= PathPointTypeStart
;
58 /* free all nodes including argument */
59 static void free_path_list(path_list_node_t
*node
)
61 path_list_node_t
*n
= node
;
70 /* Add a node after 'node' */
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
));
87 new->next
= node
->next
;
93 /* returns element count */
94 static INT
path_list_count(path_list_node_t
*node
)
98 while((node
= node
->next
))
104 /* GdipFlattenPath helper */
106 * Used to recursively flatten single Bezier curve
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.
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 */
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;
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))))){
154 /* add a middle point */
155 if(!(node
= add_path_list_node(start
, mp
[2].X
, mp
[2].Y
, PathPointTypeLine
)))
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
);
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
);
174 return InvalidParameter
;
176 count
= arc2polybezier(NULL
, x1
, y1
, x2
, y2
, startAngle
, sweepAngle
);
180 if(!lengthen_path(path
, count
))
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
;
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
)
213 TRACE("(%p, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f)\n",
214 path
, x1
, y1
, x2
, y2
, x3
, y3
, x4
, y4
);
217 return InvalidParameter
;
219 if(!lengthen_path(path
, 4))
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;
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
,
255 GpStatus WINGDIPAPI
GdipAddPathBeziers(GpPath
*path
, GDIPCONST GpPointF
*points
,
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
))
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
;
284 GpStatus WINGDIPAPI
GdipAddPathBeziersI(GpPath
*path
, GDIPCONST GpPoint
*points
,
291 TRACE("(%p, %p, %d)\n", path
, points
, count
);
293 if(!points
|| ((count
- 1) % 3))
294 return InvalidParameter
;
296 ptsF
= GdipAlloc(sizeof(GpPointF
) * count
);
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
);
311 GpStatus WINGDIPAPI
GdipAddPathClosedCurve(GpPath
*path
, GDIPCONST GpPointF
*points
,
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
,
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;
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
));
349 /* copy source points to extend with the last one */
350 memcpy(pts
, points
, sizeof(GpPointF
)*count
);
353 tension
= tension
* TENSION_CONST
;
355 for(i
= 0; i
< count
-1; i
++){
356 calc_curve_bezier(&(pts
[i
]), tension
, &x1
, &y1
, &x2
, &y2
);
360 pt
[3*i
+3].X
= pts
[i
+1].X
;
361 pt
[3*i
+3].Y
= pts
[i
+1].Y
;
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 */
372 calc_curve_bezier(pts
, tension
, &x1
, &y1
, &x2
, &y2
);
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
);
387 INT count
= path
->pathdata
.Count
;
388 path
->pathdata
.Types
[count
- 1] |= PathPointTypeCloseSubpath
;
389 path
->newfigure
= TRUE
;
398 GpStatus WINGDIPAPI
GdipAddPathClosedCurve2I(GpPath
*path
, GDIPCONST GpPoint
*points
,
399 INT count
, REAL tension
)
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
);
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
);
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
,
449 INT i
, len_pt
= count
*3-2;
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
));
463 tension
= tension
* TENSION_CONST
;
465 calc_curve_bezier_endp(points
[0].X
, points
[0].Y
, points
[1].X
, points
[1].Y
,
468 pt
[0].X
= points
[0].X
;
469 pt
[0].Y
= points
[0].Y
;
473 for(i
= 0; i
< count
-2; i
++){
474 calc_curve_bezier(&(points
[i
]), tension
, &x1
, &y1
, &x2
, &y2
);
478 pt
[3*i
+3].X
= points
[i
+1].X
;
479 pt
[3*i
+3].Y
= points
[i
+1].Y
;
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
);
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
);
499 GpStatus WINGDIPAPI
GdipAddPathCurve2I(GpPath
*path
, GDIPCONST GpPoint
*points
,
500 INT count
, REAL tension
)
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
);
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
);
527 GpStatus WINGDIPAPI
GdipAddPathEllipse(GpPath
*path
, REAL x
, REAL y
, REAL width
,
530 INT old_count
, numpts
;
532 TRACE("(%p, %.2f, %.2f, %.2f, %.2f)\n", path
, x
, y
, width
, height
);
535 return InvalidParameter
;
537 if(!lengthen_path(path
, MAX_ARC_PTS
))
540 old_count
= path
->pathdata
.Count
;
541 if((numpts
= arc2polybezier(&path
->pathdata
.Points
[old_count
], x
, y
, width
,
542 height
, 0.0, 360.0)) != MAX_ARC_PTS
){
543 ERR("expected %d points but got %d\n", MAX_ARC_PTS
, numpts
);
547 memset(&path
->pathdata
.Types
[old_count
+ 1], PathPointTypeBezier
,
550 /* An ellipse is an intrinsic figure (always is its own subpath). */
551 path
->pathdata
.Types
[old_count
] = PathPointTypeStart
;
552 path
->pathdata
.Types
[old_count
+ MAX_ARC_PTS
- 1] |= PathPointTypeCloseSubpath
;
553 path
->newfigure
= TRUE
;
554 path
->pathdata
.Count
+= MAX_ARC_PTS
;
559 GpStatus WINGDIPAPI
GdipAddPathEllipseI(GpPath
*path
, INT x
, INT y
, INT width
,
562 TRACE("(%p, %d, %d, %d, %d)\n", path
, x
, y
, width
, height
);
564 return GdipAddPathEllipse(path
,(REAL
)x
,(REAL
)y
,(REAL
)width
,(REAL
)height
);
567 GpStatus WINGDIPAPI
GdipAddPathLine2(GpPath
*path
, GDIPCONST GpPointF
*points
,
572 TRACE("(%p, %p, %d)\n", path
, points
, count
);
575 return InvalidParameter
;
577 if(!lengthen_path(path
, count
))
580 old_count
= path
->pathdata
.Count
;
582 for(i
= 0; i
< count
; i
++){
583 path
->pathdata
.Points
[old_count
+ i
].X
= points
[i
].X
;
584 path
->pathdata
.Points
[old_count
+ i
].Y
= points
[i
].Y
;
585 path
->pathdata
.Types
[old_count
+ i
] = PathPointTypeLine
;
589 path
->pathdata
.Types
[old_count
] = PathPointTypeStart
;
590 path
->newfigure
= FALSE
;
593 path
->pathdata
.Count
+= count
;
598 GpStatus WINGDIPAPI
GdipAddPathLine2I(GpPath
*path
, GDIPCONST GpPoint
*points
, INT count
)
604 TRACE("(%p, %p, %d)\n", path
, points
, count
);
607 return InvalidParameter
;
609 pointsF
= GdipAlloc(sizeof(GpPointF
) * count
);
610 if(!pointsF
) return OutOfMemory
;
612 for(i
= 0;i
< count
; i
++){
613 pointsF
[i
].X
= (REAL
)points
[i
].X
;
614 pointsF
[i
].Y
= (REAL
)points
[i
].Y
;
617 stat
= GdipAddPathLine2(path
, pointsF
, count
);
624 GpStatus WINGDIPAPI
GdipAddPathLine(GpPath
*path
, REAL x1
, REAL y1
, REAL x2
, REAL y2
)
628 TRACE("(%p, %.2f, %.2f, %.2f, %.2f)\n", path
, x1
, y1
, x2
, y2
);
631 return InvalidParameter
;
633 if(!lengthen_path(path
, 2))
636 old_count
= path
->pathdata
.Count
;
638 path
->pathdata
.Points
[old_count
].X
= x1
;
639 path
->pathdata
.Points
[old_count
].Y
= y1
;
640 path
->pathdata
.Points
[old_count
+ 1].X
= x2
;
641 path
->pathdata
.Points
[old_count
+ 1].Y
= y2
;
643 path
->pathdata
.Types
[old_count
] =
644 (path
->newfigure
? PathPointTypeStart
: PathPointTypeLine
);
645 path
->pathdata
.Types
[old_count
+ 1] = PathPointTypeLine
;
647 path
->newfigure
= FALSE
;
648 path
->pathdata
.Count
+= 2;
653 GpStatus WINGDIPAPI
GdipAddPathLineI(GpPath
*path
, INT x1
, INT y1
, INT x2
, INT y2
)
655 TRACE("(%p, %d, %d, %d, %d)\n", path
, x1
, y1
, x2
, y2
);
657 return GdipAddPathLine(path
, (REAL
)x1
, (REAL
)y1
, (REAL
)x2
, (REAL
)y2
);
660 GpStatus WINGDIPAPI
GdipAddPathPath(GpPath
*path
, GDIPCONST GpPath
* addingPath
,
663 INT old_count
, count
;
665 TRACE("(%p, %p, %d)\n", path
, addingPath
, connect
);
667 if(!path
|| !addingPath
)
668 return InvalidParameter
;
670 old_count
= path
->pathdata
.Count
;
671 count
= addingPath
->pathdata
.Count
;
673 if(!lengthen_path(path
, count
))
676 memcpy(&path
->pathdata
.Points
[old_count
], addingPath
->pathdata
.Points
,
677 count
* sizeof(GpPointF
));
678 memcpy(&path
->pathdata
.Types
[old_count
], addingPath
->pathdata
.Types
, count
);
680 if(path
->newfigure
|| !connect
)
681 path
->pathdata
.Types
[old_count
] = PathPointTypeStart
;
683 path
->pathdata
.Types
[old_count
] = PathPointTypeLine
;
685 path
->newfigure
= FALSE
;
686 path
->pathdata
.Count
+= count
;
691 GpStatus WINGDIPAPI
GdipAddPathPie(GpPath
*path
, REAL x
, REAL y
, REAL width
, REAL height
,
692 REAL startAngle
, REAL sweepAngle
)
698 TRACE("(%p, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f)\n",
699 path
, x
, y
, width
, height
, startAngle
, sweepAngle
);
702 return InvalidParameter
;
704 count
= arc2polybezier(NULL
, x
, y
, width
, height
, startAngle
, sweepAngle
);
709 ptf
= GdipAlloc(sizeof(GpPointF
)*count
);
713 arc2polybezier(ptf
, x
, y
, width
, height
, startAngle
, sweepAngle
);
715 status
= GdipAddPathLine(path
, (width
- x
)/2, (height
- y
)/2, ptf
[0].X
, ptf
[0].Y
);
720 /* one spline is already added as a line endpoint */
721 if(!lengthen_path(path
, count
- 1)){
726 memcpy(&(path
->pathdata
.Points
[path
->pathdata
.Count
]), &(ptf
[1]),sizeof(GpPointF
)*(count
-1));
727 for(i
= 0; i
< count
-1; i
++)
728 path
->pathdata
.Types
[path
->pathdata
.Count
+i
] = PathPointTypeBezier
;
730 path
->pathdata
.Count
+= count
-1;
732 GdipClosePathFigure(path
);
739 GpStatus WINGDIPAPI
GdipAddPathPieI(GpPath
*path
, INT x
, INT y
, INT width
, INT height
,
740 REAL startAngle
, REAL sweepAngle
)
742 TRACE("(%p, %d, %d, %d, %d, %.2f, %.2f)\n",
743 path
, x
, y
, width
, height
, startAngle
, sweepAngle
);
745 return GdipAddPathPieI(path
, (REAL
)x
, (REAL
)y
, (REAL
)width
, (REAL
)height
, startAngle
, sweepAngle
);
748 GpStatus WINGDIPAPI
GdipAddPathPolygon(GpPath
*path
, GDIPCONST GpPointF
*points
, INT count
)
752 TRACE("(%p, %p, %d)\n", path
, points
, count
);
754 if(!path
|| !points
|| count
< 3)
755 return InvalidParameter
;
757 if(!lengthen_path(path
, count
))
760 old_count
= path
->pathdata
.Count
;
762 memcpy(&path
->pathdata
.Points
[old_count
], points
, count
*sizeof(GpPointF
));
763 memset(&path
->pathdata
.Types
[old_count
+ 1], PathPointTypeLine
, count
- 1);
765 /* A polygon is an intrinsic figure */
766 path
->pathdata
.Types
[old_count
] = PathPointTypeStart
;
767 path
->pathdata
.Types
[old_count
+ count
- 1] |= PathPointTypeCloseSubpath
;
768 path
->newfigure
= TRUE
;
769 path
->pathdata
.Count
+= count
;
774 GpStatus WINGDIPAPI
GdipAddPathPolygonI(GpPath
*path
, GDIPCONST GpPoint
*points
, INT count
)
780 TRACE("(%p, %p, %d)\n", path
, points
, count
);
782 if(!points
|| count
< 3)
783 return InvalidParameter
;
785 ptf
= GdipAlloc(sizeof(GpPointF
) * count
);
789 for(i
= 0; i
< count
; i
++){
790 ptf
[i
].X
= (REAL
)points
[i
].X
;
791 ptf
[i
].Y
= (REAL
)points
[i
].Y
;
794 status
= GdipAddPathPolygon(path
, ptf
, count
);
801 GpStatus WINGDIPAPI
GdipClonePath(GpPath
* path
, GpPath
**clone
)
803 TRACE("(%p, %p)\n", path
, clone
);
806 return InvalidParameter
;
808 *clone
= GdipAlloc(sizeof(GpPath
));
809 if(!*clone
) return OutOfMemory
;
813 (*clone
)->pathdata
.Points
= GdipAlloc(path
->datalen
* sizeof(PointF
));
814 (*clone
)->pathdata
.Types
= GdipAlloc(path
->datalen
);
815 if(!(*clone
)->pathdata
.Points
|| !(*clone
)->pathdata
.Types
){
817 GdipFree((*clone
)->pathdata
.Points
);
818 GdipFree((*clone
)->pathdata
.Types
);
822 memcpy((*clone
)->pathdata
.Points
, path
->pathdata
.Points
,
823 path
->datalen
* sizeof(PointF
));
824 memcpy((*clone
)->pathdata
.Types
, path
->pathdata
.Types
, path
->datalen
);
829 GpStatus WINGDIPAPI
GdipClosePathFigure(GpPath
* path
)
831 TRACE("(%p)\n", path
);
834 return InvalidParameter
;
836 if(path
->pathdata
.Count
> 0){
837 path
->pathdata
.Types
[path
->pathdata
.Count
- 1] |= PathPointTypeCloseSubpath
;
838 path
->newfigure
= TRUE
;
844 GpStatus WINGDIPAPI
GdipClosePathFigures(GpPath
* path
)
848 TRACE("(%p)\n", path
);
851 return InvalidParameter
;
853 for(i
= 1; i
< path
->pathdata
.Count
; i
++){
854 if(path
->pathdata
.Types
[i
] == PathPointTypeStart
)
855 path
->pathdata
.Types
[i
-1] |= PathPointTypeCloseSubpath
;
858 path
->newfigure
= TRUE
;
863 GpStatus WINGDIPAPI
GdipCreatePath(GpFillMode fill
, GpPath
**path
)
865 TRACE("(%d, %p)\n", fill
, path
);
868 return InvalidParameter
;
870 *path
= GdipAlloc(sizeof(GpPath
));
871 if(!*path
) return OutOfMemory
;
873 (*path
)->fill
= fill
;
874 (*path
)->newfigure
= TRUE
;
879 GpStatus WINGDIPAPI
GdipCreatePath2(GDIPCONST GpPointF
* points
,
880 GDIPCONST BYTE
* types
, INT count
, GpFillMode fill
, GpPath
**path
)
882 TRACE("(%p, %p, %d, %d, %p)\n", points
, types
, count
, fill
, path
);
885 return InvalidParameter
;
887 *path
= GdipAlloc(sizeof(GpPath
));
888 if(!*path
) return OutOfMemory
;
890 (*path
)->pathdata
.Points
= GdipAlloc(count
* sizeof(PointF
));
891 (*path
)->pathdata
.Types
= GdipAlloc(count
);
893 if(!(*path
)->pathdata
.Points
|| !(*path
)->pathdata
.Types
){
894 GdipFree((*path
)->pathdata
.Points
);
895 GdipFree((*path
)->pathdata
.Types
);
900 memcpy((*path
)->pathdata
.Points
, points
, count
* sizeof(PointF
));
901 memcpy((*path
)->pathdata
.Types
, types
, count
);
902 (*path
)->pathdata
.Count
= count
;
903 (*path
)->datalen
= count
;
905 (*path
)->fill
= fill
;
906 (*path
)->newfigure
= TRUE
;
911 GpStatus WINGDIPAPI
GdipCreatePath2I(GDIPCONST GpPoint
* points
,
912 GDIPCONST BYTE
* types
, INT count
, GpFillMode fill
, GpPath
**path
)
918 TRACE("(%p, %p, %d, %d, %p)\n", points
, types
, count
, fill
, path
);
920 ptF
= GdipAlloc(sizeof(GpPointF
)*count
);
922 for(i
= 0;i
< count
; i
++){
923 ptF
[i
].X
= (REAL
)points
[i
].X
;
924 ptF
[i
].Y
= (REAL
)points
[i
].Y
;
927 ret
= GdipCreatePath2(ptF
, types
, count
, fill
, path
);
934 GpStatus WINGDIPAPI
GdipDeletePath(GpPath
*path
)
936 TRACE("(%p)\n", path
);
939 return InvalidParameter
;
941 GdipFree(path
->pathdata
.Points
);
942 GdipFree(path
->pathdata
.Types
);
948 GpStatus WINGDIPAPI
GdipFlattenPath(GpPath
*path
, GpMatrix
* matrix
, REAL flatness
)
950 path_list_node_t
*list
, *node
;
955 TRACE("(%p, %p, %.2f)\n", path
, matrix
, flatness
);
958 return InvalidParameter
;
961 WARN("transformation not supported yet!\n");
962 return NotImplemented
;
965 if(path
->pathdata
.Count
== 0)
968 pt
= path
->pathdata
.Points
[0];
969 if(!init_path_list(&list
, pt
.X
, pt
.Y
))
974 while(i
< path
->pathdata
.Count
){
976 BYTE type
= path
->pathdata
.Types
[i
] & PathPointTypePathTypeMask
;
977 path_list_node_t
*start
;
979 pt
= path
->pathdata
.Points
[i
];
981 /* save last start point index */
982 if(type
== PathPointTypeStart
)
985 /* always add line points and start points */
986 if((type
== PathPointTypeStart
) || (type
== PathPointTypeLine
)){
987 type
= (path
->pathdata
.Types
[i
] & ~PathPointTypeBezier
) | PathPointTypeLine
;
988 if(!add_path_list_node(node
, pt
.X
, pt
.Y
, type
))
995 /* Bezier curve always stored as 4 points */
996 if((path
->pathdata
.Types
[i
-1] & PathPointTypePathTypeMask
) != PathPointTypeStart
){
997 type
= (path
->pathdata
.Types
[i
] & ~PathPointTypeBezier
) | PathPointTypeLine
;
998 if(!add_path_list_node(node
, pt
.X
, pt
.Y
, type
))
1004 /* test for closed figure */
1005 if(path
->pathdata
.Types
[i
+1] & PathPointTypeCloseSubpath
){
1006 pt
= path
->pathdata
.Points
[startidx
];
1012 pt
= path
->pathdata
.Points
[i
];
1016 /* add Bezier end point */
1017 type
= (path
->pathdata
.Types
[i
] & ~PathPointTypeBezier
) | PathPointTypeLine
;
1018 if(!add_path_list_node(node
, pt
.X
, pt
.Y
, type
))
1023 if(!flatten_bezier(start
, path
->pathdata
.Points
[i
-2].X
, path
->pathdata
.Points
[i
-2].Y
,
1024 path
->pathdata
.Points
[i
-1].X
, path
->pathdata
.Points
[i
-1].Y
,
1031 /* store path data back */
1032 i
= path_list_count(list
);
1033 if(!lengthen_path(path
, i
))
1035 path
->pathdata
.Count
= i
;
1038 for(i
= 0; i
< path
->pathdata
.Count
; i
++){
1039 path
->pathdata
.Points
[i
] = node
->pt
;
1040 path
->pathdata
.Types
[i
] = node
->type
;
1044 free_path_list(list
);
1048 free_path_list(list
);
1052 GpStatus WINGDIPAPI
GdipGetPathData(GpPath
*path
, GpPathData
* pathData
)
1054 TRACE("(%p, %p)\n", path
, pathData
);
1056 if(!path
|| !pathData
)
1057 return InvalidParameter
;
1059 /* Only copy data. pathData allocation/freeing controlled by wrapper class.
1060 Assumed that pathData is enough wide to get all data - controlled by wrapper too. */
1061 memcpy(pathData
->Points
, path
->pathdata
.Points
, sizeof(PointF
) * pathData
->Count
);
1062 memcpy(pathData
->Types
, path
->pathdata
.Types
, pathData
->Count
);
1067 GpStatus WINGDIPAPI
GdipGetPathFillMode(GpPath
*path
, GpFillMode
*fillmode
)
1069 TRACE("(%p, %p)\n", path
, fillmode
);
1071 if(!path
|| !fillmode
)
1072 return InvalidParameter
;
1074 *fillmode
= path
->fill
;
1079 GpStatus WINGDIPAPI
GdipGetPathLastPoint(GpPath
* path
, GpPointF
* lastPoint
)
1083 TRACE("(%p, %p)\n", path
, lastPoint
);
1085 if(!path
|| !lastPoint
)
1086 return InvalidParameter
;
1088 count
= path
->pathdata
.Count
;
1090 *lastPoint
= path
->pathdata
.Points
[count
-1];
1095 GpStatus WINGDIPAPI
GdipGetPathPoints(GpPath
*path
, GpPointF
* points
, INT count
)
1097 TRACE("(%p, %p, %d)\n", path
, points
, count
);
1100 return InvalidParameter
;
1102 if(count
< path
->pathdata
.Count
)
1103 return InsufficientBuffer
;
1105 memcpy(points
, path
->pathdata
.Points
, path
->pathdata
.Count
* sizeof(GpPointF
));
1110 GpStatus WINGDIPAPI
GdipGetPathPointsI(GpPath
*path
, GpPoint
* points
, INT count
)
1116 TRACE("(%p, %p, %d)\n", path
, points
, count
);
1119 return InvalidParameter
;
1121 ptf
= GdipAlloc(sizeof(GpPointF
)*count
);
1122 if(!ptf
) return OutOfMemory
;
1124 ret
= GdipGetPathPoints(path
,ptf
,count
);
1126 for(i
= 0;i
< count
;i
++){
1127 points
[i
].X
= roundr(ptf
[i
].X
);
1128 points
[i
].Y
= roundr(ptf
[i
].Y
);
1135 GpStatus WINGDIPAPI
GdipGetPathTypes(GpPath
*path
, BYTE
* types
, INT count
)
1137 TRACE("(%p, %p, %d)\n", path
, types
, count
);
1140 return InvalidParameter
;
1142 if(count
< path
->pathdata
.Count
)
1143 return InsufficientBuffer
;
1145 memcpy(types
, path
->pathdata
.Types
, path
->pathdata
.Count
);
1150 /* Windows expands the bounding box to the maximum possible bounding box
1151 * for a given pen. For example, if a line join can extend past the point
1152 * it's joining by x units, the bounding box is extended by x units in every
1153 * direction (even though this is too conservative for most cases). */
1154 GpStatus WINGDIPAPI
GdipGetPathWorldBounds(GpPath
* path
, GpRectF
* bounds
,
1155 GDIPCONST GpMatrix
*matrix
, GDIPCONST GpPen
*pen
)
1157 GpPointF
* points
, temp_pts
[4];
1159 REAL path_width
= 1.0, width
, height
, temp
, low_x
, low_y
, high_x
, high_y
;
1161 TRACE("(%p, %p, %p, %p)\n", path
, bounds
, matrix
, pen
);
1163 /* Matrix and pen can be null. */
1164 if(!path
|| !bounds
)
1165 return InvalidParameter
;
1167 /* If path is empty just return. */
1168 count
= path
->pathdata
.Count
;
1170 bounds
->X
= bounds
->Y
= bounds
->Width
= bounds
->Height
= 0.0;
1174 points
= path
->pathdata
.Points
;
1176 low_x
= high_x
= points
[0].X
;
1177 low_y
= high_y
= points
[0].Y
;
1179 for(i
= 1; i
< count
; i
++){
1180 low_x
= min(low_x
, points
[i
].X
);
1181 low_y
= min(low_y
, points
[i
].Y
);
1182 high_x
= max(high_x
, points
[i
].X
);
1183 high_y
= max(high_y
, points
[i
].Y
);
1186 width
= high_x
- low_x
;
1187 height
= high_y
- low_y
;
1189 /* This looks unusual but it's the only way I can imitate windows. */
1191 temp_pts
[0].X
= low_x
;
1192 temp_pts
[0].Y
= low_y
;
1193 temp_pts
[1].X
= low_x
;
1194 temp_pts
[1].Y
= high_y
;
1195 temp_pts
[2].X
= high_x
;
1196 temp_pts
[2].Y
= high_y
;
1197 temp_pts
[3].X
= high_x
;
1198 temp_pts
[3].Y
= low_y
;
1200 GdipTransformMatrixPoints((GpMatrix
*)matrix
, temp_pts
, 4);
1201 low_x
= temp_pts
[0].X
;
1202 low_y
= temp_pts
[0].Y
;
1204 for(i
= 1; i
< 4; i
++){
1205 low_x
= min(low_x
, temp_pts
[i
].X
);
1206 low_y
= min(low_y
, temp_pts
[i
].Y
);
1210 width
= height
* fabs(matrix
->matrix
[2]) + width
* fabs(matrix
->matrix
[0]);
1211 height
= height
* fabs(matrix
->matrix
[3]) + temp
* fabs(matrix
->matrix
[1]);
1215 path_width
= pen
->width
/ 2.0;
1218 path_width
= max(path_width
, pen
->width
* pen
->miterlimit
/ 2.0);
1219 /* FIXME: this should probably also check for the startcap */
1220 if(pen
->endcap
& LineCapNoAnchor
)
1221 path_width
= max(path_width
, pen
->width
* 2.2);
1223 low_x
-= path_width
;
1224 low_y
-= path_width
;
1225 width
+= 2.0 * path_width
;
1226 height
+= 2.0 * path_width
;
1231 bounds
->Width
= width
;
1232 bounds
->Height
= height
;
1237 GpStatus WINGDIPAPI
GdipGetPathWorldBoundsI(GpPath
* path
, GpRect
* bounds
,
1238 GDIPCONST GpMatrix
*matrix
, GDIPCONST GpPen
*pen
)
1243 TRACE("(%p, %p, %p, %p)\n", path
, bounds
, matrix
, pen
);
1245 ret
= GdipGetPathWorldBounds(path
,&boundsF
,matrix
,pen
);
1248 bounds
->X
= roundr(boundsF
.X
);
1249 bounds
->Y
= roundr(boundsF
.Y
);
1250 bounds
->Width
= roundr(boundsF
.Width
);
1251 bounds
->Height
= roundr(boundsF
.Height
);
1257 GpStatus WINGDIPAPI
GdipGetPointCount(GpPath
*path
, INT
*count
)
1259 TRACE("(%p, %p)\n", path
, count
);
1262 return InvalidParameter
;
1264 *count
= path
->pathdata
.Count
;
1269 GpStatus WINGDIPAPI
GdipReversePath(GpPath
* path
)
1272 INT start
= 0; /* position in reversed path */
1275 TRACE("(%p)\n", path
);
1278 return InvalidParameter
;
1280 count
= path
->pathdata
.Count
;
1282 if(count
== 0) return Ok
;
1284 revpath
.Points
= GdipAlloc(sizeof(GpPointF
)*count
);
1285 revpath
.Types
= GdipAlloc(sizeof(BYTE
)*count
);
1286 revpath
.Count
= count
;
1287 if(!revpath
.Points
|| !revpath
.Types
){
1288 GdipFree(revpath
.Points
);
1289 GdipFree(revpath
.Types
);
1293 for(i
= 0; i
< count
; i
++){
1295 /* find next start point */
1296 if(path
->pathdata
.Types
[count
-i
-1] == PathPointTypeStart
){
1298 for(j
= start
; j
<= i
; j
++){
1299 revpath
.Points
[j
] = path
->pathdata
.Points
[count
-j
-1];
1300 revpath
.Types
[j
] = path
->pathdata
.Types
[count
-j
-1];
1302 /* mark start point */
1303 revpath
.Types
[start
] = PathPointTypeStart
;
1304 /* set 'figure' endpoint type */
1306 revpath
.Types
[i
] = path
->pathdata
.Types
[count
-start
-1] & ~PathPointTypePathTypeMask
;
1307 revpath
.Types
[i
] |= revpath
.Types
[i
-1];
1310 revpath
.Types
[i
] = path
->pathdata
.Types
[start
];
1316 memcpy(path
->pathdata
.Points
, revpath
.Points
, sizeof(GpPointF
)*count
);
1317 memcpy(path
->pathdata
.Types
, revpath
.Types
, sizeof(BYTE
)*count
);
1319 GdipFree(revpath
.Points
);
1320 GdipFree(revpath
.Types
);
1325 GpStatus WINGDIPAPI
GdipIsOutlineVisiblePathPointI(GpPath
* path
, INT x
, INT y
,
1326 GpPen
*pen
, GpGraphics
*graphics
, BOOL
*result
)
1328 TRACE("(%p, %d, %d, %p, %p, %p)\n", path
, x
, y
, pen
, graphics
, result
);
1330 return GdipIsOutlineVisiblePathPoint(path
, x
, y
, pen
, graphics
, result
);
1333 GpStatus WINGDIPAPI
GdipIsOutlineVisiblePathPoint(GpPath
* path
, REAL x
, REAL y
,
1334 GpPen
*pen
, GpGraphics
*graphics
, BOOL
*result
)
1339 return InvalidParameter
;
1342 FIXME("not implemented\n");
1344 return NotImplemented
;
1347 GpStatus WINGDIPAPI
GdipIsVisiblePathPointI(GpPath
* path
, INT x
, INT y
, GpGraphics
*graphics
, BOOL
*result
)
1349 TRACE("(%p, %d, %d, %p, %p)\n", path
, x
, y
, graphics
, result
);
1351 return GdipIsVisiblePathPoint(path
, x
, y
, graphics
, result
);
1354 GpStatus WINGDIPAPI
GdipIsVisiblePathPoint(GpPath
* path
, REAL x
, REAL y
, GpGraphics
*graphics
, BOOL
*result
)
1358 if(!path
) return InvalidParameter
;
1361 FIXME("not implemented\n");
1363 return NotImplemented
;
1366 GpStatus WINGDIPAPI
GdipStartPathFigure(GpPath
*path
)
1368 TRACE("(%p)\n", path
);
1371 return InvalidParameter
;
1373 path
->newfigure
= TRUE
;
1378 GpStatus WINGDIPAPI
GdipResetPath(GpPath
*path
)
1380 TRACE("(%p)\n", path
);
1383 return InvalidParameter
;
1385 path
->pathdata
.Count
= 0;
1386 path
->newfigure
= TRUE
;
1387 path
->fill
= FillModeAlternate
;
1392 GpStatus WINGDIPAPI
GdipSetPathFillMode(GpPath
*path
, GpFillMode fill
)
1394 TRACE("(%p, %d)\n", path
, fill
);
1397 return InvalidParameter
;
1404 GpStatus WINGDIPAPI
GdipTransformPath(GpPath
*path
, GpMatrix
*matrix
)
1406 TRACE("(%p, %p)\n", path
, matrix
);
1409 return InvalidParameter
;
1411 if(path
->pathdata
.Count
== 0)
1414 return GdipTransformMatrixPoints(matrix
, path
->pathdata
.Points
,
1415 path
->pathdata
.Count
);
1418 GpStatus WINGDIPAPI
GdipAddPathRectangle(GpPath
*path
, REAL x
, REAL y
,
1419 REAL width
, REAL height
)
1426 TRACE("(%p, %.2f, %.2f, %.2f, %.2f)\n", path
, x
, y
, width
, height
);
1428 if(!path
|| width
< 0.0 || height
< 0.0)
1429 return InvalidParameter
;
1431 /* make a backup copy of path data */
1432 if((retstat
= GdipClonePath(path
, &backup
)) != Ok
)
1435 /* rectangle should start as new path */
1436 old_new
= path
->newfigure
;
1437 path
->newfigure
= TRUE
;
1438 if((retstat
= GdipAddPathLine(path
,x
,y
,x
+width
,y
)) != Ok
){
1439 path
->newfigure
= old_new
;
1444 ptf
[0].Y
= y
+height
;
1446 ptf
[1].Y
= y
+height
;
1448 if((retstat
= GdipAddPathLine2(path
, ptf
, 2)) != Ok
) goto fail
;
1449 path
->pathdata
.Types
[path
->pathdata
.Count
-1] |= PathPointTypeCloseSubpath
;
1452 GdipDeletePath(backup
);
1457 GdipDeletePath(path
);
1458 GdipClonePath(backup
, &path
);
1459 GdipDeletePath(backup
);
1464 GpStatus WINGDIPAPI
GdipAddPathRectangleI(GpPath
*path
, INT x
, INT y
,
1465 INT width
, INT height
)
1467 TRACE("(%p, %d, %d, %d, %d)\n", path
, x
, y
, width
, height
);
1469 return GdipAddPathRectangle(path
,(REAL
)x
,(REAL
)y
,(REAL
)width
,(REAL
)height
);
1472 GpStatus WINGDIPAPI
GdipAddPathRectangles(GpPath
*path
, GDIPCONST GpRectF
*rects
, INT count
)
1478 TRACE("(%p, %p, %d)\n", path
, rects
, count
);
1480 /* count == 0 - verified condition */
1481 if(!path
|| !rects
|| count
== 0)
1482 return InvalidParameter
;
1487 /* make a backup copy */
1488 if((retstat
= GdipClonePath(path
, &backup
)) != Ok
)
1491 for(i
= 0; i
< count
; i
++){
1492 if((retstat
= GdipAddPathRectangle(path
,rects
[i
].X
,rects
[i
].Y
,rects
[i
].Width
,rects
[i
].Height
)) != Ok
)
1497 GdipDeletePath(backup
);
1502 GdipDeletePath(path
);
1503 GdipClonePath(backup
, &path
);
1504 GdipDeletePath(backup
);
1509 GpStatus WINGDIPAPI
GdipAddPathRectanglesI(GpPath
*path
, GDIPCONST GpRect
*rects
, INT count
)
1515 TRACE("(%p, %p, %d)\n", path
, rects
, count
);
1517 if(!rects
|| count
== 0)
1518 return InvalidParameter
;
1523 rectsF
= GdipAlloc(sizeof(GpRectF
)*count
);
1525 for(i
= 0;i
< count
;i
++){
1526 rectsF
[i
].X
= (REAL
)rects
[i
].X
;
1527 rectsF
[i
].Y
= (REAL
)rects
[i
].Y
;
1528 rectsF
[i
].Width
= (REAL
)rects
[i
].Width
;
1529 rectsF
[i
].Height
= (REAL
)rects
[i
].Height
;
1532 retstat
= GdipAddPathRectangles(path
, rectsF
, count
);
1538 GpStatus WINGDIPAPI
GdipSetPathMarker(GpPath
* path
)
1542 TRACE("(%p)\n", path
);
1545 return InvalidParameter
;
1547 count
= path
->pathdata
.Count
;
1549 /* set marker flag */
1551 path
->pathdata
.Types
[count
-1] |= PathPointTypePathMarker
;
1556 GpStatus WINGDIPAPI
GdipClearPathMarkers(GpPath
* path
)
1561 TRACE("(%p)\n", path
);
1564 return InvalidParameter
;
1566 count
= path
->pathdata
.Count
;
1568 for(i
= 0; i
< count
- 1; i
++){
1569 path
->pathdata
.Types
[i
] &= ~PathPointTypePathMarker
;