From 64089dca388f5a9a8235a94b4372763875132219 Mon Sep 17 00:00:00 2001 From: lecoanet Date: Wed, 2 Feb 2000 14:01:15 +0000 Subject: Passage en Zinc --- generic/Geo.c | 432 +++++++++++++++++++++++++++++----------------------------- 1 file changed, 216 insertions(+), 216 deletions(-) (limited to 'generic/Geo.c') diff --git a/generic/Geo.c b/generic/Geo.c index c2d569d..16cee3e 100644 --- a/generic/Geo.c +++ b/generic/Geo.c @@ -46,45 +46,45 @@ static const char compile_id[]="$Compile: " __FILE__ " " __DATE__ " " __TIME__ " * by position, anchor, width and height. */ void -Anchor2Origin(RadarPoint *position, - RadarDim width, - RadarDim height, - RadarAnchor anchor, - RadarPoint *origin) +Anchor2Origin(ZnPoint *position, + ZnDim width, + ZnDim height, + ZnAnchor anchor, + ZnPoint *origin) { switch (anchor) { - case RadarAnchorCenter: + case ZnAnchorCenter: origin->x = position->x - width/2; origin->y = position->y - height/2; break; - case RadarAnchorNW: + case ZnAnchorNW: *origin = *position; break; - case RadarAnchorN: + case ZnAnchorN: origin->x = position->x - width/2; origin->y = position->y; break; - case RadarAnchorNE: + case ZnAnchorNE: origin->x = position->x - width; origin->y = position->y; break; - case RadarAnchorE: + case ZnAnchorE: origin->x = position->x - width; origin->y = position->y - height/2; break; - case RadarAnchorSE: + case ZnAnchorSE: origin->x = position->x - width; origin->y = position->y - height; break; - case RadarAnchorS: + case ZnAnchorS: origin->x = position->x - width/2; origin->y = position->y - height; break; - case RadarAnchorSW: + case ZnAnchorSW: origin->x = position->x; origin->y = position->y - height; break; - case RadarAnchorW: + case ZnAnchorW: origin->x = position->x; origin->y = position->y - height/2; break; @@ -97,45 +97,45 @@ Anchor2Origin(RadarPoint *position, * height and the anchor. */ void -Origin2Anchor(RadarPoint *origin, - RadarDim width, - RadarDim height, - RadarAnchor anchor, - RadarPoint *position) +Origin2Anchor(ZnPoint *origin, + ZnDim width, + ZnDim height, + ZnAnchor anchor, + ZnPoint *position) { switch (anchor) { - case RadarAnchorCenter: + case ZnAnchorCenter: position->x = origin->x + width/2; position->y = origin->y + height/2; break; - case RadarAnchorNW: + case ZnAnchorNW: *position = *origin; break; - case RadarAnchorN: + case ZnAnchorN: position->x = origin->x + width/2; position->y = origin->y; break; - case RadarAnchorNE: + case ZnAnchorNE: position->x = origin->x + width; position->y = origin->y; break; - case RadarAnchorE: + case ZnAnchorE: position->x = origin->x + width; position->y = origin->y + height/2; break; - case RadarAnchorSE: + case ZnAnchorSE: position->x = origin->x + width; position->y = origin->y + height; break; - case RadarAnchorS: + case ZnAnchorS: position->x = origin->x + width/2; position->y = origin->y + height; break; - case RadarAnchorSW: + case ZnAnchorSW: position->x = origin->x; position->y = origin->y + height; break; - case RadarAnchorW: + case ZnAnchorW: position->x = origin->x; position->y = origin->y + height/2; break; @@ -144,7 +144,7 @@ Origin2Anchor(RadarPoint *origin, void -BBox2XRect(RadarBBox *bbox, +BBox2XRect(ZnBBox *bbox, XRectangle *r) { r->x = REAL_TO_INT(bbox->orig.x); @@ -156,15 +156,15 @@ BBox2XRect(RadarBBox *bbox, void GetStringBBox(char *str, - RadarFont font, - RadarPos x, - RadarPos y, - RadarBBox *str_bbox) + ZnFont font, + ZnPos x, + ZnPos y, + ZnBBox *str_bbox) { Tk_FontMetrics fm; str_bbox->orig.x = x; - str_bbox->corner.x = x + RadarTextWidth(font, str, strlen(str)); + str_bbox->corner.x = x + ZnTextWidth(font, str, strlen(str)); Tk_GetFontMetrics(font, &fm); str_bbox->orig.y = y - fm.ascent; str_bbox->corner.y = str_bbox->orig.y + fm.ascent + fm.descent; @@ -172,7 +172,7 @@ GetStringBBox(char *str, void -ResetBBox(RadarBBox *bbox) +ResetBBox(ZnBBox *bbox) { bbox->orig.x = bbox->orig.y = 0; bbox->corner = bbox->orig; @@ -180,8 +180,8 @@ ResetBBox(RadarBBox *bbox) void -CopyBBox(RadarBBox *bbox_from, - RadarBBox *bbox_to) +CopyBBox(ZnBBox *bbox_from, + ZnBBox *bbox_to) { bbox_to->orig = bbox_from->orig; bbox_to->corner = bbox_from->corner; @@ -189,9 +189,9 @@ CopyBBox(RadarBBox *bbox_from, void -IntersectBBox(RadarBBox *bbox1, - RadarBBox *bbox2, - RadarBBox *bbox_inter) +IntersectBBox(ZnBBox *bbox1, + ZnBBox *bbox2, + ZnBBox *bbox_inter) { if ((bbox1->corner.x < bbox2->orig.x) || (bbox1->corner.y < bbox2->orig.y) || @@ -208,16 +208,16 @@ IntersectBBox(RadarBBox *bbox1, } -RadarBool -IsEmptyBBox(RadarBBox *bbox) +ZnBool +IsEmptyBBox(ZnBBox *bbox) { return (bbox->orig.x >= bbox->corner.x) || (bbox->orig.y >= bbox->corner.y); } void -AddBBoxToBBox(RadarBBox *bbox, - RadarBBox *bbox2) +AddBBoxToBBox(ZnBBox *bbox, + ZnBBox *bbox2) { if (IsEmptyBBox(bbox2)) { return; @@ -235,9 +235,9 @@ AddBBoxToBBox(RadarBBox *bbox, void -AddPointToBBox(RadarBBox *bbox, - RadarPos px, - RadarPos py) +AddPointToBBox(ZnBBox *bbox, + ZnPos px, + ZnPos py) { if (IsEmptyBBox(bbox)) { bbox->orig.x = px; @@ -255,9 +255,9 @@ AddPointToBBox(RadarBBox *bbox, void -AddPointsToBBox(RadarBBox *bbox, - RadarPoint *points, - int num_points) +AddPointsToBBox(ZnBBox *bbox, + ZnPoint *points, + int num_points) { int x1, y1, x2, y2, cur; @@ -308,22 +308,22 @@ AddPointsToBBox(RadarBBox *bbox, void -AddStringToBBox(RadarBBox *bbox, - char *str, - RadarFont font, - RadarPos cx, - RadarPos cy) +AddStringToBBox(ZnBBox *bbox, + char *str, + ZnFont font, + ZnPos cx, + ZnPos cy) { - RadarBBox str_bbox; + ZnBBox str_bbox; GetStringBBox(str, font, cx, cy, &str_bbox); AddBBoxToBBox(bbox, &str_bbox); } -RadarBool -PointInBBox(RadarBBox *bbox, - RadarPos x, - RadarPos y) +ZnBool +PointInBBox(ZnBBox *bbox, + ZnPos x, + ZnPos y) { return ((x >= bbox->orig.x) && (x < bbox->corner.x) && (y >= bbox->orig.y) && (y < bbox->corner.y)); @@ -336,8 +336,8 @@ PointInBBox(RadarBBox *bbox, * 1 if it is entirely inside and 0 otherwise. */ int -BBoxInBBox(RadarBBox *bbox1, - RadarBBox *bbox2) +BBoxInBBox(ZnBBox *bbox1, + ZnBBox *bbox2) { if ((bbox1->corner.x <= bbox2->orig.x) || (bbox1->orig.x >= bbox2->corner.x) || @@ -360,12 +360,12 @@ BBoxInBBox(RadarBBox *bbox1, * if it is entirely inside and 0 otherwise. */ int -LineInBBox(RadarPoint *p1, - RadarPoint *p2, - RadarBBox *bbox) +LineInBBox(ZnPoint *p1, + ZnPoint *p2, + ZnBBox *bbox) { - RadarBool p1_inside = PointInBBox(bbox, p1->x, p1->y); - RadarBool p2_inside = PointInBBox(bbox, p2->x, p2->y); + ZnBool p1_inside = PointInBBox(bbox, p1->x, p1->y); + ZnBool p2_inside = PointInBBox(bbox, p2->x, p2->y); if (p1_inside != p2_inside) { return 0; @@ -457,14 +457,14 @@ LineInBBox(RadarPoint *p1, * on the right. */ void -ShiftLine(RadarPoint *p1, - RadarPoint *p2, - RadarReal dist, - RadarPoint *p3, - RadarPoint *p4) +ShiftLine(ZnPoint *p1, + ZnPoint *p2, + ZnReal dist, + ZnPoint *p3, + ZnPoint *p4) { static int shift_table[129]; - RadarBool dx_neg, dy_neg; + ZnBool dx_neg, dy_neg; int dx, dy; /* @@ -524,12 +524,12 @@ ShiftLine(RadarPoint *p1, * The function returns True if the lines are not parallel and False * otherwise. */ -RadarBool -IntersectLines(RadarPoint *a1, - RadarPoint *a2, - RadarPoint *b1, - RadarPoint *b2, - RadarPoint *pi) +ZnBool +IntersectLines(ZnPoint *a1, + ZnPoint *a2, + ZnPoint *b1, + ZnPoint *b2, + ZnPoint *pi) { int dxadyb, dxbdya, dxadxb, dyadyb, p, q; @@ -580,13 +580,13 @@ IntersectLines(RadarPoint *a1, */ /**** A FINIR ****/ void -InsetPolygon(RadarPoint *p, +InsetPolygon(ZnPoint *p, int num_points, - RadarDim inset) + ZnDim inset) { - RadarPoint *p1, *p2; - RadarPoint new_p1, new_p2; - RadarPoint shift1, shift2; + ZnPoint *p1, *p2; + ZnPoint new_p1, new_p2; + ZnPoint shift1, shift2; int i, processed_points; processed_points = 0; @@ -624,12 +624,12 @@ InsetPolygon(RadarPoint *p, * end is located around p2. */ void -GetButtPoints(RadarPoint *p1, - RadarPoint *p2, - int width, - RadarBool projecting, - RadarPoint *c1, - RadarPoint *c2) +GetButtPoints(ZnPoint *p1, + ZnPoint *p2, + int width, + ZnBool projecting, + ZnPoint *c1, + ZnPoint *c2) { double w_2 = width/2.0; double length = hypot(p2->x - p1->x, p2->y - p1->y); @@ -668,13 +668,13 @@ GetButtPoints(RadarPoint *p1, * * Hmmm, the switch has been done but not the rounding ;-) */ -RadarBool -GetMiterPoints(RadarPoint *p1, - RadarPoint *p2, - RadarPoint *p3, - int width, - RadarPoint *c1, - RadarPoint *c2) +ZnBool +GetMiterPoints(ZnPoint *p1, + ZnPoint *p2, + ZnPoint *p3, + int width, + ZnPoint *c1, + ZnPoint *c2) { static double deg11 = (11.0*2.0*M_PI)/360.0; double theta1; /* angle of p2-p1 segment. */ @@ -752,16 +752,16 @@ GetMiterPoints(RadarPoint *p1, * can be: CapRound, CapButt, CapProjecting. */ int -PolylineInBBox(RadarPoint *points, - int num_points, - int width, - int cap_style, - int join_style, - RadarBBox *bbox) +PolylineInBBox(ZnPoint *points, + int num_points, + int width, + int cap_style, + int join_style, + ZnBBox *bbox) { int count, inside = -1; - RadarBool do_miter_as_bevel; - RadarPoint poly[4]; + ZnBool do_miter_as_bevel; + ZnPoint poly[4]; /* * If the first point is inside the area, change inside @@ -872,13 +872,13 @@ PolylineInBBox(RadarPoint *points, * if it is entirely inside and 0 otherwise. */ int -PolygonInBBox(RadarPoint *points, - int num_points, - RadarBBox *bbox) +PolygonInBBox(ZnPoint *points, + int num_points, + ZnBBox *bbox) { int inside, count; - RadarPoint *p, *head, *first, *second; - RadarBool closed; + ZnPoint *p, *head, *first, *second; + ZnBool closed; p = head = points; closed = True; @@ -945,12 +945,12 @@ PolygonInBBox(RadarPoint *points, * if it is entirely inside and 0 otherwise. */ int -OvalInBBox(RadarPoint *center, +OvalInBBox(ZnPoint *center, int width, int height, - RadarBBox *bbox) + ZnBBox *bbox) { - RadarPoint origin, corner; + ZnPoint origin, corner; int w_2, h_2; double delta_x, delta_y; @@ -1050,10 +1050,10 @@ OvalInBBox(RadarPoint *center, * case we need to normalize a figure to take care of its shape and * the result needs precision. */ -RadarBool +ZnBool PointInAngle(int start_angle, int angle_extent, - RadarPoint *p) + ZnPoint *p) { double point_angle; int angle_diff; @@ -1081,17 +1081,17 @@ PointInAngle(int start_angle, * the arc described by (r1, r2, start_angle and angle_extent). * This arc is origin centered. */ -RadarBool -HorizLineToArc(RadarReal x1, - RadarReal x2, - RadarReal y, - RadarReal rx, - RadarReal ry, - RadarReal start_angle, - RadarReal angle_extent) +ZnBool +HorizLineToArc(ZnReal x1, + ZnReal x2, + ZnReal y, + ZnReal rx, + ZnReal ry, + ZnReal start_angle, + ZnReal angle_extent) { - RadarReal tmp, x; - RadarPoint t; + ZnReal tmp, x; + ZnPoint t; /* * Compute the x-coordinate of one possible intersection point @@ -1129,17 +1129,17 @@ HorizLineToArc(RadarReal x1, * the arc described by (r1, r2, start_angle and angle_extent). * This arc is origin centered. */ -RadarBool -VertLineToArc(RadarReal x, - RadarReal y1, - RadarReal y2, - RadarReal rx, - RadarReal ry, - RadarReal start_angle, - RadarReal angle_extent) +ZnBool +VertLineToArc(ZnReal x, + ZnReal y1, + ZnReal y2, + ZnReal rx, + ZnReal ry, + ZnReal start_angle, + ZnReal angle_extent) { - RadarReal tmp, y; - RadarPoint t; + ZnReal tmp, y; + ZnPoint t; /* * Compute the y-coordinate of one possible intersection point @@ -1175,11 +1175,11 @@ VertLineToArc(RadarReal x, * the rectangle. */ double -RectangleToPointDist(RadarBBox *bbox, - RadarPoint *p) +RectangleToPointDist(ZnBBox *bbox, + ZnPoint *p) { double new_dist, dist; - RadarPoint p1, p2; + ZnPoint p1, p2; p1.x = bbox->orig.x; p1.y = p2.y = bbox->orig.y; @@ -1224,9 +1224,9 @@ RectangleToPointDist(RadarBBox *bbox, * described by , .. */ double -LineToPointDist(RadarPoint *p1, - RadarPoint *p2, - RadarPoint *p) +LineToPointDist(ZnPoint *p1, + ZnPoint *p2, + ZnPoint *p) { double x, y; int x_int, y_int; @@ -1315,16 +1315,16 @@ LineToPointDist(RadarPoint *p1, * inside return values are negative. */ double -PolygonToPointDist(RadarPoint *points, +PolygonToPointDist(ZnPoint *points, int num_points, - RadarPoint *p) + ZnPoint *p) { double best_distance; int intersections; int x_int, y_int; - RadarPoint *first_point; + ZnPoint *first_point; double x, y, dist; - RadarPoint p1, p2; + ZnPoint p1, p2; /* * The algorithm iterates through all the edges of the polygon @@ -1472,17 +1472,17 @@ PolygonToPointDist(RadarPoint *points, * in the process. */ double -PolylineToPointDist(RadarPoint *points, +PolylineToPointDist(ZnPoint *points, int num_points, int width, int cap_style, int join_style, - RadarPoint *p) + ZnPoint *p) { - RadarBool miter2bevel = False; + ZnBool miter2bevel = False; int count; - RadarPoint *ptr; - RadarPoint outline[5]; + ZnPoint *ptr; + ZnPoint outline[5]; double dist, best_dist, h_width; best_dist = 1.0e36; @@ -1587,11 +1587,11 @@ PolylineToPointDist(RadarPoint *points, * if the point is inside. */ double -OvalToPointDist(RadarPoint *center, +OvalToPointDist(ZnPoint *center, int width, int height, unsigned int line_width, - RadarPoint *p) + ZnPoint *p) { double x_delta, y_delta; /* double x_diameter, y_diameter;*/ @@ -1667,12 +1667,12 @@ static int bezier_basis[][4] = ********************************************************************************** */ #define EVAL(coeff, t) (((coeff[0]*t + coeff[1])*t + coeff[2]) * t + coeff[3]) -static RadarReal -Arc2Param(RadarPoint *controls, - RadarReal angle) +static ZnReal +Arc2Param(ZnPoint *controls, + ZnReal angle) { - RadarReal coeff_x[4], coeff_y[4]; - RadarReal min_angle, min_t, max_angle, max_t, cur_angle, cur_t; + ZnReal coeff_x[4], coeff_y[4]; + ZnReal min_angle, min_t, max_angle, max_t, cur_angle, cur_t; int i, j, depth = 0; /* assume angle >= 0 */ @@ -1733,13 +1733,13 @@ Arc2Param(RadarPoint *controls, ********************************************************************************** */ void -BezierSubdivide(RadarPoint *controls, - RadarReal t, - RadarBool first) +BezierSubdivide(ZnPoint *controls, + ZnReal t, + ZnBool first) { - RadarReal s = 1.0 - t; - RadarPoint r[7]; - RadarPoint a; + ZnReal s = 1.0 - t; + ZnPoint r[7]; + ZnPoint a; r[0] = controls[0]; r[6] = controls[3]; @@ -1757,10 +1757,10 @@ BezierSubdivide(RadarPoint *controls, r[3].y = s*r[2].y + t*r[4].y; if (first) { - memcpy(controls, r, 4*sizeof(RadarPoint)); + memcpy(controls, r, 4*sizeof(ZnPoint)); } else { - memcpy(controls, &r[3], 4*sizeof(RadarPoint)); + memcpy(controls, &r[3], 4*sizeof(ZnPoint)); } } @@ -1777,12 +1777,12 @@ BezierSubdivide(RadarPoint *controls, ********************************************************************************** */ static void -GetBezierPoints(RadarPoint *controls, - RadarList to_points, - double eps) +GetBezierPoints(ZnPoint *controls, + ZnList to_points, + double eps) { - RadarReal dist2; - RadarPoint mid_segm, mid_cord, delta; + ZnReal dist2; + ZnPoint mid_segm, mid_cord, delta; /* * Compute distance between cord center and curve at t = 0.5 @@ -1796,7 +1796,7 @@ GetBezierPoints(RadarPoint *controls, dist2 = delta.x*delta.x + delta.y*delta.y; if (dist2 > eps) { - RadarPoint new_controls[4]; + ZnPoint new_controls[4]; /* * Subdivide the curve at t = 0.5 * and compute each new curve. @@ -1822,7 +1822,7 @@ GetBezierPoints(RadarPoint *controls, * Flat enough add the end to the current path. * The start should already be there. */ - RadarListAdd(to_points, &controls[3], RadarListTail); + ZnListAdd(to_points, &controls[3], ZnListTail); } } @@ -1842,21 +1842,21 @@ GetBezierPoints(RadarPoint *controls, ********************************************************************************** */ void -GetBezierPath(RadarList from_points, - RadarList to_points) +GetBezierPath(ZnList from_points, + ZnList to_points) { - RadarPoint *fp; + ZnPoint *fp; int num_fp, i; - RadarPoint s[4]; + ZnPoint s[4]; - fp = (RadarPoint *) RadarListArray(from_points); - num_fp = RadarListSize(from_points); + fp = (ZnPoint *) ZnListArray(from_points); + num_fp = ZnListSize(from_points); /* * make sure the output vector is empty, then add the first point. */ - RadarListEmpty(to_points); - RadarListAdd(to_points, &fp[0], RadarListTail); + ZnListEmpty(to_points); + ZnListAdd(to_points, &fp[0], ZnListTail); for (i = 0; i < num_fp; ) { if (i < (num_fp-3)) { @@ -1877,7 +1877,7 @@ GetBezierPath(RadarList from_points, break; } else if (i == (num_fp-2)) { - RadarListAdd(to_points, &fp[1], RadarListTail); + ZnListAdd(to_points, &fp[1], ZnListTail); break; } } @@ -1901,19 +1901,19 @@ static double arc_nodes_y[4] = { 0.0, 1.0, 0.0, -1.0 }; static double arc_controls_x[8] = { 1.0, 0.55197, -0.55197, -1.0, -1.0, -0.55197, 0.55197, 1.0 }; static double arc_controls_y[8] = { 0.55197, 1.0, 1.0, 0.55197, -0.55197, -1.0, -1.0, -0.55197 }; void -GetArcPath(RadarReal start_angle, - RadarReal end_angle, +GetArcPath(ZnReal start_angle, + ZnReal end_angle, int type, - RadarList to_points) + ZnList to_points) { int start_quad, end_quad, quadrant; - RadarPoint center_p = { 0.0, 0.0 }; - RadarPoint start_p = center_p; + ZnPoint center_p = { 0.0, 0.0 }; + ZnPoint start_p = center_p; /* * make sure the output vector is empty. */ - RadarListEmpty(to_points); + ZnListEmpty(to_points); /* * normalize start_angle and end_angle. @@ -1941,8 +1941,8 @@ GetArcPath(RadarReal start_angle, end_quad = end_angle / (M_PI / 2.0); for (quadrant = start_quad; quadrant <= end_quad; quadrant++) { - RadarPoint controls[4]; - RadarReal t; + ZnPoint controls[4]; + ZnReal t; controls[0].x = arc_nodes_x[quadrant % 4]; controls[0].y = arc_nodes_y[quadrant % 4]; @@ -1961,7 +1961,7 @@ GetArcPath(RadarReal start_angle, * vertex. */ start_p = controls[0]; - RadarListAdd(to_points, &controls[0], RadarListTail); + ZnListAdd(to_points, &controls[0], ZnListTail); } if (quadrant == end_quad) { t = Arc2Param(controls, end_angle); @@ -1970,23 +1970,23 @@ GetArcPath(RadarReal start_angle, } BezierSubdivide(controls, t, True); } - RadarListAdd(to_points, &controls[1], RadarListTail); - RadarListAdd(to_points, &controls[2], RadarListTail); - RadarListAdd(to_points, &controls[3], RadarListTail); + ZnListAdd(to_points, &controls[1], ZnListTail); + ZnListAdd(to_points, &controls[2], ZnListTail); + ZnListAdd(to_points, &controls[3], ZnListTail); } if (type == 2) { - RadarListAdd(to_points, ¢er_p, RadarListTail); + ZnListAdd(to_points, ¢er_p, ZnListTail); /* * Can't add this one, it would be interpreted by GetBezierPath * as an off-curve control. The path should be closed by the client * after expansion by GetBezierPath. * - RadarListAdd(to_points, &start_p, RadarListTail); + ZnListAdd(to_points, &start_p, ZnListTail); */ } else if (type == 1) { - RadarListAdd(to_points, &start_p, RadarListTail); + ZnListAdd(to_points, &start_p, ZnListTail); } } @@ -2001,22 +2001,22 @@ GetArcPath(RadarReal start_angle, ********************************************************************************** */ void -SmoothPathWithBezier(RadarList from_points, - RadarList to_points) +SmoothPathWithBezier(ZnList from_points, + ZnList to_points) { - RadarPoint *fp; - int num_fp; - RadarBool closed; - RadarPoint s[4]; - int i; + ZnPoint *fp; + int num_fp; + ZnBool closed; + ZnPoint s[4]; + int i; - fp = (RadarPoint *) RadarListArray(from_points); - num_fp = RadarListSize(from_points); + fp = (ZnPoint *) ZnListArray(from_points); + num_fp = ZnListSize(from_points); /* * make sure the output vector is empty */ - RadarListEmpty(to_points); + ZnListEmpty(to_points); /* * If the curve is closed, generates a Bezier curve that @@ -2033,12 +2033,12 @@ SmoothPathWithBezier(RadarList from_points, s[2].y = REAL_TO_INT(0.833*fp[0].y + 0.167*fp[1].y); s[3].x = REAL_TO_INT(0.5*fp[0].x + 0.5*fp[1].x); s[3].y = REAL_TO_INT(0.5*fp[0].y + 0.5*fp[1].y); - RadarListAdd(to_points, s, RadarListTail); + ZnListAdd(to_points, s, ZnListTail); GetBezierPoints(s, to_points, 1.0); } else { closed = False; - RadarListAdd(to_points, &fp[0], RadarListTail); + ZnListAdd(to_points, &fp[0], ZnListTail); } for (i = 2; i < num_fp; i++, fp++) { @@ -2081,7 +2081,7 @@ SmoothPathWithBezier(RadarList from_points, */ if (((fp[0].x == fp[1].x) && (fp[0].y == fp[1].y)) || ((fp[1].x == fp[2].x) && (fp[1].y == fp[2].y))) { - RadarListAdd(to_points, &s[3], RadarListTail); + ZnListAdd(to_points, &s[3], ZnListTail); } else { GetBezierPoints(s, to_points, 1.0); @@ -2119,17 +2119,17 @@ SmoothPathWithBezier(RadarList from_points, ********************************************************************************** */ void -GetLineEnd(RadarPoint *p1, - RadarPoint *p2, +GetLineEnd(ZnPoint *p1, + ZnPoint *p2, unsigned int line_width, int cap_style, LineEnd end_style, - RadarPoint *points) + ZnPoint *points) { - RadarReal dx, dy, length, temp, backup; - RadarReal frac_height, sin_theta, cos_theta; - RadarReal vert_x, vert_y; - RadarReal shape_a, shape_b, shape_c; + ZnReal dx, dy, length, temp, backup; + ZnReal frac_height, sin_theta, cos_theta; + ZnReal vert_x, vert_y; + ZnReal shape_a, shape_b, shape_c; if (end_style != NULL) { shape_a = end_style->shape_a + 0.001; -- cgit v1.1