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 halves */
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 separately 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 path
->pathdata
.Types
[path
->pathdata
.Count
- 1] |= PathPointTypeCloseSubpath
;
388 path
->newfigure
= TRUE
;
397 GpStatus WINGDIPAPI
GdipAddPathClosedCurve2I(GpPath
*path
, GDIPCONST GpPoint
*points
,
398 INT count
, REAL tension
)
404 TRACE("(%p, %p, %d, %.2f)\n", path
, points
, count
, tension
);
406 if(!path
|| !points
|| count
<= 1)
407 return InvalidParameter
;
409 ptf
= GdipAlloc(sizeof(GpPointF
)*count
);
413 for(i
= 0; i
< count
; i
++){
414 ptf
[i
].X
= (REAL
)points
[i
].X
;
415 ptf
[i
].Y
= (REAL
)points
[i
].Y
;
418 stat
= GdipAddPathClosedCurve2(path
, ptf
, count
, tension
);
425 GpStatus WINGDIPAPI
GdipAddPathCurve(GpPath
*path
, GDIPCONST GpPointF
*points
, INT count
)
427 TRACE("(%p, %p, %d)\n", path
, points
, count
);
429 if(!path
|| !points
|| count
<= 1)
430 return InvalidParameter
;
432 return GdipAddPathCurve2(path
, points
, count
, 1.0);
435 GpStatus WINGDIPAPI
GdipAddPathCurveI(GpPath
*path
, GDIPCONST GpPoint
*points
, INT count
)
437 TRACE("(%p, %p, %d)\n", path
, points
, count
);
439 if(!path
|| !points
|| count
<= 1)
440 return InvalidParameter
;
442 return GdipAddPathCurve2I(path
, points
, count
, 1.0);
445 GpStatus WINGDIPAPI
GdipAddPathCurve2(GpPath
*path
, GDIPCONST GpPointF
*points
, INT count
,
448 INT i
, len_pt
= count
*3-2;
453 TRACE("(%p, %p, %d, %.2f)\n", path
, points
, count
, tension
);
455 if(!path
|| !points
|| count
<= 1)
456 return InvalidParameter
;
458 pt
= GdipAlloc(len_pt
* sizeof(GpPointF
));
462 tension
= tension
* TENSION_CONST
;
464 calc_curve_bezier_endp(points
[0].X
, points
[0].Y
, points
[1].X
, points
[1].Y
,
467 pt
[0].X
= points
[0].X
;
468 pt
[0].Y
= points
[0].Y
;
472 for(i
= 0; i
< count
-2; i
++){
473 calc_curve_bezier(&(points
[i
]), tension
, &x1
, &y1
, &x2
, &y2
);
477 pt
[3*i
+3].X
= points
[i
+1].X
;
478 pt
[3*i
+3].Y
= points
[i
+1].Y
;
483 calc_curve_bezier_endp(points
[count
-1].X
, points
[count
-1].Y
,
484 points
[count
-2].X
, points
[count
-2].Y
, tension
, &x1
, &y1
);
488 pt
[len_pt
-1].X
= points
[count
-1].X
;
489 pt
[len_pt
-1].Y
= points
[count
-1].Y
;
491 stat
= GdipAddPathBeziers(path
, pt
, len_pt
);
498 GpStatus WINGDIPAPI
GdipAddPathCurve2I(GpPath
*path
, GDIPCONST GpPoint
*points
,
499 INT count
, REAL tension
)
505 TRACE("(%p, %p, %d, %.2f)\n", path
, points
, count
, tension
);
507 if(!path
|| !points
|| count
<= 1)
508 return InvalidParameter
;
510 ptf
= GdipAlloc(sizeof(GpPointF
)*count
);
514 for(i
= 0; i
< count
; i
++){
515 ptf
[i
].X
= (REAL
)points
[i
].X
;
516 ptf
[i
].Y
= (REAL
)points
[i
].Y
;
519 stat
= GdipAddPathCurve2(path
, ptf
, count
, tension
);
526 GpStatus WINGDIPAPI
GdipAddPathCurve3(GpPath
*path
, GDIPCONST GpPointF
*points
,
527 INT count
, INT offset
, INT nseg
, REAL tension
)
529 TRACE("(%p, %p, %d, %d, %d, %.2f)\n", path
, points
, count
, offset
, nseg
, tension
);
531 if(!path
|| !points
|| offset
+ 1 >= count
|| count
- offset
< nseg
+ 1)
532 return InvalidParameter
;
534 return GdipAddPathCurve2(path
, &points
[offset
], nseg
+ 1, tension
);
537 GpStatus WINGDIPAPI
GdipAddPathCurve3I(GpPath
*path
, GDIPCONST GpPoint
*points
,
538 INT count
, INT offset
, INT nseg
, REAL tension
)
540 TRACE("(%p, %p, %d, %d, %d, %.2f)\n", path
, points
, count
, offset
, nseg
, tension
);
542 if(!path
|| !points
|| offset
+ 1 >= count
|| count
- offset
< nseg
+ 1)
543 return InvalidParameter
;
545 return GdipAddPathCurve2I(path
, &points
[offset
], nseg
+ 1, tension
);
548 GpStatus WINGDIPAPI
GdipAddPathEllipse(GpPath
*path
, REAL x
, REAL y
, REAL width
,
551 INT old_count
, numpts
;
553 TRACE("(%p, %.2f, %.2f, %.2f, %.2f)\n", path
, x
, y
, width
, height
);
556 return InvalidParameter
;
558 if(!lengthen_path(path
, MAX_ARC_PTS
))
561 old_count
= path
->pathdata
.Count
;
562 if((numpts
= arc2polybezier(&path
->pathdata
.Points
[old_count
], x
, y
, width
,
563 height
, 0.0, 360.0)) != MAX_ARC_PTS
){
564 ERR("expected %d points but got %d\n", MAX_ARC_PTS
, numpts
);
568 memset(&path
->pathdata
.Types
[old_count
+ 1], PathPointTypeBezier
,
571 /* An ellipse is an intrinsic figure (always is its own subpath). */
572 path
->pathdata
.Types
[old_count
] = PathPointTypeStart
;
573 path
->pathdata
.Types
[old_count
+ MAX_ARC_PTS
- 1] |= PathPointTypeCloseSubpath
;
574 path
->newfigure
= TRUE
;
575 path
->pathdata
.Count
+= MAX_ARC_PTS
;
580 GpStatus WINGDIPAPI
GdipAddPathEllipseI(GpPath
*path
, INT x
, INT y
, INT width
,
583 TRACE("(%p, %d, %d, %d, %d)\n", path
, x
, y
, width
, height
);
585 return GdipAddPathEllipse(path
,(REAL
)x
,(REAL
)y
,(REAL
)width
,(REAL
)height
);
588 GpStatus WINGDIPAPI
GdipAddPathLine2(GpPath
*path
, GDIPCONST GpPointF
*points
,
593 TRACE("(%p, %p, %d)\n", path
, points
, count
);
596 return InvalidParameter
;
598 if(!lengthen_path(path
, count
))
601 old_count
= path
->pathdata
.Count
;
603 for(i
= 0; i
< count
; i
++){
604 path
->pathdata
.Points
[old_count
+ i
].X
= points
[i
].X
;
605 path
->pathdata
.Points
[old_count
+ i
].Y
= points
[i
].Y
;
606 path
->pathdata
.Types
[old_count
+ i
] = PathPointTypeLine
;
610 path
->pathdata
.Types
[old_count
] = PathPointTypeStart
;
611 path
->newfigure
= FALSE
;
614 path
->pathdata
.Count
+= count
;
619 GpStatus WINGDIPAPI
GdipAddPathLine2I(GpPath
*path
, GDIPCONST GpPoint
*points
, INT count
)
625 TRACE("(%p, %p, %d)\n", path
, points
, count
);
628 return InvalidParameter
;
630 pointsF
= GdipAlloc(sizeof(GpPointF
) * count
);
631 if(!pointsF
) return OutOfMemory
;
633 for(i
= 0;i
< count
; i
++){
634 pointsF
[i
].X
= (REAL
)points
[i
].X
;
635 pointsF
[i
].Y
= (REAL
)points
[i
].Y
;
638 stat
= GdipAddPathLine2(path
, pointsF
, count
);
645 GpStatus WINGDIPAPI
GdipAddPathLine(GpPath
*path
, REAL x1
, REAL y1
, REAL x2
, REAL y2
)
649 TRACE("(%p, %.2f, %.2f, %.2f, %.2f)\n", path
, x1
, y1
, x2
, y2
);
652 return InvalidParameter
;
654 if(!lengthen_path(path
, 2))
657 old_count
= path
->pathdata
.Count
;
659 path
->pathdata
.Points
[old_count
].X
= x1
;
660 path
->pathdata
.Points
[old_count
].Y
= y1
;
661 path
->pathdata
.Points
[old_count
+ 1].X
= x2
;
662 path
->pathdata
.Points
[old_count
+ 1].Y
= y2
;
664 path
->pathdata
.Types
[old_count
] =
665 (path
->newfigure
? PathPointTypeStart
: PathPointTypeLine
);
666 path
->pathdata
.Types
[old_count
+ 1] = PathPointTypeLine
;
668 path
->newfigure
= FALSE
;
669 path
->pathdata
.Count
+= 2;
674 GpStatus WINGDIPAPI
GdipAddPathLineI(GpPath
*path
, INT x1
, INT y1
, INT x2
, INT y2
)
676 TRACE("(%p, %d, %d, %d, %d)\n", path
, x1
, y1
, x2
, y2
);
678 return GdipAddPathLine(path
, (REAL
)x1
, (REAL
)y1
, (REAL
)x2
, (REAL
)y2
);
681 GpStatus WINGDIPAPI
GdipAddPathPath(GpPath
*path
, GDIPCONST GpPath
* addingPath
,
684 INT old_count
, count
;
686 TRACE("(%p, %p, %d)\n", path
, addingPath
, connect
);
688 if(!path
|| !addingPath
)
689 return InvalidParameter
;
691 old_count
= path
->pathdata
.Count
;
692 count
= addingPath
->pathdata
.Count
;
694 if(!lengthen_path(path
, count
))
697 memcpy(&path
->pathdata
.Points
[old_count
], addingPath
->pathdata
.Points
,
698 count
* sizeof(GpPointF
));
699 memcpy(&path
->pathdata
.Types
[old_count
], addingPath
->pathdata
.Types
, count
);
701 if(path
->newfigure
|| !connect
)
702 path
->pathdata
.Types
[old_count
] = PathPointTypeStart
;
704 path
->pathdata
.Types
[old_count
] = PathPointTypeLine
;
706 path
->newfigure
= FALSE
;
707 path
->pathdata
.Count
+= count
;
712 GpStatus WINGDIPAPI
GdipAddPathPie(GpPath
*path
, REAL x
, REAL y
, REAL width
, REAL height
,
713 REAL startAngle
, REAL sweepAngle
)
719 TRACE("(%p, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f)\n",
720 path
, x
, y
, width
, height
, startAngle
, sweepAngle
);
723 return InvalidParameter
;
725 /* on zero width/height only start point added */
726 if(width
<= 1e-7 || height
<= 1e-7){
727 if(!lengthen_path(path
, 1))
729 path
->pathdata
.Points
[0].X
= x
+ width
/ 2.0;
730 path
->pathdata
.Points
[0].Y
= y
+ height
/ 2.0;
731 path
->pathdata
.Types
[0] = PathPointTypeStart
| PathPointTypeCloseSubpath
;
732 path
->pathdata
.Count
= 1;
733 return InvalidParameter
;
736 count
= arc2polybezier(NULL
, x
, y
, width
, height
, startAngle
, sweepAngle
);
741 ptf
= GdipAlloc(sizeof(GpPointF
)*count
);
745 arc2polybezier(ptf
, x
, y
, width
, height
, startAngle
, sweepAngle
);
747 status
= GdipAddPathLine(path
, x
+ width
/2, y
+ height
/2, ptf
[0].X
, ptf
[0].Y
);
752 /* one spline is already added as a line endpoint */
753 if(!lengthen_path(path
, count
- 1)){
758 memcpy(&(path
->pathdata
.Points
[path
->pathdata
.Count
]), &(ptf
[1]),sizeof(GpPointF
)*(count
-1));
759 for(i
= 0; i
< count
-1; i
++)
760 path
->pathdata
.Types
[path
->pathdata
.Count
+i
] = PathPointTypeBezier
;
762 path
->pathdata
.Count
+= count
-1;
764 GdipClosePathFigure(path
);
771 GpStatus WINGDIPAPI
GdipAddPathPieI(GpPath
*path
, INT x
, INT y
, INT width
, INT height
,
772 REAL startAngle
, REAL sweepAngle
)
774 TRACE("(%p, %d, %d, %d, %d, %.2f, %.2f)\n",
775 path
, x
, y
, width
, height
, startAngle
, sweepAngle
);
777 return GdipAddPathPie(path
, (REAL
)x
, (REAL
)y
, (REAL
)width
, (REAL
)height
, startAngle
, sweepAngle
);
780 GpStatus WINGDIPAPI
GdipAddPathPolygon(GpPath
*path
, GDIPCONST GpPointF
*points
, INT count
)
784 TRACE("(%p, %p, %d)\n", path
, points
, count
);
786 if(!path
|| !points
|| count
< 3)
787 return InvalidParameter
;
789 if(!lengthen_path(path
, count
))
792 old_count
= path
->pathdata
.Count
;
794 memcpy(&path
->pathdata
.Points
[old_count
], points
, count
*sizeof(GpPointF
));
795 memset(&path
->pathdata
.Types
[old_count
+ 1], PathPointTypeLine
, count
- 1);
797 /* A polygon is an intrinsic figure */
798 path
->pathdata
.Types
[old_count
] = PathPointTypeStart
;
799 path
->pathdata
.Types
[old_count
+ count
- 1] |= PathPointTypeCloseSubpath
;
800 path
->newfigure
= TRUE
;
801 path
->pathdata
.Count
+= count
;
806 GpStatus WINGDIPAPI
GdipAddPathPolygonI(GpPath
*path
, GDIPCONST GpPoint
*points
, INT count
)
812 TRACE("(%p, %p, %d)\n", path
, points
, count
);
814 if(!points
|| count
< 3)
815 return InvalidParameter
;
817 ptf
= GdipAlloc(sizeof(GpPointF
) * count
);
821 for(i
= 0; i
< count
; i
++){
822 ptf
[i
].X
= (REAL
)points
[i
].X
;
823 ptf
[i
].Y
= (REAL
)points
[i
].Y
;
826 status
= GdipAddPathPolygon(path
, ptf
, count
);
833 static float fromfixedpoint(const FIXED v
)
835 float f
= ((float)v
.fract
) / (1<<(sizeof(v
.fract
)*8));
840 struct format_string_args
848 static GpStatus
format_string_callback(HDC dc
,
849 GDIPCONST WCHAR
*string
, INT index
, INT length
, GDIPCONST GpFont
*font
,
850 GDIPCONST RectF
*rect
, GDIPCONST GpStringFormat
*format
,
851 INT lineno
, const RectF
*bounds
, INT
*underlined_indexes
,
852 INT underlined_index_count
, void *priv
)
854 static const MAT2 identity
= { {0,1}, {0,0}, {0,0}, {0,1} };
855 struct format_string_args
*args
= priv
;
856 GpPath
*path
= args
->path
;
857 GpStatus status
= Ok
;
858 float x
= rect
->X
+ (bounds
->X
- rect
->X
) * args
->scale
;
859 float y
= rect
->Y
+ (bounds
->Y
- rect
->Y
) * args
->scale
;
862 if (underlined_index_count
)
863 FIXME("hotkey underlines not drawn yet\n");
865 if (y
+ bounds
->Height
* args
->scale
> args
->maxY
)
866 args
->maxY
= y
+ bounds
->Height
* args
->scale
;
868 for (i
= index
; i
< length
; ++i
)
871 TTPOLYGONHEADER
*ph
= NULL
;
874 len
= GetGlyphOutlineW(dc
, string
[i
], GGO_BEZIER
, &gm
, 0, NULL
, &identity
);
875 if (len
== GDI_ERROR
)
877 status
= GenericError
;
882 if (!ph
|| !lengthen_path(path
, len
/ sizeof(POINTFX
)))
884 status
= OutOfMemory
;
887 GetGlyphOutlineW(dc
, string
[i
], GGO_BEZIER
, &gm
, len
, start
, &identity
);
892 DWORD ofs_start
= ofs
;
893 ph
= (TTPOLYGONHEADER
*)&start
[ofs
];
894 path
->pathdata
.Types
[path
->pathdata
.Count
] = PathPointTypeStart
;
895 path
->pathdata
.Points
[path
->pathdata
.Count
].X
= x
+ fromfixedpoint(ph
->pfxStart
.x
) * args
->scale
;
896 path
->pathdata
.Points
[path
->pathdata
.Count
++].Y
= y
+ args
->ascent
- fromfixedpoint(ph
->pfxStart
.y
) * args
->scale
;
897 TRACE("Starting at count %i with pos %f, %f)\n", path
->pathdata
.Count
, x
, y
);
899 while (ofs
- ofs_start
< ph
->cb
)
901 TTPOLYCURVE
*curve
= (TTPOLYCURVE
*)&start
[ofs
];
903 ofs
+= sizeof(TTPOLYCURVE
) + (curve
->cpfx
- 1) * sizeof(POINTFX
);
905 switch (curve
->wType
)
908 for (j
= 0; j
< curve
->cpfx
; ++j
)
910 path
->pathdata
.Types
[path
->pathdata
.Count
] = PathPointTypeLine
;
911 path
->pathdata
.Points
[path
->pathdata
.Count
].X
= x
+ fromfixedpoint(curve
->apfx
[j
].x
) * args
->scale
;
912 path
->pathdata
.Points
[path
->pathdata
.Count
++].Y
= y
+ args
->ascent
- fromfixedpoint(curve
->apfx
[j
].y
) * args
->scale
;
915 case TT_PRIM_CSPLINE
:
916 for (j
= 0; j
< curve
->cpfx
; ++j
)
918 path
->pathdata
.Types
[path
->pathdata
.Count
] = PathPointTypeBezier
;
919 path
->pathdata
.Points
[path
->pathdata
.Count
].X
= x
+ fromfixedpoint(curve
->apfx
[j
].x
) * args
->scale
;
920 path
->pathdata
.Points
[path
->pathdata
.Count
++].Y
= y
+ args
->ascent
- fromfixedpoint(curve
->apfx
[j
].y
) * args
->scale
;
924 ERR("Unhandled type: %u\n", curve
->wType
);
925 status
= GenericError
;
928 path
->pathdata
.Types
[path
->pathdata
.Count
- 1] |= PathPointTypeCloseSubpath
;
930 path
->newfigure
= TRUE
;
931 x
+= gm
.gmCellIncX
* args
->scale
;
932 y
+= gm
.gmCellIncY
* args
->scale
;
942 GpStatus WINGDIPAPI
GdipAddPathString(GpPath
* path
, GDIPCONST WCHAR
* string
, INT length
, GDIPCONST GpFontFamily
* family
, INT style
, REAL emSize
, GDIPCONST RectF
* layoutRect
, GDIPCONST GpStringFormat
* format
)
950 struct format_string_args args
;
952 UINT16 native_height
;
953 RectF scaled_layout_rect
;
954 TEXTMETRICW textmetric
;
956 TRACE("(%p, %s, %d, %p, %d, %f, %p, %p)\n", path
, debugstr_w(string
), length
, family
, style
, emSize
, layoutRect
, format
);
957 if (!path
|| !string
|| !family
|| !emSize
|| !layoutRect
|| !format
)
958 return InvalidParameter
;
960 status
= GdipGetEmHeight(family
, style
, &native_height
);
964 scaled_layout_rect
.X
= layoutRect
->X
;
965 scaled_layout_rect
.Y
= layoutRect
->Y
;
966 scaled_layout_rect
.Width
= layoutRect
->Width
* native_height
/ emSize
;
967 scaled_layout_rect
.Height
= layoutRect
->Height
* native_height
/ emSize
;
969 status
= GdipCreateFont(family
, native_height
, style
, UnitPixel
, &font
);
973 get_log_fontW(font
, NULL
, &lfw
);
974 hfont
= CreateFontIndirectW(&lfw
);
977 WARN("Failed to create font\n");
981 if ((status
= GdipClonePath(path
, &backup
)) != Ok
)
987 dc
= CreateCompatibleDC(0);
988 SelectObject(dc
, hfont
);
990 GetTextMetricsW(dc
, &textmetric
);
994 args
.scale
= emSize
/ native_height
;
995 args
.ascent
= textmetric
.tmAscent
* args
.scale
;
996 status
= gdip_format_string(dc
, string
, length
, NULL
, &scaled_layout_rect
, format
, format_string_callback
, &args
);
1001 if (status
!= Ok
) /* free backup */
1003 GdipFree(path
->pathdata
.Points
);
1004 GdipFree(path
->pathdata
.Types
);
1009 if (format
&& format
->vertalign
== StringAlignmentCenter
&& layoutRect
->Y
+ args
.maxY
< layoutRect
->Height
)
1011 float inc
= layoutRect
->Height
+ layoutRect
->Y
- args
.maxY
;
1013 for (i
= backup
->pathdata
.Count
; i
< path
->pathdata
.Count
; ++i
)
1014 path
->pathdata
.Points
[i
].Y
+= inc
;
1015 } else if (format
&& format
->vertalign
== StringAlignmentFar
) {
1016 float inc
= layoutRect
->Height
+ layoutRect
->Y
- args
.maxY
;
1017 for (i
= backup
->pathdata
.Count
; i
< path
->pathdata
.Count
; ++i
)
1018 path
->pathdata
.Points
[i
].Y
+= inc
;
1020 GdipDeletePath(backup
);
1024 GpStatus WINGDIPAPI
GdipAddPathStringI(GpPath
* path
, GDIPCONST WCHAR
* string
, INT length
, GDIPCONST GpFontFamily
* family
, INT style
, REAL emSize
, GDIPCONST Rect
* layoutRect
, GDIPCONST GpStringFormat
* format
)
1028 RectF layoutRectF
= {
1029 (REAL
)layoutRect
->X
,
1030 (REAL
)layoutRect
->Y
,
1031 (REAL
)layoutRect
->Width
,
1032 (REAL
)layoutRect
->Height
1034 return GdipAddPathString(path
, string
, length
, family
, style
, emSize
, &layoutRectF
, format
);
1036 return InvalidParameter
;
1039 GpStatus WINGDIPAPI
GdipClonePath(GpPath
* path
, GpPath
**clone
)
1041 TRACE("(%p, %p)\n", path
, clone
);
1044 return InvalidParameter
;
1046 *clone
= GdipAlloc(sizeof(GpPath
));
1047 if(!*clone
) return OutOfMemory
;
1051 (*clone
)->pathdata
.Points
= GdipAlloc(path
->datalen
* sizeof(PointF
));
1052 (*clone
)->pathdata
.Types
= GdipAlloc(path
->datalen
);
1053 if(!(*clone
)->pathdata
.Points
|| !(*clone
)->pathdata
.Types
){
1055 GdipFree((*clone
)->pathdata
.Points
);
1056 GdipFree((*clone
)->pathdata
.Types
);
1060 memcpy((*clone
)->pathdata
.Points
, path
->pathdata
.Points
,
1061 path
->datalen
* sizeof(PointF
));
1062 memcpy((*clone
)->pathdata
.Types
, path
->pathdata
.Types
, path
->datalen
);
1067 GpStatus WINGDIPAPI
GdipClosePathFigure(GpPath
* path
)
1069 TRACE("(%p)\n", path
);
1072 return InvalidParameter
;
1074 if(path
->pathdata
.Count
> 0){
1075 path
->pathdata
.Types
[path
->pathdata
.Count
- 1] |= PathPointTypeCloseSubpath
;
1076 path
->newfigure
= TRUE
;
1082 GpStatus WINGDIPAPI
GdipClosePathFigures(GpPath
* path
)
1086 TRACE("(%p)\n", path
);
1089 return InvalidParameter
;
1091 for(i
= 1; i
< path
->pathdata
.Count
; i
++){
1092 if(path
->pathdata
.Types
[i
] == PathPointTypeStart
)
1093 path
->pathdata
.Types
[i
-1] |= PathPointTypeCloseSubpath
;
1096 path
->newfigure
= TRUE
;
1101 GpStatus WINGDIPAPI
GdipCreatePath(GpFillMode fill
, GpPath
**path
)
1103 TRACE("(%d, %p)\n", fill
, path
);
1106 return InvalidParameter
;
1108 *path
= GdipAlloc(sizeof(GpPath
));
1109 if(!*path
) return OutOfMemory
;
1111 (*path
)->fill
= fill
;
1112 (*path
)->newfigure
= TRUE
;
1117 GpStatus WINGDIPAPI
GdipCreatePath2(GDIPCONST GpPointF
* points
,
1118 GDIPCONST BYTE
* types
, INT count
, GpFillMode fill
, GpPath
**path
)
1120 TRACE("(%p, %p, %d, %d, %p)\n", points
, types
, count
, fill
, path
);
1123 return InvalidParameter
;
1125 *path
= GdipAlloc(sizeof(GpPath
));
1126 if(!*path
) return OutOfMemory
;
1128 (*path
)->pathdata
.Points
= GdipAlloc(count
* sizeof(PointF
));
1129 (*path
)->pathdata
.Types
= GdipAlloc(count
);
1131 if(!(*path
)->pathdata
.Points
|| !(*path
)->pathdata
.Types
){
1132 GdipFree((*path
)->pathdata
.Points
);
1133 GdipFree((*path
)->pathdata
.Types
);
1138 memcpy((*path
)->pathdata
.Points
, points
, count
* sizeof(PointF
));
1139 memcpy((*path
)->pathdata
.Types
, types
, count
);
1140 (*path
)->pathdata
.Count
= count
;
1141 (*path
)->datalen
= count
;
1143 (*path
)->fill
= fill
;
1144 (*path
)->newfigure
= TRUE
;
1149 GpStatus WINGDIPAPI
GdipCreatePath2I(GDIPCONST GpPoint
* points
,
1150 GDIPCONST BYTE
* types
, INT count
, GpFillMode fill
, GpPath
**path
)
1156 TRACE("(%p, %p, %d, %d, %p)\n", points
, types
, count
, fill
, path
);
1158 ptF
= GdipAlloc(sizeof(GpPointF
)*count
);
1160 for(i
= 0;i
< count
; i
++){
1161 ptF
[i
].X
= (REAL
)points
[i
].X
;
1162 ptF
[i
].Y
= (REAL
)points
[i
].Y
;
1165 ret
= GdipCreatePath2(ptF
, types
, count
, fill
, path
);
1172 GpStatus WINGDIPAPI
GdipDeletePath(GpPath
*path
)
1174 TRACE("(%p)\n", path
);
1177 return InvalidParameter
;
1179 GdipFree(path
->pathdata
.Points
);
1180 GdipFree(path
->pathdata
.Types
);
1186 GpStatus WINGDIPAPI
GdipFlattenPath(GpPath
*path
, GpMatrix
* matrix
, REAL flatness
)
1188 path_list_node_t
*list
, *node
;
1193 TRACE("(%p, %p, %.2f)\n", path
, matrix
, flatness
);
1196 return InvalidParameter
;
1199 WARN("transformation not supported yet!\n");
1200 return NotImplemented
;
1203 if(path
->pathdata
.Count
== 0)
1206 pt
= path
->pathdata
.Points
[0];
1207 if(!init_path_list(&list
, pt
.X
, pt
.Y
))
1212 while(i
< path
->pathdata
.Count
){
1214 BYTE type
= path
->pathdata
.Types
[i
] & PathPointTypePathTypeMask
;
1215 path_list_node_t
*start
;
1217 pt
= path
->pathdata
.Points
[i
];
1219 /* save last start point index */
1220 if(type
== PathPointTypeStart
)
1223 /* always add line points and start points */
1224 if((type
== PathPointTypeStart
) || (type
== PathPointTypeLine
)){
1225 if(!add_path_list_node(node
, pt
.X
, pt
.Y
, path
->pathdata
.Types
[i
]))
1235 /* test for closed figure */
1236 if(path
->pathdata
.Types
[i
+1] & PathPointTypeCloseSubpath
){
1237 pt
= path
->pathdata
.Points
[startidx
];
1243 pt
= path
->pathdata
.Points
[i
];
1247 /* add Bezier end point */
1248 type
= (path
->pathdata
.Types
[i
] & ~PathPointTypePathTypeMask
) | PathPointTypeLine
;
1249 if(!add_path_list_node(node
, pt
.X
, pt
.Y
, type
))
1254 if(!flatten_bezier(start
, path
->pathdata
.Points
[i
-2].X
, path
->pathdata
.Points
[i
-2].Y
,
1255 path
->pathdata
.Points
[i
-1].X
, path
->pathdata
.Points
[i
-1].Y
,
1262 /* store path data back */
1263 i
= path_list_count(list
);
1264 if(!lengthen_path(path
, i
))
1266 path
->pathdata
.Count
= i
;
1269 for(i
= 0; i
< path
->pathdata
.Count
; i
++){
1270 path
->pathdata
.Points
[i
] = node
->pt
;
1271 path
->pathdata
.Types
[i
] = node
->type
;
1275 free_path_list(list
);
1279 free_path_list(list
);
1283 GpStatus WINGDIPAPI
GdipGetPathData(GpPath
*path
, GpPathData
* pathData
)
1285 TRACE("(%p, %p)\n", path
, pathData
);
1287 if(!path
|| !pathData
)
1288 return InvalidParameter
;
1290 /* Only copy data. pathData allocation/freeing controlled by wrapper class.
1291 Assumed that pathData is enough wide to get all data - controlled by wrapper too. */
1292 memcpy(pathData
->Points
, path
->pathdata
.Points
, sizeof(PointF
) * pathData
->Count
);
1293 memcpy(pathData
->Types
, path
->pathdata
.Types
, pathData
->Count
);
1298 GpStatus WINGDIPAPI
GdipGetPathFillMode(GpPath
*path
, GpFillMode
*fillmode
)
1300 TRACE("(%p, %p)\n", path
, fillmode
);
1302 if(!path
|| !fillmode
)
1303 return InvalidParameter
;
1305 *fillmode
= path
->fill
;
1310 GpStatus WINGDIPAPI
GdipGetPathLastPoint(GpPath
* path
, GpPointF
* lastPoint
)
1314 TRACE("(%p, %p)\n", path
, lastPoint
);
1316 if(!path
|| !lastPoint
)
1317 return InvalidParameter
;
1319 count
= path
->pathdata
.Count
;
1321 *lastPoint
= path
->pathdata
.Points
[count
-1];
1326 GpStatus WINGDIPAPI
GdipGetPathPoints(GpPath
*path
, GpPointF
* points
, INT count
)
1328 TRACE("(%p, %p, %d)\n", path
, points
, count
);
1331 return InvalidParameter
;
1333 if(count
< path
->pathdata
.Count
)
1334 return InsufficientBuffer
;
1336 memcpy(points
, path
->pathdata
.Points
, path
->pathdata
.Count
* sizeof(GpPointF
));
1341 GpStatus WINGDIPAPI
GdipGetPathPointsI(GpPath
*path
, GpPoint
* points
, INT count
)
1347 TRACE("(%p, %p, %d)\n", path
, points
, count
);
1350 return InvalidParameter
;
1352 ptf
= GdipAlloc(sizeof(GpPointF
)*count
);
1353 if(!ptf
) return OutOfMemory
;
1355 ret
= GdipGetPathPoints(path
,ptf
,count
);
1357 for(i
= 0;i
< count
;i
++){
1358 points
[i
].X
= roundr(ptf
[i
].X
);
1359 points
[i
].Y
= roundr(ptf
[i
].Y
);
1366 GpStatus WINGDIPAPI
GdipGetPathTypes(GpPath
*path
, BYTE
* types
, INT count
)
1368 TRACE("(%p, %p, %d)\n", path
, types
, count
);
1371 return InvalidParameter
;
1373 if(count
< path
->pathdata
.Count
)
1374 return InsufficientBuffer
;
1376 memcpy(types
, path
->pathdata
.Types
, path
->pathdata
.Count
);
1381 /* Windows expands the bounding box to the maximum possible bounding box
1382 * for a given pen. For example, if a line join can extend past the point
1383 * it's joining by x units, the bounding box is extended by x units in every
1384 * direction (even though this is too conservative for most cases). */
1385 GpStatus WINGDIPAPI
GdipGetPathWorldBounds(GpPath
* path
, GpRectF
* bounds
,
1386 GDIPCONST GpMatrix
*matrix
, GDIPCONST GpPen
*pen
)
1388 GpPointF
* points
, temp_pts
[4];
1390 REAL path_width
= 1.0, width
, height
, temp
, low_x
, low_y
, high_x
, high_y
;
1392 TRACE("(%p, %p, %p, %p)\n", path
, bounds
, matrix
, pen
);
1394 /* Matrix and pen can be null. */
1395 if(!path
|| !bounds
)
1396 return InvalidParameter
;
1398 /* If path is empty just return. */
1399 count
= path
->pathdata
.Count
;
1401 bounds
->X
= bounds
->Y
= bounds
->Width
= bounds
->Height
= 0.0;
1405 points
= path
->pathdata
.Points
;
1407 low_x
= high_x
= points
[0].X
;
1408 low_y
= high_y
= points
[0].Y
;
1410 for(i
= 1; i
< count
; i
++){
1411 low_x
= min(low_x
, points
[i
].X
);
1412 low_y
= min(low_y
, points
[i
].Y
);
1413 high_x
= max(high_x
, points
[i
].X
);
1414 high_y
= max(high_y
, points
[i
].Y
);
1417 width
= high_x
- low_x
;
1418 height
= high_y
- low_y
;
1420 /* This looks unusual but it's the only way I can imitate windows. */
1422 temp_pts
[0].X
= low_x
;
1423 temp_pts
[0].Y
= low_y
;
1424 temp_pts
[1].X
= low_x
;
1425 temp_pts
[1].Y
= high_y
;
1426 temp_pts
[2].X
= high_x
;
1427 temp_pts
[2].Y
= high_y
;
1428 temp_pts
[3].X
= high_x
;
1429 temp_pts
[3].Y
= low_y
;
1431 GdipTransformMatrixPoints((GpMatrix
*)matrix
, temp_pts
, 4);
1432 low_x
= temp_pts
[0].X
;
1433 low_y
= temp_pts
[0].Y
;
1435 for(i
= 1; i
< 4; i
++){
1436 low_x
= min(low_x
, temp_pts
[i
].X
);
1437 low_y
= min(low_y
, temp_pts
[i
].Y
);
1441 width
= height
* fabs(matrix
->matrix
[2]) + width
* fabs(matrix
->matrix
[0]);
1442 height
= height
* fabs(matrix
->matrix
[3]) + temp
* fabs(matrix
->matrix
[1]);
1446 path_width
= pen
->width
/ 2.0;
1449 path_width
= max(path_width
, pen
->width
* pen
->miterlimit
/ 2.0);
1450 /* FIXME: this should probably also check for the startcap */
1451 if(pen
->endcap
& LineCapNoAnchor
)
1452 path_width
= max(path_width
, pen
->width
* 2.2);
1454 low_x
-= path_width
;
1455 low_y
-= path_width
;
1456 width
+= 2.0 * path_width
;
1457 height
+= 2.0 * path_width
;
1462 bounds
->Width
= width
;
1463 bounds
->Height
= height
;
1468 GpStatus WINGDIPAPI
GdipGetPathWorldBoundsI(GpPath
* path
, GpRect
* bounds
,
1469 GDIPCONST GpMatrix
*matrix
, GDIPCONST GpPen
*pen
)
1474 TRACE("(%p, %p, %p, %p)\n", path
, bounds
, matrix
, pen
);
1476 ret
= GdipGetPathWorldBounds(path
,&boundsF
,matrix
,pen
);
1479 bounds
->X
= roundr(boundsF
.X
);
1480 bounds
->Y
= roundr(boundsF
.Y
);
1481 bounds
->Width
= roundr(boundsF
.Width
);
1482 bounds
->Height
= roundr(boundsF
.Height
);
1488 GpStatus WINGDIPAPI
GdipGetPointCount(GpPath
*path
, INT
*count
)
1490 TRACE("(%p, %p)\n", path
, count
);
1493 return InvalidParameter
;
1495 *count
= path
->pathdata
.Count
;
1500 GpStatus WINGDIPAPI
GdipReversePath(GpPath
* path
)
1503 INT start
= 0; /* position in reversed path */
1506 TRACE("(%p)\n", path
);
1509 return InvalidParameter
;
1511 count
= path
->pathdata
.Count
;
1513 if(count
== 0) return Ok
;
1515 revpath
.Points
= GdipAlloc(sizeof(GpPointF
)*count
);
1516 revpath
.Types
= GdipAlloc(sizeof(BYTE
)*count
);
1517 revpath
.Count
= count
;
1518 if(!revpath
.Points
|| !revpath
.Types
){
1519 GdipFree(revpath
.Points
);
1520 GdipFree(revpath
.Types
);
1524 for(i
= 0; i
< count
; i
++){
1526 /* find next start point */
1527 if(path
->pathdata
.Types
[count
-i
-1] == PathPointTypeStart
){
1529 for(j
= start
; j
<= i
; j
++){
1530 revpath
.Points
[j
] = path
->pathdata
.Points
[count
-j
-1];
1531 revpath
.Types
[j
] = path
->pathdata
.Types
[count
-j
-1];
1533 /* mark start point */
1534 revpath
.Types
[start
] = PathPointTypeStart
;
1535 /* set 'figure' endpoint type */
1537 revpath
.Types
[i
] = path
->pathdata
.Types
[count
-start
-1] & ~PathPointTypePathTypeMask
;
1538 revpath
.Types
[i
] |= revpath
.Types
[i
-1];
1541 revpath
.Types
[i
] = path
->pathdata
.Types
[start
];
1547 memcpy(path
->pathdata
.Points
, revpath
.Points
, sizeof(GpPointF
)*count
);
1548 memcpy(path
->pathdata
.Types
, revpath
.Types
, sizeof(BYTE
)*count
);
1550 GdipFree(revpath
.Points
);
1551 GdipFree(revpath
.Types
);
1556 GpStatus WINGDIPAPI
GdipIsOutlineVisiblePathPointI(GpPath
* path
, INT x
, INT y
,
1557 GpPen
*pen
, GpGraphics
*graphics
, BOOL
*result
)
1559 TRACE("(%p, %d, %d, %p, %p, %p)\n", path
, x
, y
, pen
, graphics
, result
);
1561 return GdipIsOutlineVisiblePathPoint(path
, x
, y
, pen
, graphics
, result
);
1564 GpStatus WINGDIPAPI
GdipIsOutlineVisiblePathPoint(GpPath
* path
, REAL x
, REAL y
,
1565 GpPen
*pen
, GpGraphics
*graphics
, BOOL
*result
)
1569 TRACE("(%p,%0.2f,%0.2f,%p,%p,%p)\n", path
, x
, y
, pen
, graphics
, result
);
1572 return InvalidParameter
;
1575 FIXME("not implemented\n");
1577 return NotImplemented
;
1580 GpStatus WINGDIPAPI
GdipIsVisiblePathPointI(GpPath
* path
, INT x
, INT y
, GpGraphics
*graphics
, BOOL
*result
)
1582 TRACE("(%p, %d, %d, %p, %p)\n", path
, x
, y
, graphics
, result
);
1584 return GdipIsVisiblePathPoint(path
, x
, y
, graphics
, result
);
1587 /*****************************************************************************
1588 * GdipIsVisiblePathPoint [GDIPLUS.@]
1590 GpStatus WINGDIPAPI
GdipIsVisiblePathPoint(GpPath
* path
, REAL x
, REAL y
, GpGraphics
*graphics
, BOOL
*result
)
1596 if(!path
|| !result
) return InvalidParameter
;
1598 status
= GdipCreateRegionPath(path
, ®ion
);
1602 status
= GdipGetRegionHRgn(region
, graphics
, &hrgn
);
1604 GdipDeleteRegion(region
);
1608 *result
= PtInRegion(hrgn
, roundr(x
), roundr(y
));
1611 GdipDeleteRegion(region
);
1616 GpStatus WINGDIPAPI
GdipStartPathFigure(GpPath
*path
)
1618 TRACE("(%p)\n", path
);
1621 return InvalidParameter
;
1623 path
->newfigure
= TRUE
;
1628 GpStatus WINGDIPAPI
GdipResetPath(GpPath
*path
)
1630 TRACE("(%p)\n", path
);
1633 return InvalidParameter
;
1635 path
->pathdata
.Count
= 0;
1636 path
->newfigure
= TRUE
;
1637 path
->fill
= FillModeAlternate
;
1642 GpStatus WINGDIPAPI
GdipSetPathFillMode(GpPath
*path
, GpFillMode fill
)
1644 TRACE("(%p, %d)\n", path
, fill
);
1647 return InvalidParameter
;
1654 GpStatus WINGDIPAPI
GdipTransformPath(GpPath
*path
, GpMatrix
*matrix
)
1656 TRACE("(%p, %p)\n", path
, matrix
);
1659 return InvalidParameter
;
1661 if(path
->pathdata
.Count
== 0)
1664 return GdipTransformMatrixPoints(matrix
, path
->pathdata
.Points
,
1665 path
->pathdata
.Count
);
1668 GpStatus WINGDIPAPI
GdipWarpPath(GpPath
*path
, GpMatrix
* matrix
,
1669 GDIPCONST GpPointF
*points
, INT count
, REAL x
, REAL y
, REAL width
,
1670 REAL height
, WarpMode warpmode
, REAL flatness
)
1672 FIXME("(%p,%p,%p,%i,%0.2f,%0.2f,%0.2f,%0.2f,%i,%0.2f)\n", path
, matrix
,
1673 points
, count
, x
, y
, width
, height
, warpmode
, flatness
);
1675 return NotImplemented
;
1678 static void add_bevel_point(const GpPointF
*endpoint
, const GpPointF
*nextpoint
,
1679 GpPen
*pen
, int right_side
, path_list_node_t
**last_point
)
1681 REAL segment_dy
= nextpoint
->Y
-endpoint
->Y
;
1682 REAL segment_dx
= nextpoint
->X
-endpoint
->X
;
1683 REAL segment_length
= sqrtf(segment_dy
*segment_dy
+ segment_dx
*segment_dx
);
1684 REAL distance
= pen
->width
/2.0;
1685 REAL bevel_dx
, bevel_dy
;
1689 bevel_dx
= -distance
* segment_dy
/ segment_length
;
1690 bevel_dy
= distance
* segment_dx
/ segment_length
;
1694 bevel_dx
= distance
* segment_dy
/ segment_length
;
1695 bevel_dy
= -distance
* segment_dx
/ segment_length
;
1698 *last_point
= add_path_list_node(*last_point
, endpoint
->X
+ bevel_dx
,
1699 endpoint
->Y
+ bevel_dy
, PathPointTypeLine
);
1702 static void widen_joint(const GpPointF
*p1
, const GpPointF
*p2
, const GpPointF
*p3
,
1703 GpPen
* pen
, path_list_node_t
**last_point
)
1709 add_bevel_point(p2
, p1
, pen
, 1, last_point
);
1710 add_bevel_point(p2
, p3
, pen
, 0, last_point
);
1715 static void widen_cap(const GpPointF
*endpoint
, const GpPointF
*nextpoint
,
1716 GpPen
*pen
, GpLineCap cap
, GpCustomLineCap
*custom
, int add_first_points
,
1717 int add_last_point
, path_list_node_t
**last_point
)
1723 if (add_first_points
)
1724 add_bevel_point(endpoint
, nextpoint
, pen
, 1, last_point
);
1726 add_bevel_point(endpoint
, nextpoint
, pen
, 0, last_point
);
1731 static void widen_open_figure(GpPath
*path
, GpPen
*pen
, int start
, int end
,
1732 path_list_node_t
**last_point
)
1739 widen_cap(&path
->pathdata
.Points
[start
], &path
->pathdata
.Points
[start
+1],
1740 pen
, pen
->startcap
, pen
->customstart
, FALSE
, TRUE
, last_point
);
1742 (*last_point
)->type
= PathPointTypeStart
;
1744 for (i
=start
+1; i
<end
; i
++)
1745 widen_joint(&path
->pathdata
.Points
[i
-1], &path
->pathdata
.Points
[i
],
1746 &path
->pathdata
.Points
[i
+1], pen
, last_point
);
1748 widen_cap(&path
->pathdata
.Points
[end
], &path
->pathdata
.Points
[end
-1],
1749 pen
, pen
->endcap
, pen
->customend
, TRUE
, TRUE
, last_point
);
1751 for (i
=end
-1; i
>start
; i
--)
1752 widen_joint(&path
->pathdata
.Points
[i
+1], &path
->pathdata
.Points
[i
],
1753 &path
->pathdata
.Points
[i
-1], pen
, last_point
);
1755 widen_cap(&path
->pathdata
.Points
[start
], &path
->pathdata
.Points
[start
+1],
1756 pen
, pen
->startcap
, pen
->customstart
, TRUE
, FALSE
, last_point
);
1758 (*last_point
)->type
|= PathPointTypeCloseSubpath
;
1761 static void widen_closed_figure(GpPath
*path
, GpPen
*pen
, int start
, int end
,
1762 path_list_node_t
**last_point
)
1765 path_list_node_t
*prev_point
;
1771 prev_point
= *last_point
;
1773 widen_joint(&path
->pathdata
.Points
[end
], &path
->pathdata
.Points
[start
],
1774 &path
->pathdata
.Points
[start
+1], pen
, last_point
);
1776 for (i
=start
+1; i
<end
; i
++)
1777 widen_joint(&path
->pathdata
.Points
[i
-1], &path
->pathdata
.Points
[i
],
1778 &path
->pathdata
.Points
[i
+1], pen
, last_point
);
1780 widen_joint(&path
->pathdata
.Points
[end
-1], &path
->pathdata
.Points
[end
],
1781 &path
->pathdata
.Points
[start
], pen
, last_point
);
1783 prev_point
->next
->type
= PathPointTypeStart
;
1784 (*last_point
)->type
|= PathPointTypeCloseSubpath
;
1787 prev_point
= *last_point
;
1789 widen_joint(&path
->pathdata
.Points
[start
], &path
->pathdata
.Points
[end
],
1790 &path
->pathdata
.Points
[end
-1], pen
, last_point
);
1792 for (i
=end
-1; i
>start
; i
--)
1793 widen_joint(&path
->pathdata
.Points
[i
+1], &path
->pathdata
.Points
[i
],
1794 &path
->pathdata
.Points
[i
-1], pen
, last_point
);
1796 widen_joint(&path
->pathdata
.Points
[start
+1], &path
->pathdata
.Points
[start
],
1797 &path
->pathdata
.Points
[end
], pen
, last_point
);
1799 prev_point
->next
->type
= PathPointTypeStart
;
1800 (*last_point
)->type
|= PathPointTypeCloseSubpath
;
1803 GpStatus WINGDIPAPI
GdipWidenPath(GpPath
*path
, GpPen
*pen
, GpMatrix
*matrix
,
1806 GpPath
*flat_path
=NULL
;
1808 path_list_node_t
*points
=NULL
, *last_point
=NULL
;
1809 int i
, subpath_start
=0, new_length
;
1812 TRACE("(%p,%p,%p,%0.2f)\n", path
, pen
, matrix
, flatness
);
1815 return InvalidParameter
;
1817 if (path
->pathdata
.Count
<= 1)
1820 status
= GdipClonePath(path
, &flat_path
);
1823 status
= GdipFlattenPath(flat_path
, matrix
, flatness
);
1825 if (status
== Ok
&& !init_path_list(&points
, 314.0, 22.0))
1826 status
= OutOfMemory
;
1830 last_point
= points
;
1832 if (pen
->endcap
!= LineCapFlat
)
1833 FIXME("unimplemented end cap %x\n", pen
->endcap
);
1835 if (pen
->startcap
!= LineCapFlat
)
1836 FIXME("unimplemented start cap %x\n", pen
->startcap
);
1838 if (pen
->dashcap
!= DashCapFlat
)
1839 FIXME("unimplemented dash cap %d\n", pen
->dashcap
);
1841 if (pen
->join
!= LineJoinBevel
)
1842 FIXME("unimplemented line join %d\n", pen
->join
);
1844 if (pen
->dash
!= DashStyleSolid
)
1845 FIXME("unimplemented dash style %d\n", pen
->dash
);
1847 if (pen
->align
!= PenAlignmentCenter
)
1848 FIXME("unimplemented pen alignment %d\n", pen
->align
);
1850 for (i
=0; i
< flat_path
->pathdata
.Count
; i
++)
1852 type
= flat_path
->pathdata
.Types
[i
];
1854 if ((type
&PathPointTypePathTypeMask
) == PathPointTypeStart
)
1857 if ((type
&PathPointTypeCloseSubpath
) == PathPointTypeCloseSubpath
)
1859 widen_closed_figure(flat_path
, pen
, subpath_start
, i
, &last_point
);
1861 else if (i
== flat_path
->pathdata
.Count
-1 ||
1862 (flat_path
->pathdata
.Types
[i
+1]&PathPointTypePathTypeMask
) == PathPointTypeStart
)
1864 widen_open_figure(flat_path
, pen
, subpath_start
, i
, &last_point
);
1868 new_length
= path_list_count(points
)-1;
1870 if (!lengthen_path(path
, new_length
))
1871 status
= OutOfMemory
;
1876 path
->pathdata
.Count
= new_length
;
1878 last_point
= points
->next
;
1879 for (i
= 0; i
< new_length
; i
++)
1881 path
->pathdata
.Points
[i
] = last_point
->pt
;
1882 path
->pathdata
.Types
[i
] = last_point
->type
;
1883 last_point
= last_point
->next
;
1886 path
->fill
= FillModeWinding
;
1889 free_path_list(points
);
1891 GdipDeletePath(flat_path
);
1896 GpStatus WINGDIPAPI
GdipAddPathRectangle(GpPath
*path
, REAL x
, REAL y
,
1897 REAL width
, REAL height
)
1904 TRACE("(%p, %.2f, %.2f, %.2f, %.2f)\n", path
, x
, y
, width
, height
);
1907 return InvalidParameter
;
1909 /* make a backup copy of path data */
1910 if((retstat
= GdipClonePath(path
, &backup
)) != Ok
)
1913 /* rectangle should start as new path */
1914 old_new
= path
->newfigure
;
1915 path
->newfigure
= TRUE
;
1916 if((retstat
= GdipAddPathLine(path
,x
,y
,x
+width
,y
)) != Ok
){
1917 path
->newfigure
= old_new
;
1922 ptf
[0].Y
= y
+height
;
1924 ptf
[1].Y
= y
+height
;
1926 if((retstat
= GdipAddPathLine2(path
, ptf
, 2)) != Ok
) goto fail
;
1927 path
->pathdata
.Types
[path
->pathdata
.Count
-1] |= PathPointTypeCloseSubpath
;
1930 GdipDeletePath(backup
);
1935 GdipFree(path
->pathdata
.Points
);
1936 GdipFree(path
->pathdata
.Types
);
1937 memcpy(path
, backup
, sizeof(*path
));
1943 GpStatus WINGDIPAPI
GdipAddPathRectangleI(GpPath
*path
, INT x
, INT y
,
1944 INT width
, INT height
)
1946 TRACE("(%p, %d, %d, %d, %d)\n", path
, x
, y
, width
, height
);
1948 return GdipAddPathRectangle(path
,(REAL
)x
,(REAL
)y
,(REAL
)width
,(REAL
)height
);
1951 GpStatus WINGDIPAPI
GdipAddPathRectangles(GpPath
*path
, GDIPCONST GpRectF
*rects
, INT count
)
1957 TRACE("(%p, %p, %d)\n", path
, rects
, count
);
1959 /* count == 0 - verified condition */
1960 if(!path
|| !rects
|| count
== 0)
1961 return InvalidParameter
;
1966 /* make a backup copy */
1967 if((retstat
= GdipClonePath(path
, &backup
)) != Ok
)
1970 for(i
= 0; i
< count
; i
++){
1971 if((retstat
= GdipAddPathRectangle(path
,rects
[i
].X
,rects
[i
].Y
,rects
[i
].Width
,rects
[i
].Height
)) != Ok
)
1976 GdipDeletePath(backup
);
1981 GdipFree(path
->pathdata
.Points
);
1982 GdipFree(path
->pathdata
.Types
);
1983 memcpy(path
, backup
, sizeof(*path
));
1989 GpStatus WINGDIPAPI
GdipAddPathRectanglesI(GpPath
*path
, GDIPCONST GpRect
*rects
, INT count
)
1995 TRACE("(%p, %p, %d)\n", path
, rects
, count
);
1997 if(!rects
|| count
== 0)
1998 return InvalidParameter
;
2003 rectsF
= GdipAlloc(sizeof(GpRectF
)*count
);
2005 for(i
= 0;i
< count
;i
++){
2006 rectsF
[i
].X
= (REAL
)rects
[i
].X
;
2007 rectsF
[i
].Y
= (REAL
)rects
[i
].Y
;
2008 rectsF
[i
].Width
= (REAL
)rects
[i
].Width
;
2009 rectsF
[i
].Height
= (REAL
)rects
[i
].Height
;
2012 retstat
= GdipAddPathRectangles(path
, rectsF
, count
);
2018 GpStatus WINGDIPAPI
GdipSetPathMarker(GpPath
* path
)
2022 TRACE("(%p)\n", path
);
2025 return InvalidParameter
;
2027 count
= path
->pathdata
.Count
;
2029 /* set marker flag */
2031 path
->pathdata
.Types
[count
-1] |= PathPointTypePathMarker
;
2036 GpStatus WINGDIPAPI
GdipClearPathMarkers(GpPath
* path
)
2041 TRACE("(%p)\n", path
);
2044 return InvalidParameter
;
2046 count
= path
->pathdata
.Count
;
2048 for(i
= 0; i
< count
- 1; i
++){
2049 path
->pathdata
.Types
[i
] &= ~PathPointTypePathMarker
;
2055 GpStatus WINGDIPAPI
GdipWindingModeOutline(GpPath
*path
, GpMatrix
*matrix
, REAL flatness
)
2057 FIXME("stub: %p, %p, %.2f\n", path
, matrix
, flatness
);
2058 return NotImplemented
;