| 0,0 → 1,990 |
|---|
| #include "fitz.h" |
| #include "muxps.h" |
| |
| static fz_point |
| fz_currentpoint(fz_path *path) |
| { |
| fz_point c, m; |
| int i; |
| |
| c.x = c.y = m.x = m.y = 0; |
| i = 0; |
| |
| while (i < path->len) |
| { |
| switch (path->items[i++].k) |
| { |
| case FZ_MOVETO: |
| m.x = c.x = path->items[i++].v; |
| m.y = c.y = path->items[i++].v; |
| break; |
| case FZ_LINETO: |
| c.x = path->items[i++].v; |
| c.y = path->items[i++].v; |
| break; |
| case FZ_CURVETO: |
| i += 4; |
| c.x = path->items[i++].v; |
| c.y = path->items[i++].v; |
| break; |
| case FZ_CLOSE_PATH: |
| c = m; |
| } |
| } |
| |
| return c; |
| } |
| |
| /* Draw an arc segment transformed by the matrix, we approximate with straight |
| * line segments. We cannot use the fz_arc function because they only draw |
| * circular arcs, we need to transform the line to make them elliptical but |
| * without transforming the line width. |
| */ |
| static void |
| xps_draw_arc_segment(fz_path *path, fz_matrix mtx, float th0, float th1, int iscw) |
| { |
| float t, d; |
| fz_point p; |
| |
| while (th1 < th0) |
| th1 += (float)M_PI * 2; |
| |
| d = (float)M_PI / 180; /* 1-degree precision */ |
| |
| if (iscw) |
| { |
| p.x = cosf(th0); |
| p.y = sinf(th0); |
| p = fz_transform_point(mtx, p); |
| fz_lineto(path, p.x, p.y); |
| for (t = th0; t < th1; t += d) |
| { |
| p.x = cosf(t); |
| p.y = sinf(t); |
| p = fz_transform_point(mtx, p); |
| fz_lineto(path, p.x, p.y); |
| } |
| p.x = cosf(th1); |
| p.y = sinf(th1); |
| p = fz_transform_point(mtx, p); |
| fz_lineto(path, p.x, p.y); |
| } |
| else |
| { |
| th0 += (float)M_PI * 2; |
| p.x = cosf(th0); |
| p.y = sinf(th0); |
| p = fz_transform_point(mtx, p); |
| fz_lineto(path, p.x, p.y); |
| for (t = th0; t > th1; t -= d) |
| { |
| p.x = cosf(t); |
| p.y = sinf(t); |
| p = fz_transform_point(mtx, p); |
| fz_lineto(path, p.x, p.y); |
| } |
| p.x = cosf(th1); |
| p.y = sinf(th1); |
| p = fz_transform_point(mtx, p); |
| fz_lineto(path, p.x, p.y); |
| } |
| } |
| |
| /* Given two vectors find the angle between them. */ |
| static float |
| angle_between(const fz_point u, const fz_point v) |
| { |
| float det = u.x * v.y - u.y * v.x; |
| float sign = (det < 0 ? -1 : 1); |
| float magu = u.x * u.x + u.y * u.y; |
| float magv = v.x * v.x + v.y * v.y; |
| float udotv = u.x * v.x + u.y * v.y; |
| float t = udotv / (magu * magv); |
| /* guard against rounding errors when near |1| (where acos will return NaN) */ |
| if (t < -1) t = -1; |
| if (t > 1) t = 1; |
| return sign * acosf(t); |
| } |
| |
| static void |
| xps_draw_arc(fz_path *path, |
| float size_x, float size_y, float rotation_angle, |
| int is_large_arc, int is_clockwise, |
| float point_x, float point_y) |
| { |
| fz_matrix rotmat, revmat; |
| fz_matrix mtx; |
| fz_point pt; |
| float rx, ry; |
| float x1, y1, x2, y2; |
| float x1t, y1t; |
| float cxt, cyt, cx, cy; |
| float t1, t2, t3; |
| float sign; |
| float th1, dth; |
| |
| pt = fz_currentpoint(path); |
| x1 = pt.x; |
| y1 = pt.y; |
| x2 = point_x; |
| y2 = point_y; |
| rx = size_x; |
| ry = size_y; |
| |
| if (is_clockwise != is_large_arc) |
| sign = 1; |
| else |
| sign = -1; |
| |
| rotmat = fz_rotate(rotation_angle); |
| revmat = fz_rotate(-rotation_angle); |
| |
| /* http://www.w3.org/TR/SVG11/implnote.html#ArcImplementationNotes */ |
| /* Conversion from endpoint to center parameterization */ |
| |
| /* F.6.6.1 -- ensure radii are positive and non-zero */ |
| rx = fabsf(rx); |
| ry = fabsf(ry); |
| if (rx < 0.001f || ry < 0.001f) |
| { |
| fz_lineto(path, x2, y2); |
| return; |
| } |
| |
| /* F.6.5.1 */ |
| pt.x = (x1 - x2) / 2; |
| pt.y = (y1 - y2) / 2; |
| pt = fz_transform_vector(revmat, pt); |
| x1t = pt.x; |
| y1t = pt.y; |
| |
| /* F.6.6.2 -- ensure radii are large enough */ |
| t1 = (x1t * x1t) / (rx * rx) + (y1t * y1t) / (ry * ry); |
| if (t1 > 1) |
| { |
| rx = rx * sqrtf(t1); |
| ry = ry * sqrtf(t1); |
| } |
| |
| /* F.6.5.2 */ |
| t1 = (rx * rx * ry * ry) - (rx * rx * y1t * y1t) - (ry * ry * x1t * x1t); |
| t2 = (rx * rx * y1t * y1t) + (ry * ry * x1t * x1t); |
| t3 = t1 / t2; |
| /* guard against rounding errors; sqrt of negative numbers is bad for your health */ |
| if (t3 < 0) t3 = 0; |
| t3 = sqrtf(t3); |
| |
| cxt = sign * t3 * (rx * y1t) / ry; |
| cyt = sign * t3 * -(ry * x1t) / rx; |
| |
| /* F.6.5.3 */ |
| pt.x = cxt; |
| pt.y = cyt; |
| pt = fz_transform_vector(rotmat, pt); |
| cx = pt.x + (x1 + x2) / 2; |
| cy = pt.y + (y1 + y2) / 2; |
| |
| /* F.6.5.4 */ |
| { |
| fz_point coord1, coord2, coord3, coord4; |
| coord1.x = 1; |
| coord1.y = 0; |
| coord2.x = (x1t - cxt) / rx; |
| coord2.y = (y1t - cyt) / ry; |
| coord3.x = (x1t - cxt) / rx; |
| coord3.y = (y1t - cyt) / ry; |
| coord4.x = (-x1t - cxt) / rx; |
| coord4.y = (-y1t - cyt) / ry; |
| th1 = angle_between(coord1, coord2); |
| dth = angle_between(coord3, coord4); |
| if (dth < 0 && !is_clockwise) |
| dth += (((float)M_PI / 180) * 360); |
| if (dth > 0 && is_clockwise) |
| dth -= (((float)M_PI / 180) * 360); |
| } |
| |
| mtx = fz_identity; |
| mtx = fz_concat(fz_translate(cx, cy), mtx); |
| mtx = fz_concat(fz_rotate(rotation_angle), mtx); |
| mtx = fz_concat(fz_scale(rx, ry), mtx); |
| xps_draw_arc_segment(path, mtx, th1, th1 + dth, is_clockwise); |
| |
| fz_lineto(path, point_x, point_y); |
| } |
| |
| /* |
| * Parse an abbreviated geometry string, and call |
| * ghostscript moveto/lineto/curveto functions to |
| * build up a path. |
| */ |
| |
| static fz_path * |
| xps_parse_abbreviated_geometry(xps_context *ctx, char *geom, int *fill_rule) |
| { |
| fz_path *path; |
| char **args; |
| char **pargs; |
| char *s = geom; |
| fz_point pt; |
| int i, n; |
| int cmd, old; |
| float x1, y1, x2, y2, x3, y3; |
| float smooth_x, smooth_y; /* saved cubic bezier control point for smooth curves */ |
| int reset_smooth; |
| |
| path = fz_new_path(); |
| |
| args = fz_calloc(strlen(geom) + 1, sizeof(char*)); |
| pargs = args; |
| |
| while (*s) |
| { |
| if ((*s >= 'A' && *s <= 'Z') || (*s >= 'a' && *s <= 'z')) |
| { |
| *pargs++ = s++; |
| } |
| else if ((*s >= '0' && *s <= '9') || *s == '.' || *s == '+' || *s == '-' || *s == 'e' || *s == 'E') |
| { |
| *pargs++ = s; |
| while ((*s >= '0' && *s <= '9') || *s == '.' || *s == '+' || *s == '-' || *s == 'e' || *s == 'E') |
| s ++; |
| } |
| else |
| { |
| s++; |
| } |
| } |
| |
| pargs[0] = s; |
| pargs[1] = 0; |
| |
| n = pargs - args; |
| i = 0; |
| |
| old = 0; |
| |
| reset_smooth = 1; |
| smooth_x = 0; |
| smooth_y = 0; |
| |
| while (i < n) |
| { |
| cmd = args[i][0]; |
| if (cmd == '+' || cmd == '.' || cmd == '-' || (cmd >= '0' && cmd <= '9')) |
| cmd = old; /* it's a number, repeat old command */ |
| else |
| i ++; |
| |
| if (reset_smooth) |
| { |
| smooth_x = 0; |
| smooth_y = 0; |
| } |
| |
| reset_smooth = 1; |
| |
| switch (cmd) |
| { |
| case 'F': |
| *fill_rule = atoi(args[i]); |
| i ++; |
| break; |
| |
| case 'M': |
| fz_moveto(path, fz_atof(args[i]), fz_atof(args[i+1])); |
| i += 2; |
| break; |
| case 'm': |
| pt = fz_currentpoint(path); |
| fz_moveto(path, pt.x + fz_atof(args[i]), pt.y + fz_atof(args[i+1])); |
| i += 2; |
| break; |
| |
| case 'L': |
| fz_lineto(path, fz_atof(args[i]), fz_atof(args[i+1])); |
| i += 2; |
| break; |
| case 'l': |
| pt = fz_currentpoint(path); |
| fz_lineto(path, pt.x + fz_atof(args[i]), pt.y + fz_atof(args[i+1])); |
| i += 2; |
| break; |
| |
| case 'H': |
| pt = fz_currentpoint(path); |
| fz_lineto(path, fz_atof(args[i]), pt.y); |
| i += 1; |
| break; |
| case 'h': |
| pt = fz_currentpoint(path); |
| fz_lineto(path, pt.x + fz_atof(args[i]), pt.y); |
| i += 1; |
| break; |
| |
| case 'V': |
| pt = fz_currentpoint(path); |
| fz_lineto(path, pt.x, fz_atof(args[i])); |
| i += 1; |
| break; |
| case 'v': |
| pt = fz_currentpoint(path); |
| fz_lineto(path, pt.x, pt.y + fz_atof(args[i])); |
| i += 1; |
| break; |
| |
| case 'C': |
| x1 = fz_atof(args[i+0]); |
| y1 = fz_atof(args[i+1]); |
| x2 = fz_atof(args[i+2]); |
| y2 = fz_atof(args[i+3]); |
| x3 = fz_atof(args[i+4]); |
| y3 = fz_atof(args[i+5]); |
| fz_curveto(path, x1, y1, x2, y2, x3, y3); |
| i += 6; |
| reset_smooth = 0; |
| smooth_x = x3 - x2; |
| smooth_y = y3 - y2; |
| break; |
| |
| case 'c': |
| pt = fz_currentpoint(path); |
| x1 = fz_atof(args[i+0]) + pt.x; |
| y1 = fz_atof(args[i+1]) + pt.y; |
| x2 = fz_atof(args[i+2]) + pt.x; |
| y2 = fz_atof(args[i+3]) + pt.y; |
| x3 = fz_atof(args[i+4]) + pt.x; |
| y3 = fz_atof(args[i+5]) + pt.y; |
| fz_curveto(path, x1, y1, x2, y2, x3, y3); |
| i += 6; |
| reset_smooth = 0; |
| smooth_x = x3 - x2; |
| smooth_y = y3 - y2; |
| break; |
| |
| case 'S': |
| pt = fz_currentpoint(path); |
| x1 = fz_atof(args[i+0]); |
| y1 = fz_atof(args[i+1]); |
| x2 = fz_atof(args[i+2]); |
| y2 = fz_atof(args[i+3]); |
| fz_curveto(path, pt.x + smooth_x, pt.y + smooth_y, x1, y1, x2, y2); |
| i += 4; |
| reset_smooth = 0; |
| smooth_x = x2 - x1; |
| smooth_y = y2 - y1; |
| break; |
| |
| case 's': |
| pt = fz_currentpoint(path); |
| x1 = fz_atof(args[i+0]) + pt.x; |
| y1 = fz_atof(args[i+1]) + pt.y; |
| x2 = fz_atof(args[i+2]) + pt.x; |
| y2 = fz_atof(args[i+3]) + pt.y; |
| fz_curveto(path, pt.x + smooth_x, pt.y + smooth_y, x1, y1, x2, y2); |
| i += 4; |
| reset_smooth = 0; |
| smooth_x = x2 - x1; |
| smooth_y = y2 - y1; |
| break; |
| |
| case 'Q': |
| pt = fz_currentpoint(path); |
| x1 = fz_atof(args[i+0]); |
| y1 = fz_atof(args[i+1]); |
| x2 = fz_atof(args[i+2]); |
| y2 = fz_atof(args[i+3]); |
| fz_curveto(path, |
| (pt.x + 2 * x1) / 3, (pt.y + 2 * y1) / 3, |
| (x2 + 2 * x1) / 3, (y2 + 2 * y1) / 3, |
| x2, y2); |
| i += 4; |
| break; |
| case 'q': |
| pt = fz_currentpoint(path); |
| x1 = fz_atof(args[i+0]) + pt.x; |
| y1 = fz_atof(args[i+1]) + pt.y; |
| x2 = fz_atof(args[i+2]) + pt.x; |
| y2 = fz_atof(args[i+3]) + pt.y; |
| fz_curveto(path, |
| (pt.x + 2 * x1) / 3, (pt.y + 2 * y1) / 3, |
| (x2 + 2 * x1) / 3, (y2 + 2 * y1) / 3, |
| x2, y2); |
| i += 4; |
| break; |
| |
| case 'A': |
| xps_draw_arc(path, |
| fz_atof(args[i+0]), fz_atof(args[i+1]), fz_atof(args[i+2]), |
| atoi(args[i+3]), atoi(args[i+4]), |
| fz_atof(args[i+5]), fz_atof(args[i+6])); |
| i += 7; |
| break; |
| case 'a': |
| pt = fz_currentpoint(path); |
| xps_draw_arc(path, |
| fz_atof(args[i+0]), fz_atof(args[i+1]), fz_atof(args[i+2]), |
| atoi(args[i+3]), atoi(args[i+4]), |
| fz_atof(args[i+5]) + pt.x, fz_atof(args[i+6]) + pt.y); |
| i += 7; |
| break; |
| |
| case 'Z': |
| case 'z': |
| fz_closepath(path); |
| break; |
| |
| default: |
| /* eek */ |
| break; |
| } |
| |
| old = cmd; |
| } |
| |
| fz_free(args); |
| return path; |
| } |
| |
| static void |
| xps_parse_arc_segment(fz_path *path, xml_element *root, int stroking, int *skipped_stroke) |
| { |
| /* ArcSegment pretty much follows the SVG algorithm for converting an |
| * arc in endpoint representation to an arc in centerpoint |
| * representation. Once in centerpoint it can be given to the |
| * graphics library in the form of a postscript arc. */ |
| |
| float rotation_angle; |
| int is_large_arc, is_clockwise; |
| float point_x, point_y; |
| float size_x, size_y; |
| int is_stroked; |
| |
| char *point_att = xml_att(root, "Point"); |
| char *size_att = xml_att(root, "Size"); |
| char *rotation_angle_att = xml_att(root, "RotationAngle"); |
| char *is_large_arc_att = xml_att(root, "IsLargeArc"); |
| char *sweep_direction_att = xml_att(root, "SweepDirection"); |
| char *is_stroked_att = xml_att(root, "IsStroked"); |
| |
| if (!point_att || !size_att || !rotation_angle_att || !is_large_arc_att || !sweep_direction_att) |
| { |
| fz_warn("ArcSegment element is missing attributes"); |
| return; |
| } |
| |
| is_stroked = 1; |
| if (is_stroked_att && !strcmp(is_stroked_att, "false")) |
| is_stroked = 0; |
| if (!is_stroked) |
| *skipped_stroke = 1; |
| |
| sscanf(point_att, "%g,%g", &point_x, &point_y); |
| sscanf(size_att, "%g,%g", &size_x, &size_y); |
| rotation_angle = fz_atof(rotation_angle_att); |
| is_large_arc = !strcmp(is_large_arc_att, "true"); |
| is_clockwise = !strcmp(sweep_direction_att, "Clockwise"); |
| |
| if (stroking && !is_stroked) |
| { |
| fz_moveto(path, point_x, point_y); |
| return; |
| } |
| |
| xps_draw_arc(path, size_x, size_y, rotation_angle, is_large_arc, is_clockwise, point_x, point_y); |
| } |
| |
| static void |
| xps_parse_poly_quadratic_bezier_segment(fz_path *path, xml_element *root, int stroking, int *skipped_stroke) |
| { |
| char *points_att = xml_att(root, "Points"); |
| char *is_stroked_att = xml_att(root, "IsStroked"); |
| float x[2], y[2]; |
| int is_stroked; |
| fz_point pt; |
| char *s; |
| int n; |
| |
| if (!points_att) |
| { |
| fz_warn("PolyQuadraticBezierSegment element has no points"); |
| return; |
| } |
| |
| is_stroked = 1; |
| if (is_stroked_att && !strcmp(is_stroked_att, "false")) |
| is_stroked = 0; |
| if (!is_stroked) |
| *skipped_stroke = 1; |
| |
| s = points_att; |
| n = 0; |
| while (*s != 0) |
| { |
| while (*s == ' ') s++; |
| sscanf(s, "%g,%g", &x[n], &y[n]); |
| while (*s != ' ' && *s != 0) s++; |
| n ++; |
| if (n == 2) |
| { |
| if (stroking && !is_stroked) |
| { |
| fz_moveto(path, x[1], y[1]); |
| } |
| else |
| { |
| pt = fz_currentpoint(path); |
| fz_curveto(path, |
| (pt.x + 2 * x[0]) / 3, (pt.y + 2 * y[0]) / 3, |
| (x[1] + 2 * x[0]) / 3, (y[1] + 2 * y[0]) / 3, |
| x[1], y[1]); |
| } |
| n = 0; |
| } |
| } |
| } |
| |
| static void |
| xps_parse_poly_bezier_segment(fz_path *path, xml_element *root, int stroking, int *skipped_stroke) |
| { |
| char *points_att = xml_att(root, "Points"); |
| char *is_stroked_att = xml_att(root, "IsStroked"); |
| float x[3], y[3]; |
| int is_stroked; |
| char *s; |
| int n; |
| |
| if (!points_att) |
| { |
| fz_warn("PolyBezierSegment element has no points"); |
| return; |
| } |
| |
| is_stroked = 1; |
| if (is_stroked_att && !strcmp(is_stroked_att, "false")) |
| is_stroked = 0; |
| if (!is_stroked) |
| *skipped_stroke = 1; |
| |
| s = points_att; |
| n = 0; |
| while (*s != 0) |
| { |
| while (*s == ' ') s++; |
| sscanf(s, "%g,%g", &x[n], &y[n]); |
| while (*s != ' ' && *s != 0) s++; |
| n ++; |
| if (n == 3) |
| { |
| if (stroking && !is_stroked) |
| fz_moveto(path, x[2], y[2]); |
| else |
| fz_curveto(path, x[0], y[0], x[1], y[1], x[2], y[2]); |
| n = 0; |
| } |
| } |
| } |
| |
| static void |
| xps_parse_poly_line_segment(fz_path *path, xml_element *root, int stroking, int *skipped_stroke) |
| { |
| char *points_att = xml_att(root, "Points"); |
| char *is_stroked_att = xml_att(root, "IsStroked"); |
| int is_stroked; |
| float x, y; |
| char *s; |
| |
| if (!points_att) |
| { |
| fz_warn("PolyLineSegment element has no points"); |
| return; |
| } |
| |
| is_stroked = 1; |
| if (is_stroked_att && !strcmp(is_stroked_att, "false")) |
| is_stroked = 0; |
| if (!is_stroked) |
| *skipped_stroke = 1; |
| |
| s = points_att; |
| while (*s != 0) |
| { |
| while (*s == ' ') s++; |
| sscanf(s, "%g,%g", &x, &y); |
| if (stroking && !is_stroked) |
| fz_moveto(path, x, y); |
| else |
| fz_lineto(path, x, y); |
| while (*s != ' ' && *s != 0) s++; |
| } |
| } |
| |
| static void |
| xps_parse_path_figure(fz_path *path, xml_element *root, int stroking) |
| { |
| xml_element *node; |
| |
| char *is_closed_att; |
| char *start_point_att; |
| char *is_filled_att; |
| |
| int is_closed = 0; |
| int is_filled = 1; |
| float start_x = 0; |
| float start_y = 0; |
| |
| int skipped_stroke = 0; |
| |
| is_closed_att = xml_att(root, "IsClosed"); |
| start_point_att = xml_att(root, "StartPoint"); |
| is_filled_att = xml_att(root, "IsFilled"); |
| |
| if (is_closed_att) |
| is_closed = !strcmp(is_closed_att, "true"); |
| if (is_filled_att) |
| is_filled = !strcmp(is_filled_att, "true"); |
| if (start_point_att) |
| sscanf(start_point_att, "%g,%g", &start_x, &start_y); |
| |
| if (!stroking && !is_filled) /* not filled, when filling */ |
| return; |
| |
| fz_moveto(path, start_x, start_y); |
| |
| for (node = xml_down(root); node; node = xml_next(node)) |
| { |
| if (!strcmp(xml_tag(node), "ArcSegment")) |
| xps_parse_arc_segment(path, node, stroking, &skipped_stroke); |
| if (!strcmp(xml_tag(node), "PolyBezierSegment")) |
| xps_parse_poly_bezier_segment(path, node, stroking, &skipped_stroke); |
| if (!strcmp(xml_tag(node), "PolyLineSegment")) |
| xps_parse_poly_line_segment(path, node, stroking, &skipped_stroke); |
| if (!strcmp(xml_tag(node), "PolyQuadraticBezierSegment")) |
| xps_parse_poly_quadratic_bezier_segment(path, node, stroking, &skipped_stroke); |
| } |
| |
| if (is_closed) |
| { |
| if (stroking && skipped_stroke) |
| fz_lineto(path, start_x, start_y); /* we've skipped using fz_moveto... */ |
| else |
| fz_closepath(path); /* no skipped segments, safe to closepath properly */ |
| } |
| } |
| |
| fz_path * |
| xps_parse_path_geometry(xps_context *ctx, xps_resource *dict, xml_element *root, int stroking, int *fill_rule) |
| { |
| xml_element *node; |
| |
| char *figures_att; |
| char *fill_rule_att; |
| char *transform_att; |
| |
| xml_element *transform_tag = NULL; |
| xml_element *figures_tag = NULL; /* only used by resource */ |
| |
| fz_matrix transform; |
| fz_path *path; |
| |
| figures_att = xml_att(root, "Figures"); |
| fill_rule_att = xml_att(root, "FillRule"); |
| transform_att = xml_att(root, "Transform"); |
| |
| for (node = xml_down(root); node; node = xml_next(node)) |
| { |
| if (!strcmp(xml_tag(node), "PathGeometry.Transform")) |
| transform_tag = xml_down(node); |
| } |
| |
| xps_resolve_resource_reference(ctx, dict, &transform_att, &transform_tag, NULL); |
| xps_resolve_resource_reference(ctx, dict, &figures_att, &figures_tag, NULL); |
| |
| if (fill_rule_att) |
| { |
| if (!strcmp(fill_rule_att, "NonZero")) |
| *fill_rule = 1; |
| if (!strcmp(fill_rule_att, "EvenOdd")) |
| *fill_rule = 0; |
| } |
| |
| transform = fz_identity; |
| if (transform_att) |
| xps_parse_render_transform(ctx, transform_att, &transform); |
| if (transform_tag) |
| xps_parse_matrix_transform(ctx, transform_tag, &transform); |
| |
| if (figures_att) |
| path = xps_parse_abbreviated_geometry(ctx, figures_att, fill_rule); |
| else |
| path = fz_new_path(); |
| |
| if (figures_tag) |
| xps_parse_path_figure(path, figures_tag, stroking); |
| |
| for (node = xml_down(root); node; node = xml_next(node)) |
| { |
| if (!strcmp(xml_tag(node), "PathFigure")) |
| xps_parse_path_figure(path, node, stroking); |
| } |
| |
| if (transform_att || transform_tag) |
| fz_transform_path(path, transform); |
| |
| return path; |
| } |
| |
| static int |
| xps_parse_line_cap(char *attr) |
| { |
| if (attr) |
| { |
| if (!strcmp(attr, "Flat")) return 0; |
| if (!strcmp(attr, "Round")) return 1; |
| if (!strcmp(attr, "Square")) return 2; |
| if (!strcmp(attr, "Triangle")) return 3; |
| } |
| return 0; |
| } |
| |
| void |
| xps_clip(xps_context *ctx, fz_matrix ctm, xps_resource *dict, char *clip_att, xml_element *clip_tag) |
| { |
| fz_path *path; |
| int fill_rule = 0; |
| |
| if (clip_att) |
| path = xps_parse_abbreviated_geometry(ctx, clip_att, &fill_rule); |
| else if (clip_tag) |
| path = xps_parse_path_geometry(ctx, dict, clip_tag, 0, &fill_rule); |
| else |
| path = fz_new_path(); |
| fz_clip_path(ctx->dev, path, NULL, fill_rule == 0, ctm); |
| fz_free_path(path); |
| } |
| |
| /* |
| * Parse an XPS <Path> element, and call relevant ghostscript |
| * functions for drawing and/or clipping the child elements. |
| */ |
| |
| void |
| xps_parse_path(xps_context *ctx, fz_matrix ctm, char *base_uri, xps_resource *dict, xml_element *root) |
| { |
| xml_element *node; |
| |
| char *fill_uri; |
| char *stroke_uri; |
| char *opacity_mask_uri; |
| |
| char *transform_att; |
| char *clip_att; |
| char *data_att; |
| char *fill_att; |
| char *stroke_att; |
| char *opacity_att; |
| char *opacity_mask_att; |
| |
| xml_element *transform_tag = NULL; |
| xml_element *clip_tag = NULL; |
| xml_element *data_tag = NULL; |
| xml_element *fill_tag = NULL; |
| xml_element *stroke_tag = NULL; |
| xml_element *opacity_mask_tag = NULL; |
| |
| char *fill_opacity_att = NULL; |
| char *stroke_opacity_att = NULL; |
| |
| char *stroke_dash_array_att; |
| char *stroke_dash_cap_att; |
| char *stroke_dash_offset_att; |
| char *stroke_end_line_cap_att; |
| char *stroke_start_line_cap_att; |
| char *stroke_line_join_att; |
| char *stroke_miter_limit_att; |
| char *stroke_thickness_att; |
| |
| fz_stroke_state stroke; |
| fz_matrix transform; |
| float samples[32]; |
| fz_colorspace *colorspace; |
| fz_path *path; |
| fz_rect area; |
| int fill_rule; |
| |
| /* |
| * Extract attributes and extended attributes. |
| */ |
| |
| transform_att = xml_att(root, "RenderTransform"); |
| clip_att = xml_att(root, "Clip"); |
| data_att = xml_att(root, "Data"); |
| fill_att = xml_att(root, "Fill"); |
| stroke_att = xml_att(root, "Stroke"); |
| opacity_att = xml_att(root, "Opacity"); |
| opacity_mask_att = xml_att(root, "OpacityMask"); |
| |
| stroke_dash_array_att = xml_att(root, "StrokeDashArray"); |
| stroke_dash_cap_att = xml_att(root, "StrokeDashCap"); |
| stroke_dash_offset_att = xml_att(root, "StrokeDashOffset"); |
| stroke_end_line_cap_att = xml_att(root, "StrokeEndLineCap"); |
| stroke_start_line_cap_att = xml_att(root, "StrokeStartLineCap"); |
| stroke_line_join_att = xml_att(root, "StrokeLineJoin"); |
| stroke_miter_limit_att = xml_att(root, "StrokeMiterLimit"); |
| stroke_thickness_att = xml_att(root, "StrokeThickness"); |
| |
| for (node = xml_down(root); node; node = xml_next(node)) |
| { |
| if (!strcmp(xml_tag(node), "Path.RenderTransform")) |
| transform_tag = xml_down(node); |
| if (!strcmp(xml_tag(node), "Path.OpacityMask")) |
| opacity_mask_tag = xml_down(node); |
| if (!strcmp(xml_tag(node), "Path.Clip")) |
| clip_tag = xml_down(node); |
| if (!strcmp(xml_tag(node), "Path.Fill")) |
| fill_tag = xml_down(node); |
| if (!strcmp(xml_tag(node), "Path.Stroke")) |
| stroke_tag = xml_down(node); |
| if (!strcmp(xml_tag(node), "Path.Data")) |
| data_tag = xml_down(node); |
| } |
| |
| fill_uri = base_uri; |
| stroke_uri = base_uri; |
| opacity_mask_uri = base_uri; |
| |
| xps_resolve_resource_reference(ctx, dict, &data_att, &data_tag, NULL); |
| xps_resolve_resource_reference(ctx, dict, &clip_att, &clip_tag, NULL); |
| xps_resolve_resource_reference(ctx, dict, &transform_att, &transform_tag, NULL); |
| xps_resolve_resource_reference(ctx, dict, &fill_att, &fill_tag, &fill_uri); |
| xps_resolve_resource_reference(ctx, dict, &stroke_att, &stroke_tag, &stroke_uri); |
| xps_resolve_resource_reference(ctx, dict, &opacity_mask_att, &opacity_mask_tag, &opacity_mask_uri); |
| |
| /* |
| * Act on the information we have gathered: |
| */ |
| |
| if (!data_att && !data_tag) |
| return; |
| |
| if (fill_tag && !strcmp(xml_tag(fill_tag), "SolidColorBrush")) |
| { |
| fill_opacity_att = xml_att(fill_tag, "Opacity"); |
| fill_att = xml_att(fill_tag, "Color"); |
| fill_tag = NULL; |
| } |
| |
| if (stroke_tag && !strcmp(xml_tag(stroke_tag), "SolidColorBrush")) |
| { |
| stroke_opacity_att = xml_att(stroke_tag, "Opacity"); |
| stroke_att = xml_att(stroke_tag, "Color"); |
| stroke_tag = NULL; |
| } |
| |
| stroke.start_cap = xps_parse_line_cap(stroke_start_line_cap_att); |
| stroke.dash_cap = xps_parse_line_cap(stroke_dash_cap_att); |
| stroke.end_cap = xps_parse_line_cap(stroke_end_line_cap_att); |
| |
| stroke.linejoin = 0; |
| if (stroke_line_join_att) |
| { |
| if (!strcmp(stroke_line_join_att, "Miter")) stroke.linejoin = 0; |
| if (!strcmp(stroke_line_join_att, "Round")) stroke.linejoin = 1; |
| if (!strcmp(stroke_line_join_att, "Bevel")) stroke.linejoin = 2; |
| } |
| |
| stroke.miterlimit = 10; |
| if (stroke_miter_limit_att) |
| stroke.miterlimit = fz_atof(stroke_miter_limit_att); |
| |
| stroke.linewidth = 1; |
| if (stroke_thickness_att) |
| stroke.linewidth = fz_atof(stroke_thickness_att); |
| |
| stroke.dash_phase = 0; |
| stroke.dash_len = 0; |
| if (stroke_dash_array_att) |
| { |
| char *s = stroke_dash_array_att; |
| |
| if (stroke_dash_offset_att) |
| stroke.dash_phase = fz_atof(stroke_dash_offset_att) * stroke.linewidth; |
| |
| while (*s && stroke.dash_len < nelem(stroke.dash_list)) |
| { |
| while (*s == ' ') |
| s++; |
| stroke.dash_list[stroke.dash_len++] = fz_atof(s) * stroke.linewidth; |
| while (*s && *s != ' ') |
| s++; |
| } |
| } |
| |
| transform = fz_identity; |
| if (transform_att) |
| xps_parse_render_transform(ctx, transform_att, &transform); |
| if (transform_tag) |
| xps_parse_matrix_transform(ctx, transform_tag, &transform); |
| ctm = fz_concat(transform, ctm); |
| |
| if (clip_att || clip_tag) |
| xps_clip(ctx, ctm, dict, clip_att, clip_tag); |
| |
| fill_rule = 0; |
| if (data_att) |
| path = xps_parse_abbreviated_geometry(ctx, data_att, &fill_rule); |
| else if (data_tag) |
| path = xps_parse_path_geometry(ctx, dict, data_tag, 0, &fill_rule); |
| |
| if (stroke_att || stroke_tag) |
| area = fz_bound_path(path, &stroke, ctm); |
| else |
| area = fz_bound_path(path, NULL, ctm); |
| |
| xps_begin_opacity(ctx, ctm, area, opacity_mask_uri, dict, opacity_att, opacity_mask_tag); |
| |
| if (fill_att) |
| { |
| xps_parse_color(ctx, base_uri, fill_att, &colorspace, samples); |
| if (fill_opacity_att) |
| samples[0] = fz_atof(fill_opacity_att); |
| xps_set_color(ctx, colorspace, samples); |
| |
| fz_fill_path(ctx->dev, path, fill_rule == 0, ctm, |
| ctx->colorspace, ctx->color, ctx->alpha); |
| } |
| |
| if (fill_tag) |
| { |
| area = fz_bound_path(path, NULL, ctm); |
| |
| fz_clip_path(ctx->dev, path, NULL, fill_rule == 0, ctm); |
| xps_parse_brush(ctx, ctm, area, fill_uri, dict, fill_tag); |
| fz_pop_clip(ctx->dev); |
| } |
| |
| if (stroke_att) |
| { |
| xps_parse_color(ctx, base_uri, stroke_att, &colorspace, samples); |
| if (stroke_opacity_att) |
| samples[0] = fz_atof(stroke_opacity_att); |
| xps_set_color(ctx, colorspace, samples); |
| |
| fz_stroke_path(ctx->dev, path, &stroke, ctm, |
| ctx->colorspace, ctx->color, ctx->alpha); |
| } |
| |
| if (stroke_tag) |
| { |
| fz_clip_stroke_path(ctx->dev, path, NULL, &stroke, ctm); |
| xps_parse_brush(ctx, ctm, area, stroke_uri, dict, stroke_tag); |
| fz_pop_clip(ctx->dev); |
| } |
| |
| xps_end_opacity(ctx, opacity_mask_uri, dict, opacity_att, opacity_mask_tag); |
| |
| fz_free_path(path); |
| path = NULL; |
| |
| if (clip_att || clip_tag) |
| fz_pop_clip(ctx->dev); |
| } |