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 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
846 static GpStatus format_string_callback(HDC dc,
847 GDIPCONST WCHAR *string, INT index, INT length, GDIPCONST GpFont *font,
848 GDIPCONST RectF *rect, GDIPCONST GpStringFormat *format,
849 INT lineno, const RectF *bounds, INT *underlined_indexes,
850 INT underlined_index_count, void *priv)
852 static const MAT2 identity = { {0,1}, {0,0}, {0,0}, {0,1} };
853 struct format_string_args *args = priv;
854 GpPath *path = args->path;
855 GpStatus status = Ok;
860 if (underlined_index_count)
861 FIXME("hotkey underlines not drawn yet\n");
863 for (i = index; i < length; ++i)
866 TTPOLYGONHEADER *ph = NULL;
870 len = GetGlyphOutlineW(dc, string[i], GGO_BEZIER, &gm, 0, NULL, &identity);
871 if (len == GDI_ERROR)
873 status = GenericError;
878 if (!ph || !lengthen_path(path, len / sizeof(POINTFX)))
880 status = OutOfMemory;
883 GetGlyphOutlineW(dc, string[i], GGO_BEZIER, &gm, len, start, &identity);
884 bb_end = gm.gmBlackBoxY + gm.gmptGlyphOrigin.y;
885 if (bb_end + y > args->maxY)
886 args->maxY = bb_end + y;
891 DWORD ofs_start = ofs;
892 ph = (TTPOLYGONHEADER*)&start[ofs];
893 path->pathdata.Types[path->pathdata.Count] = PathPointTypeStart;
894 path->pathdata.Points[path->pathdata.Count].X = x + fromfixedpoint(ph->pfxStart.x);
895 path->pathdata.Points[path->pathdata.Count++].Y = y + bb_end - fromfixedpoint(ph->pfxStart.y);
896 TRACE("Starting at count %i with pos %f, %f)\n", path->pathdata.Count, x, y);
898 while (ofs - ofs_start < ph->cb)
900 TTPOLYCURVE *curve = (TTPOLYCURVE*)&start[ofs];
902 ofs += sizeof(TTPOLYCURVE) + (curve->cpfx - 1) * sizeof(POINTFX);
904 switch (curve->wType)
907 for (j = 0; j < curve->cpfx; ++j)
909 path->pathdata.Types[path->pathdata.Count] = PathPointTypeLine;
910 path->pathdata.Points[path->pathdata.Count].X = x + fromfixedpoint(curve->apfx[j].x);
911 path->pathdata.Points[path->pathdata.Count++].Y = y + bb_end - fromfixedpoint(curve->apfx[j].y);
914 case TT_PRIM_CSPLINE:
915 for (j = 0; j < curve->cpfx; ++j)
917 path->pathdata.Types[path->pathdata.Count] = PathPointTypeBezier;
918 path->pathdata.Points[path->pathdata.Count].X = x + fromfixedpoint(curve->apfx[j].x);
919 path->pathdata.Points[path->pathdata.Count++].Y = y + bb_end - fromfixedpoint(curve->apfx[j].y);
923 ERR("Unhandled type: %u\n", curve->wType);
924 status = GenericError;
927 path->pathdata.Types[path->pathdata.Count - 1] |= PathPointTypeCloseSubpath;
929 path->newfigure = TRUE;
941 GpStatus WINGDIPAPI GdipAddPathString(GpPath* path, GDIPCONST WCHAR* string, INT length, GDIPCONST GpFontFamily* family, INT style, REAL emSize, GDIPCONST RectF* layoutRect, GDIPCONST GpStringFormat* format)
949 struct format_string_args args;
952 FIXME("(%p, %s, %d, %p, %d, %f, %p, %p): stub\n", path, debugstr_w(string), length, family, style, emSize, layoutRect, format);
953 if (!path || !string || !family || !emSize || !layoutRect || !format)
954 return InvalidParameter;
956 status = GdipCreateFont(family, emSize, style, UnitPixel, &font);
960 status = GdipGetLogFontW((GpFont *)font, NULL, &lfw);
961 if (status != Ok) return status;
962 hfont = CreateFontIndirectW(&lfw);
965 WARN("Failed to create font\n");
969 if ((status = GdipClonePath(path, &backup)) != Ok)
975 dc = CreateCompatibleDC(0);
976 SelectObject(dc, hfont);
980 status = gdip_format_string(dc, string, length, NULL, layoutRect, format, format_string_callback, &args);
985 if (status != Ok) /* free backup */
987 GdipFree(path->pathdata.Points);
988 GdipFree(path->pathdata.Types);
993 if (format && format->vertalign == StringAlignmentCenter && layoutRect->Y + args.maxY < layoutRect->Height)
995 float inc = layoutRect->Height - args.maxY - layoutRect->Y;
997 for (i = backup->pathdata.Count; i < path->pathdata.Count; ++i)
998 path->pathdata.Points[i].Y += inc;
999 } else if (format && format->vertalign == StringAlignmentFar) {
1000 float inc = layoutRect->Height - args.maxY - layoutRect->Y;
1001 for (i = backup->pathdata.Count; i < path->pathdata.Count; ++i)
1002 path->pathdata.Points[i].Y += inc;
1004 GdipDeletePath(backup);
1008 GpStatus WINGDIPAPI GdipAddPathStringI(GpPath* path, GDIPCONST WCHAR* string, INT length, GDIPCONST GpFontFamily* family, INT style, REAL emSize, GDIPCONST Rect* layoutRect, GDIPCONST GpStringFormat* format)
1012 RectF layoutRectF = {
1013 (REAL)layoutRect->X,
1014 (REAL)layoutRect->Y,
1015 (REAL)layoutRect->Width,
1016 (REAL)layoutRect->Height
1018 return GdipAddPathString(path, string, length, family, style, emSize, &layoutRectF, format);
1020 return InvalidParameter;
1023 GpStatus WINGDIPAPI GdipClonePath(GpPath* path, GpPath **clone)
1025 TRACE("(%p, %p)\n", path, clone);
1028 return InvalidParameter;
1030 *clone = GdipAlloc(sizeof(GpPath));
1031 if(!*clone) return OutOfMemory;
1035 (*clone)->pathdata.Points = GdipAlloc(path->datalen * sizeof(PointF));
1036 (*clone)->pathdata.Types = GdipAlloc(path->datalen);
1037 if(!(*clone)->pathdata.Points || !(*clone)->pathdata.Types){
1039 GdipFree((*clone)->pathdata.Points);
1040 GdipFree((*clone)->pathdata.Types);
1044 memcpy((*clone)->pathdata.Points, path->pathdata.Points,
1045 path->datalen * sizeof(PointF));
1046 memcpy((*clone)->pathdata.Types, path->pathdata.Types, path->datalen);
1051 GpStatus WINGDIPAPI GdipClosePathFigure(GpPath* path)
1053 TRACE("(%p)\n", path);
1056 return InvalidParameter;
1058 if(path->pathdata.Count > 0){
1059 path->pathdata.Types[path->pathdata.Count - 1] |= PathPointTypeCloseSubpath;
1060 path->newfigure = TRUE;
1066 GpStatus WINGDIPAPI GdipClosePathFigures(GpPath* path)
1070 TRACE("(%p)\n", path);
1073 return InvalidParameter;
1075 for(i = 1; i < path->pathdata.Count; i++){
1076 if(path->pathdata.Types[i] == PathPointTypeStart)
1077 path->pathdata.Types[i-1] |= PathPointTypeCloseSubpath;
1080 path->newfigure = TRUE;
1085 GpStatus WINGDIPAPI GdipCreatePath(GpFillMode fill, GpPath **path)
1087 TRACE("(%d, %p)\n", fill, path);
1090 return InvalidParameter;
1092 *path = GdipAlloc(sizeof(GpPath));
1093 if(!*path) return OutOfMemory;
1095 (*path)->fill = fill;
1096 (*path)->newfigure = TRUE;
1101 GpStatus WINGDIPAPI GdipCreatePath2(GDIPCONST GpPointF* points,
1102 GDIPCONST BYTE* types, INT count, GpFillMode fill, GpPath **path)
1104 TRACE("(%p, %p, %d, %d, %p)\n", points, types, count, fill, path);
1107 return InvalidParameter;
1109 *path = GdipAlloc(sizeof(GpPath));
1110 if(!*path) return OutOfMemory;
1112 (*path)->pathdata.Points = GdipAlloc(count * sizeof(PointF));
1113 (*path)->pathdata.Types = GdipAlloc(count);
1115 if(!(*path)->pathdata.Points || !(*path)->pathdata.Types){
1116 GdipFree((*path)->pathdata.Points);
1117 GdipFree((*path)->pathdata.Types);
1122 memcpy((*path)->pathdata.Points, points, count * sizeof(PointF));
1123 memcpy((*path)->pathdata.Types, types, count);
1124 (*path)->pathdata.Count = count;
1125 (*path)->datalen = count;
1127 (*path)->fill = fill;
1128 (*path)->newfigure = TRUE;
1133 GpStatus WINGDIPAPI GdipCreatePath2I(GDIPCONST GpPoint* points,
1134 GDIPCONST BYTE* types, INT count, GpFillMode fill, GpPath **path)
1140 TRACE("(%p, %p, %d, %d, %p)\n", points, types, count, fill, path);
1142 ptF = GdipAlloc(sizeof(GpPointF)*count);
1144 for(i = 0;i < count; i++){
1145 ptF[i].X = (REAL)points[i].X;
1146 ptF[i].Y = (REAL)points[i].Y;
1149 ret = GdipCreatePath2(ptF, types, count, fill, path);
1156 GpStatus WINGDIPAPI GdipDeletePath(GpPath *path)
1158 TRACE("(%p)\n", path);
1161 return InvalidParameter;
1163 GdipFree(path->pathdata.Points);
1164 GdipFree(path->pathdata.Types);
1170 GpStatus WINGDIPAPI GdipFlattenPath(GpPath *path, GpMatrix* matrix, REAL flatness)
1172 path_list_node_t *list, *node;
1177 TRACE("(%p, %p, %.2f)\n", path, matrix, flatness);
1180 return InvalidParameter;
1183 WARN("transformation not supported yet!\n");
1184 return NotImplemented;
1187 if(path->pathdata.Count == 0)
1190 pt = path->pathdata.Points[0];
1191 if(!init_path_list(&list, pt.X, pt.Y))
1196 while(i < path->pathdata.Count){
1198 BYTE type = path->pathdata.Types[i] & PathPointTypePathTypeMask;
1199 path_list_node_t *start;
1201 pt = path->pathdata.Points[i];
1203 /* save last start point index */
1204 if(type == PathPointTypeStart)
1207 /* always add line points and start points */
1208 if((type == PathPointTypeStart) || (type == PathPointTypeLine)){
1209 if(!add_path_list_node(node, pt.X, pt.Y, path->pathdata.Types[i]))
1219 /* test for closed figure */
1220 if(path->pathdata.Types[i+1] & PathPointTypeCloseSubpath){
1221 pt = path->pathdata.Points[startidx];
1227 pt = path->pathdata.Points[i];
1231 /* add Bezier end point */
1232 type = (path->pathdata.Types[i] & ~PathPointTypePathTypeMask) | PathPointTypeLine;
1233 if(!add_path_list_node(node, pt.X, pt.Y, type))
1238 if(!flatten_bezier(start, path->pathdata.Points[i-2].X, path->pathdata.Points[i-2].Y,
1239 path->pathdata.Points[i-1].X, path->pathdata.Points[i-1].Y,
1246 /* store path data back */
1247 i = path_list_count(list);
1248 if(!lengthen_path(path, i))
1250 path->pathdata.Count = i;
1253 for(i = 0; i < path->pathdata.Count; i++){
1254 path->pathdata.Points[i] = node->pt;
1255 path->pathdata.Types[i] = node->type;
1259 free_path_list(list);
1263 free_path_list(list);
1267 GpStatus WINGDIPAPI GdipGetPathData(GpPath *path, GpPathData* pathData)
1269 TRACE("(%p, %p)\n", path, pathData);
1271 if(!path || !pathData)
1272 return InvalidParameter;
1274 /* Only copy data. pathData allocation/freeing controlled by wrapper class.
1275 Assumed that pathData is enough wide to get all data - controlled by wrapper too. */
1276 memcpy(pathData->Points, path->pathdata.Points, sizeof(PointF) * pathData->Count);
1277 memcpy(pathData->Types , path->pathdata.Types , pathData->Count);
1282 GpStatus WINGDIPAPI GdipGetPathFillMode(GpPath *path, GpFillMode *fillmode)
1284 TRACE("(%p, %p)\n", path, fillmode);
1286 if(!path || !fillmode)
1287 return InvalidParameter;
1289 *fillmode = path->fill;
1294 GpStatus WINGDIPAPI GdipGetPathLastPoint(GpPath* path, GpPointF* lastPoint)
1298 TRACE("(%p, %p)\n", path, lastPoint);
1300 if(!path || !lastPoint)
1301 return InvalidParameter;
1303 count = path->pathdata.Count;
1305 *lastPoint = path->pathdata.Points[count-1];
1310 GpStatus WINGDIPAPI GdipGetPathPoints(GpPath *path, GpPointF* points, INT count)
1312 TRACE("(%p, %p, %d)\n", path, points, count);
1315 return InvalidParameter;
1317 if(count < path->pathdata.Count)
1318 return InsufficientBuffer;
1320 memcpy(points, path->pathdata.Points, path->pathdata.Count * sizeof(GpPointF));
1325 GpStatus WINGDIPAPI GdipGetPathPointsI(GpPath *path, GpPoint* points, INT count)
1331 TRACE("(%p, %p, %d)\n", path, points, count);
1334 return InvalidParameter;
1336 ptf = GdipAlloc(sizeof(GpPointF)*count);
1337 if(!ptf) return OutOfMemory;
1339 ret = GdipGetPathPoints(path,ptf,count);
1341 for(i = 0;i < count;i++){
1342 points[i].X = roundr(ptf[i].X);
1343 points[i].Y = roundr(ptf[i].Y);
1350 GpStatus WINGDIPAPI GdipGetPathTypes(GpPath *path, BYTE* types, INT count)
1352 TRACE("(%p, %p, %d)\n", path, types, count);
1355 return InvalidParameter;
1357 if(count < path->pathdata.Count)
1358 return InsufficientBuffer;
1360 memcpy(types, path->pathdata.Types, path->pathdata.Count);
1365 /* Windows expands the bounding box to the maximum possible bounding box
1366 * for a given pen. For example, if a line join can extend past the point
1367 * it's joining by x units, the bounding box is extended by x units in every
1368 * direction (even though this is too conservative for most cases). */
1369 GpStatus WINGDIPAPI GdipGetPathWorldBounds(GpPath* path, GpRectF* bounds,
1370 GDIPCONST GpMatrix *matrix, GDIPCONST GpPen *pen)
1372 GpPointF * points, temp_pts[4];
1374 REAL path_width = 1.0, width, height, temp, low_x, low_y, high_x, high_y;
1376 TRACE("(%p, %p, %p, %p)\n", path, bounds, matrix, pen);
1378 /* Matrix and pen can be null. */
1379 if(!path || !bounds)
1380 return InvalidParameter;
1382 /* If path is empty just return. */
1383 count = path->pathdata.Count;
1385 bounds->X = bounds->Y = bounds->Width = bounds->Height = 0.0;
1389 points = path->pathdata.Points;
1391 low_x = high_x = points[0].X;
1392 low_y = high_y = points[0].Y;
1394 for(i = 1; i < count; i++){
1395 low_x = min(low_x, points[i].X);
1396 low_y = min(low_y, points[i].Y);
1397 high_x = max(high_x, points[i].X);
1398 high_y = max(high_y, points[i].Y);
1401 width = high_x - low_x;
1402 height = high_y - low_y;
1404 /* This looks unusual but it's the only way I can imitate windows. */
1406 temp_pts[0].X = low_x;
1407 temp_pts[0].Y = low_y;
1408 temp_pts[1].X = low_x;
1409 temp_pts[1].Y = high_y;
1410 temp_pts[2].X = high_x;
1411 temp_pts[2].Y = high_y;
1412 temp_pts[3].X = high_x;
1413 temp_pts[3].Y = low_y;
1415 GdipTransformMatrixPoints((GpMatrix*)matrix, temp_pts, 4);
1416 low_x = temp_pts[0].X;
1417 low_y = temp_pts[0].Y;
1419 for(i = 1; i < 4; i++){
1420 low_x = min(low_x, temp_pts[i].X);
1421 low_y = min(low_y, temp_pts[i].Y);
1425 width = height * fabs(matrix->matrix[2]) + width * fabs(matrix->matrix[0]);
1426 height = height * fabs(matrix->matrix[3]) + temp * fabs(matrix->matrix[1]);
1430 path_width = pen->width / 2.0;
1433 path_width = max(path_width, pen->width * pen->miterlimit / 2.0);
1434 /* FIXME: this should probably also check for the startcap */
1435 if(pen->endcap & LineCapNoAnchor)
1436 path_width = max(path_width, pen->width * 2.2);
1438 low_x -= path_width;
1439 low_y -= path_width;
1440 width += 2.0 * path_width;
1441 height += 2.0 * path_width;
1446 bounds->Width = width;
1447 bounds->Height = height;
1452 GpStatus WINGDIPAPI GdipGetPathWorldBoundsI(GpPath* path, GpRect* bounds,
1453 GDIPCONST GpMatrix *matrix, GDIPCONST GpPen *pen)
1458 TRACE("(%p, %p, %p, %p)\n", path, bounds, matrix, pen);
1460 ret = GdipGetPathWorldBounds(path,&boundsF,matrix,pen);
1463 bounds->X = roundr(boundsF.X);
1464 bounds->Y = roundr(boundsF.Y);
1465 bounds->Width = roundr(boundsF.Width);
1466 bounds->Height = roundr(boundsF.Height);
1472 GpStatus WINGDIPAPI GdipGetPointCount(GpPath *path, INT *count)
1474 TRACE("(%p, %p)\n", path, count);
1477 return InvalidParameter;
1479 *count = path->pathdata.Count;
1484 GpStatus WINGDIPAPI GdipReversePath(GpPath* path)
1487 INT start = 0; /* position in reversed path */
1490 TRACE("(%p)\n", path);
1493 return InvalidParameter;
1495 count = path->pathdata.Count;
1497 if(count == 0) return Ok;
1499 revpath.Points = GdipAlloc(sizeof(GpPointF)*count);
1500 revpath.Types = GdipAlloc(sizeof(BYTE)*count);
1501 revpath.Count = count;
1502 if(!revpath.Points || !revpath.Types){
1503 GdipFree(revpath.Points);
1504 GdipFree(revpath.Types);
1508 for(i = 0; i < count; i++){
1510 /* find next start point */
1511 if(path->pathdata.Types[count-i-1] == PathPointTypeStart){
1513 for(j = start; j <= i; j++){
1514 revpath.Points[j] = path->pathdata.Points[count-j-1];
1515 revpath.Types[j] = path->pathdata.Types[count-j-1];
1517 /* mark start point */
1518 revpath.Types[start] = PathPointTypeStart;
1519 /* set 'figure' endpoint type */
1521 revpath.Types[i] = path->pathdata.Types[count-start-1] & ~PathPointTypePathTypeMask;
1522 revpath.Types[i] |= revpath.Types[i-1];
1525 revpath.Types[i] = path->pathdata.Types[start];
1531 memcpy(path->pathdata.Points, revpath.Points, sizeof(GpPointF)*count);
1532 memcpy(path->pathdata.Types, revpath.Types, sizeof(BYTE)*count);
1534 GdipFree(revpath.Points);
1535 GdipFree(revpath.Types);
1540 GpStatus WINGDIPAPI GdipIsOutlineVisiblePathPointI(GpPath* path, INT x, INT y,
1541 GpPen *pen, GpGraphics *graphics, BOOL *result)
1543 TRACE("(%p, %d, %d, %p, %p, %p)\n", path, x, y, pen, graphics, result);
1545 return GdipIsOutlineVisiblePathPoint(path, x, y, pen, graphics, result);
1548 GpStatus WINGDIPAPI GdipIsOutlineVisiblePathPoint(GpPath* path, REAL x, REAL y,
1549 GpPen *pen, GpGraphics *graphics, BOOL *result)
1553 TRACE("(%p,%0.2f,%0.2f,%p,%p,%p)\n", path, x, y, pen, graphics, result);
1556 return InvalidParameter;
1559 FIXME("not implemented\n");
1561 return NotImplemented;
1564 GpStatus WINGDIPAPI GdipIsVisiblePathPointI(GpPath* path, INT x, INT y, GpGraphics *graphics, BOOL *result)
1566 TRACE("(%p, %d, %d, %p, %p)\n", path, x, y, graphics, result);
1568 return GdipIsVisiblePathPoint(path, x, y, graphics, result);
1571 /*****************************************************************************
1572 * GdipIsVisiblePathPoint [GDIPLUS.@]
1574 GpStatus WINGDIPAPI GdipIsVisiblePathPoint(GpPath* path, REAL x, REAL y, GpGraphics *graphics, BOOL *result)
1580 if(!path || !result) return InvalidParameter;
1582 status = GdipCreateRegionPath(path, ®ion);
1586 status = GdipGetRegionHRgn(region, graphics, &hrgn);
1588 GdipDeleteRegion(region);
1592 *result = PtInRegion(hrgn, roundr(x), roundr(y));
1595 GdipDeleteRegion(region);
1600 GpStatus WINGDIPAPI GdipStartPathFigure(GpPath *path)
1602 TRACE("(%p)\n", path);
1605 return InvalidParameter;
1607 path->newfigure = TRUE;
1612 GpStatus WINGDIPAPI GdipResetPath(GpPath *path)
1614 TRACE("(%p)\n", path);
1617 return InvalidParameter;
1619 path->pathdata.Count = 0;
1620 path->newfigure = TRUE;
1621 path->fill = FillModeAlternate;
1626 GpStatus WINGDIPAPI GdipSetPathFillMode(GpPath *path, GpFillMode fill)
1628 TRACE("(%p, %d)\n", path, fill);
1631 return InvalidParameter;
1638 GpStatus WINGDIPAPI GdipTransformPath(GpPath *path, GpMatrix *matrix)
1640 TRACE("(%p, %p)\n", path, matrix);
1643 return InvalidParameter;
1645 if(path->pathdata.Count == 0)
1648 return GdipTransformMatrixPoints(matrix, path->pathdata.Points,
1649 path->pathdata.Count);
1652 GpStatus WINGDIPAPI GdipWarpPath(GpPath *path, GpMatrix* matrix,
1653 GDIPCONST GpPointF *points, INT count, REAL x, REAL y, REAL width,
1654 REAL height, WarpMode warpmode, REAL flatness)
1656 FIXME("(%p,%p,%p,%i,%0.2f,%0.2f,%0.2f,%0.2f,%i,%0.2f)\n", path, matrix,
1657 points, count, x, y, width, height, warpmode, flatness);
1659 return NotImplemented;
1662 static void add_bevel_point(const GpPointF *endpoint, const GpPointF *nextpoint,
1663 GpPen *pen, int right_side, path_list_node_t **last_point)
1665 REAL segment_dy = nextpoint->Y-endpoint->Y;
1666 REAL segment_dx = nextpoint->X-endpoint->X;
1667 REAL segment_length = sqrtf(segment_dy*segment_dy + segment_dx*segment_dx);
1668 REAL distance = pen->width/2.0;
1669 REAL bevel_dx, bevel_dy;
1673 bevel_dx = -distance * segment_dy / segment_length;
1674 bevel_dy = distance * segment_dx / segment_length;
1678 bevel_dx = distance * segment_dy / segment_length;
1679 bevel_dy = -distance * segment_dx / segment_length;
1682 *last_point = add_path_list_node(*last_point, endpoint->X + bevel_dx,
1683 endpoint->Y + bevel_dy, PathPointTypeLine);
1686 static void widen_joint(const GpPointF *p1, const GpPointF *p2, const GpPointF *p3,
1687 GpPen* pen, path_list_node_t **last_point)
1693 add_bevel_point(p2, p1, pen, 1, last_point);
1694 add_bevel_point(p2, p3, pen, 0, last_point);
1699 static void widen_cap(const GpPointF *endpoint, const GpPointF *nextpoint,
1700 GpPen *pen, GpLineCap cap, GpCustomLineCap *custom, int add_first_points,
1701 int add_last_point, path_list_node_t **last_point)
1707 if (add_first_points)
1708 add_bevel_point(endpoint, nextpoint, pen, 1, last_point);
1710 add_bevel_point(endpoint, nextpoint, pen, 0, last_point);
1715 static void widen_open_figure(GpPath *path, GpPen *pen, int start, int end,
1716 path_list_node_t **last_point)
1723 widen_cap(&path->pathdata.Points[start], &path->pathdata.Points[start+1],
1724 pen, pen->startcap, pen->customstart, FALSE, TRUE, last_point);
1726 (*last_point)->type = PathPointTypeStart;
1728 for (i=start+1; i<end; i++)
1729 widen_joint(&path->pathdata.Points[i-1], &path->pathdata.Points[i],
1730 &path->pathdata.Points[i+1], pen, last_point);
1732 widen_cap(&path->pathdata.Points[end], &path->pathdata.Points[end-1],
1733 pen, pen->endcap, pen->customend, TRUE, TRUE, last_point);
1735 for (i=end-1; i>start; i--)
1736 widen_joint(&path->pathdata.Points[i+1], &path->pathdata.Points[i],
1737 &path->pathdata.Points[i-1], pen, last_point);
1739 widen_cap(&path->pathdata.Points[start], &path->pathdata.Points[start+1],
1740 pen, pen->startcap, pen->customstart, TRUE, FALSE, last_point);
1742 (*last_point)->type |= PathPointTypeCloseSubpath;
1745 static void widen_closed_figure(GpPath *path, GpPen *pen, int start, int end,
1746 path_list_node_t **last_point)
1749 path_list_node_t *prev_point;
1755 prev_point = *last_point;
1757 widen_joint(&path->pathdata.Points[end], &path->pathdata.Points[start],
1758 &path->pathdata.Points[start+1], pen, last_point);
1760 for (i=start+1; i<end; i++)
1761 widen_joint(&path->pathdata.Points[i-1], &path->pathdata.Points[i],
1762 &path->pathdata.Points[i+1], pen, last_point);
1764 widen_joint(&path->pathdata.Points[end-1], &path->pathdata.Points[end],
1765 &path->pathdata.Points[start], pen, last_point);
1767 prev_point->next->type = PathPointTypeStart;
1768 (*last_point)->type |= PathPointTypeCloseSubpath;
1771 prev_point = *last_point;
1773 widen_joint(&path->pathdata.Points[start], &path->pathdata.Points[end],
1774 &path->pathdata.Points[end-1], pen, last_point);
1776 for (i=end-1; i>start; 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[start+1], &path->pathdata.Points[start],
1781 &path->pathdata.Points[end], pen, last_point);
1783 prev_point->next->type = PathPointTypeStart;
1784 (*last_point)->type |= PathPointTypeCloseSubpath;
1787 GpStatus WINGDIPAPI GdipWidenPath(GpPath *path, GpPen *pen, GpMatrix *matrix,
1790 GpPath *flat_path=NULL;
1792 path_list_node_t *points=NULL, *last_point=NULL;
1793 int i, subpath_start=0, new_length;
1796 TRACE("(%p,%p,%p,%0.2f)\n", path, pen, matrix, flatness);
1799 return InvalidParameter;
1801 if (path->pathdata.Count <= 1)
1804 status = GdipClonePath(path, &flat_path);
1807 status = GdipFlattenPath(flat_path, matrix, flatness);
1809 if (status == Ok && !init_path_list(&points, 314.0, 22.0))
1810 status = OutOfMemory;
1814 last_point = points;
1816 if (pen->endcap != LineCapFlat)
1817 FIXME("unimplemented end cap %x\n", pen->endcap);
1819 if (pen->startcap != LineCapFlat)
1820 FIXME("unimplemented start cap %x\n", pen->startcap);
1822 if (pen->dashcap != DashCapFlat)
1823 FIXME("unimplemented dash cap %d\n", pen->dashcap);
1825 if (pen->join != LineJoinBevel)
1826 FIXME("unimplemented line join %d\n", pen->join);
1828 if (pen->dash != DashStyleSolid)
1829 FIXME("unimplemented dash style %d\n", pen->dash);
1831 if (pen->align != PenAlignmentCenter)
1832 FIXME("unimplemented pen alignment %d\n", pen->align);
1834 for (i=0; i < flat_path->pathdata.Count; i++)
1836 type = flat_path->pathdata.Types[i];
1838 if ((type&PathPointTypePathTypeMask) == PathPointTypeStart)
1841 if ((type&PathPointTypeCloseSubpath) == PathPointTypeCloseSubpath)
1843 widen_closed_figure(flat_path, pen, subpath_start, i, &last_point);
1845 else if (i == flat_path->pathdata.Count-1 ||
1846 (flat_path->pathdata.Types[i+1]&PathPointTypePathTypeMask) == PathPointTypeStart)
1848 widen_open_figure(flat_path, pen, subpath_start, i, &last_point);
1852 new_length = path_list_count(points)-1;
1854 if (!lengthen_path(path, new_length))
1855 status = OutOfMemory;
1860 path->pathdata.Count = new_length;
1862 last_point = points->next;
1863 for (i = 0; i < new_length; i++)
1865 path->pathdata.Points[i] = last_point->pt;
1866 path->pathdata.Types[i] = last_point->type;
1867 last_point = last_point->next;
1870 path->fill = FillModeWinding;
1873 free_path_list(points);
1875 GdipDeletePath(flat_path);
1880 GpStatus WINGDIPAPI GdipAddPathRectangle(GpPath *path, REAL x, REAL y,
1881 REAL width, REAL height)
1888 TRACE("(%p, %.2f, %.2f, %.2f, %.2f)\n", path, x, y, width, height);
1891 return InvalidParameter;
1893 /* make a backup copy of path data */
1894 if((retstat = GdipClonePath(path, &backup)) != Ok)
1897 /* rectangle should start as new path */
1898 old_new = path->newfigure;
1899 path->newfigure = TRUE;
1900 if((retstat = GdipAddPathLine(path,x,y,x+width,y)) != Ok){
1901 path->newfigure = old_new;
1906 ptf[0].Y = y+height;
1908 ptf[1].Y = y+height;
1910 if((retstat = GdipAddPathLine2(path, ptf, 2)) != Ok) goto fail;
1911 path->pathdata.Types[path->pathdata.Count-1] |= PathPointTypeCloseSubpath;
1914 GdipDeletePath(backup);
1919 GdipFree(path->pathdata.Points);
1920 GdipFree(path->pathdata.Types);
1921 memcpy(path, backup, sizeof(*path));
1927 GpStatus WINGDIPAPI GdipAddPathRectangleI(GpPath *path, INT x, INT y,
1928 INT width, INT height)
1930 TRACE("(%p, %d, %d, %d, %d)\n", path, x, y, width, height);
1932 return GdipAddPathRectangle(path,(REAL)x,(REAL)y,(REAL)width,(REAL)height);
1935 GpStatus WINGDIPAPI GdipAddPathRectangles(GpPath *path, GDIPCONST GpRectF *rects, INT count)
1941 TRACE("(%p, %p, %d)\n", path, rects, count);
1943 /* count == 0 - verified condition */
1944 if(!path || !rects || count == 0)
1945 return InvalidParameter;
1950 /* make a backup copy */
1951 if((retstat = GdipClonePath(path, &backup)) != Ok)
1954 for(i = 0; i < count; i++){
1955 if((retstat = GdipAddPathRectangle(path,rects[i].X,rects[i].Y,rects[i].Width,rects[i].Height)) != Ok)
1960 GdipDeletePath(backup);
1965 GdipFree(path->pathdata.Points);
1966 GdipFree(path->pathdata.Types);
1967 memcpy(path, backup, sizeof(*path));
1973 GpStatus WINGDIPAPI GdipAddPathRectanglesI(GpPath *path, GDIPCONST GpRect *rects, INT count)
1979 TRACE("(%p, %p, %d)\n", path, rects, count);
1981 if(!rects || count == 0)
1982 return InvalidParameter;
1987 rectsF = GdipAlloc(sizeof(GpRectF)*count);
1989 for(i = 0;i < count;i++){
1990 rectsF[i].X = (REAL)rects[i].X;
1991 rectsF[i].Y = (REAL)rects[i].Y;
1992 rectsF[i].Width = (REAL)rects[i].Width;
1993 rectsF[i].Height = (REAL)rects[i].Height;
1996 retstat = GdipAddPathRectangles(path, rectsF, count);
2002 GpStatus WINGDIPAPI GdipSetPathMarker(GpPath* path)
2006 TRACE("(%p)\n", path);
2009 return InvalidParameter;
2011 count = path->pathdata.Count;
2013 /* set marker flag */
2015 path->pathdata.Types[count-1] |= PathPointTypePathMarker;
2020 GpStatus WINGDIPAPI GdipClearPathMarkers(GpPath* path)
2025 TRACE("(%p)\n", path);
2028 return InvalidParameter;
2030 count = path->pathdata.Count;
2032 for(i = 0; i < count - 1; i++){
2033 path->pathdata.Types[i] &= ~PathPointTypePathMarker;
2039 GpStatus WINGDIPAPI GdipWindingModeOutline(GpPath *path, GpMatrix *matrix, REAL flatness)
2041 FIXME("stub: %p, %p, %.2f\n", path, matrix, flatness);
2042 return NotImplemented;