static void
svg_run_ellipse(fz_context *ctx, fz_device *dev, svg_document *doc, fz_xml *node, const svg_state *inherit_state)
{
svg_state local_state = *inherit_state;
char *cx_att = fz_xml_att(node, "cx");
char *cy_att = fz_xml_att(node, "cy");
char *rx_att = fz_xml_att(node, "rx");
char *ry_att = fz_xml_att(node, "ry");
float cx = 0;
float cy = 0;
float rx = 0;
float ry = 0;
fz_path *path;
svg_parse_common(ctx, doc, node, &local_state);
if (cx_att) cx = svg_parse_length(cx_att, local_state.viewbox_w, local_state.fontsize);
if (cy_att) cy = svg_parse_length(cy_att, local_state.viewbox_h, local_state.fontsize);
if (rx_att) rx = svg_parse_length(rx_att, local_state.viewbox_w, local_state.fontsize);
if (ry_att) ry = svg_parse_length(ry_att, local_state.viewbox_h, local_state.fontsize);
if (rx <= 0 || ry <= 0)
return;
path = fz_new_path(ctx);
approx_circle(ctx, path, cx, cy, rx, ry);
svg_draw_path(ctx, dev, doc, path, &local_state);
fz_drop_path(ctx, path);
}
static void
xps_load_links_in_path(fz_context *ctx, xps_document *doc, const fz_matrix *ctm,
char *base_uri, xps_resource *dict, fz_xml *root, fz_link **link)
{
char *navigate_uri_att = fz_xml_att(root, "FixedPage.NavigateUri");
if (navigate_uri_att)
{
char *transform_att = fz_xml_att(root, "RenderTransform");
fz_xml *transform_tag = fz_xml_down(fz_xml_find_down(root, "Path.RenderTransform"));
char *data_att = fz_xml_att(root, "Data");
fz_xml *data_tag = fz_xml_down(fz_xml_find_down(root, "Path.Data"));
fz_path *path = NULL;
int fill_rule;
fz_matrix local_ctm;
fz_rect area;
xps_resolve_resource_reference(ctx, doc, dict, &data_att, &data_tag, NULL);
xps_resolve_resource_reference(ctx, doc, dict, &transform_att, &transform_tag, NULL);
xps_parse_transform(ctx, doc, transform_att, transform_tag, &local_ctm, ctm);
if (data_att)
path = xps_parse_abbreviated_geometry(ctx, doc, data_att, &fill_rule);
else if (data_tag)
path = xps_parse_path_geometry(ctx, doc, dict, data_tag, 0, &fill_rule);
if (path)
{
fz_bound_path(ctx, path, NULL, &local_ctm, &area);
fz_drop_path(ctx, path);
xps_add_link(ctx, doc, &area, base_uri, navigate_uri_att, link);
}
}
}
static void
svg_run_line(fz_context *ctx, fz_device *dev, svg_document *doc, fz_xml *node, const svg_state *inherit_state)
{
svg_state local_state = *inherit_state;
char *x1_att = fz_xml_att(node, "x1");
char *y1_att = fz_xml_att(node, "y1");
char *x2_att = fz_xml_att(node, "x2");
char *y2_att = fz_xml_att(node, "y2");
float x1 = 0;
float y1 = 0;
float x2 = 0;
float y2 = 0;
svg_parse_common(ctx, doc, node, &local_state);
if (x1_att) x1 = svg_parse_length(x1_att, local_state.viewbox_w, local_state.fontsize);
if (y1_att) y1 = svg_parse_length(y1_att, local_state.viewbox_h, local_state.fontsize);
if (x2_att) x2 = svg_parse_length(x2_att, local_state.viewbox_w, local_state.fontsize);
if (y2_att) y2 = svg_parse_length(y2_att, local_state.viewbox_h, local_state.fontsize);
if (local_state.stroke_is_set)
{
fz_path *path = fz_new_path(ctx);
fz_moveto(ctx, path, x1, y1);
fz_lineto(ctx, path, x2, y2);
svg_stroke(ctx, dev, doc, path, &local_state);
fz_drop_path(ctx, path);
}
}
static void
svg_run_polygon(fz_context *ctx, fz_device *dev, svg_document *doc, fz_xml *node, const svg_state *inherit_state)
{
svg_state local_state = *inherit_state;
fz_path *path;
svg_parse_common(ctx, doc, node, &local_state);
path = svg_parse_polygon_imp(ctx, doc, node, 1);
svg_draw_path(ctx, dev, doc, path, &local_state);
fz_drop_path(ctx, path);
}
static void
svg_run_polyline(fz_context *ctx, fz_device *dev, svg_document *doc, fz_xml *node, const svg_state *inherit_state)
{
svg_state local_state = *inherit_state;
svg_parse_common(ctx, doc, node, &local_state);
if (local_state.stroke_is_set)
{
fz_path *path = svg_parse_polygon_imp(ctx, doc, node, 0);
svg_stroke(ctx, dev, doc, path, &local_state);
fz_drop_path(ctx, path);
}
}
static void draw_rect(fz_context *ctx, fz_device *dev, const fz_matrix *ctm, float *rgba, float x0, float y0, float x1, float y1)
{
fz_path *path = fz_new_path(ctx);
fz_moveto(ctx, path, x0, y0);
fz_lineto(ctx, path, x1, y0);
fz_lineto(ctx, path, x1, y1);
fz_lineto(ctx, path, x0, y1);
fz_closepath(ctx, path);
fz_fill_path(ctx, dev, path, 0, ctm, fz_device_rgb(ctx), rgba, rgba[3]);
fz_drop_path(ctx, path);
}
static void
xps_paint_tiling_brush_clipped(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, const fz_rect *viewbox, struct closure *c)
{
fz_device *dev = doc->dev;
fz_path *path = fz_new_path(ctx);
fz_moveto(ctx, path, viewbox->x0, viewbox->y0);
fz_lineto(ctx, path, viewbox->x0, viewbox->y1);
fz_lineto(ctx, path, viewbox->x1, viewbox->y1);
fz_lineto(ctx, path, viewbox->x1, viewbox->y0);
fz_closepath(ctx, path);
fz_clip_path(ctx, dev, path, NULL, 0, ctm);
fz_drop_path(ctx, path);
c->func(ctx, doc, ctm, viewbox, c->base_uri, c->dict, c->root, c->user);
fz_pop_clip(ctx, dev);
}
void
xps_clip(fz_context *ctx, xps_document *doc, fz_matrix ctm, xps_resource *dict, char *clip_att, fz_xml *clip_tag)
{
fz_device *dev = doc->dev;
fz_path *path;
int fill_rule = 0;
if (clip_att)
path = xps_parse_abbreviated_geometry(ctx, doc, clip_att, &fill_rule);
else if (clip_tag)
path = xps_parse_path_geometry(ctx, doc, dict, clip_tag, 0, &fill_rule);
else
path = fz_new_path(ctx);
fz_clip_path(ctx, dev, path, fill_rule == 0, ctm, fz_infinite_rect);
fz_drop_path(ctx, path);
}
static void
svg_run_path(fz_context *ctx, fz_device *dev, svg_document *doc, fz_xml *node, const svg_state *inherit_state)
{
svg_state local_state = *inherit_state;
const char *d_att = fz_xml_att(node, "d");
/* unused: char *path_length_att = fz_xml_att(node, "pathLength"); */
svg_parse_common(ctx, doc, node, &local_state);
if (d_att)
{
fz_path *path = svg_parse_path_data(ctx, doc, d_att);
svg_draw_path(ctx, dev, doc, path, &local_state);
fz_drop_path(ctx, path);
}
}
static void draw_rect(fz_context *ctx, fz_device *dev, const fz_matrix *ctm, fz_css_color color, float x0, float y0, float x1, float y1)
{
if (color.a > 0)
{
float rgb[3];
fz_path *path = fz_new_path(ctx);
fz_moveto(ctx, path, x0, y0);
fz_lineto(ctx, path, x1, y0);
fz_lineto(ctx, path, x1, y1);
fz_lineto(ctx, path, x0, y1);
fz_closepath(ctx, path);
rgb[0] = color.r / 255.0f;
rgb[1] = color.g / 255.0f;
rgb[2] = color.b / 255.0f;
fz_fill_path(ctx, dev, path, 0, ctm, fz_device_rgb(ctx), rgb, color.a / 255.0f);
fz_drop_path(ctx, path);
}
}
static void
svg_run_rect(fz_context *ctx, fz_device *dev, svg_document *doc, fz_xml *node, const svg_state *inherit_state)
{
svg_state local_state = *inherit_state;
char *x_att = fz_xml_att(node, "x");
char *y_att = fz_xml_att(node, "y");
char *w_att = fz_xml_att(node, "width");
char *h_att = fz_xml_att(node, "height");
char *rx_att = fz_xml_att(node, "rx");
char *ry_att = fz_xml_att(node, "ry");
float x = 0;
float y = 0;
float w = 0;
float h = 0;
float rx = 0;
float ry = 0;
fz_path *path;
svg_parse_common(ctx, doc, node, &local_state);
if (x_att) x = svg_parse_length(x_att, local_state.viewbox_w, local_state.fontsize);
if (y_att) y = svg_parse_length(y_att, local_state.viewbox_h, local_state.fontsize);
if (w_att) w = svg_parse_length(w_att, local_state.viewbox_w, local_state.fontsize);
if (h_att) h = svg_parse_length(h_att, local_state.viewbox_h, local_state.fontsize);
if (rx_att) rx = svg_parse_length(rx_att, local_state.viewbox_w, local_state.fontsize);
if (ry_att) ry = svg_parse_length(ry_att, local_state.viewbox_h, local_state.fontsize);
if (rx_att && !ry_att)
ry = rx;
if (ry_att && !rx_att)
rx = ry;
if (rx > w * 0.5)
rx = w * 0.5;
if (ry > h * 0.5)
ry = h * 0.5;
if (w <= 0 || h <= 0)
return;
path = fz_new_path(ctx);
if (rx == 0 || ry == 0)
{
fz_moveto(ctx, path, x, y);
fz_lineto(ctx, path, x + w, y);
fz_lineto(ctx, path, x + w, y + h);
fz_lineto(ctx, path, x, y + h);
}
else
{
float rxs = rx * MAGIC_CIRCLE;
float rys = rx * MAGIC_CIRCLE;
fz_moveto(ctx, path, x + w - rx, y);
fz_curveto(ctx, path, x + w - rxs, y, x + w, y + rys, x + w, y + ry);
fz_lineto(ctx, path, x + w, y + h - ry);
fz_curveto(ctx, path, x + w, y + h - rys, x + w - rxs, y + h, x + w - rx, y + h);
fz_lineto(ctx, path, x + rx, y + h);
fz_curveto(ctx, path, x + rxs, y + h, x, y + h - rys, x, y + h - rx);
fz_lineto(ctx, path, x, y + rx);
fz_curveto(ctx, path, x, y + rxs, x + rxs, y, x + rx, y);
}
fz_closepath(ctx, path);
svg_draw_path(ctx, dev, doc, path, &local_state);
fz_drop_path(ctx, path);
}
static fz_path *
svg_parse_path_data(fz_context *ctx, svg_document *doc, const char *str)
{
fz_path *path = fz_new_path(ctx);
fz_point p;
float x1, y1, x2, y2;
int cmd;
float number;
float args[6];
int nargs;
/* saved control point for smooth curves */
int reset_smooth = 1;
float smooth_x = 0.0;
float smooth_y = 0.0;
cmd = 0;
nargs = 0;
fz_try(ctx)
{
fz_moveto(ctx, path, 0.0, 0.0); /* for the case of opening 'm' */
while (*str)
{
while (svg_is_whitespace_or_comma(*str))
str ++;
if (svg_is_digit(*str))
{
str = svg_lex_number(&number, str);
if (nargs == 6)
fz_throw(ctx, FZ_ERROR_GENERIC, "stack overflow in path data");
args[nargs++] = number;
}
else if (svg_is_alpha(*str))
{
if (nargs != 0)
fz_throw(ctx, FZ_ERROR_GENERIC, "syntax error in path data (wrong number of parameters to '%c')", cmd);
cmd = *str++;
}
else if (*str == 0)
{
break;
}
else
{
fz_throw(ctx, FZ_ERROR_GENERIC, "syntax error in path data: '%c'", *str);
}
if (reset_smooth)
{
smooth_x = 0.0;
smooth_y = 0.0;
}
reset_smooth = 1;
switch (cmd)
{
case 'M':
if (nargs == 2)
{
fz_moveto(ctx, path, args[0], args[1]);
nargs = 0;
cmd = 'L'; /* implicit lineto after */
}
break;
case 'm':
if (nargs == 2)
{
p = fz_currentpoint(ctx, path);
fz_moveto(ctx, path, p.x + args[0], p.y + args[1]);
nargs = 0;
cmd = 'l'; /* implicit lineto after */
}
break;
case 'Z':
case 'z':
if (nargs == 0)
{
fz_closepath(ctx, path);
}
break;
case 'L':
if (nargs == 2)
{
fz_lineto(ctx, path, args[0], args[1]);
nargs = 0;
}
break;
case 'l':
if (nargs == 2)
{
p = fz_currentpoint(ctx, path);
fz_lineto(ctx, path, p.x + args[0], p.y + args[1]);
nargs = 0;
}
break;
case 'H':
if (nargs == 1)
{
p = fz_currentpoint(ctx, path);
fz_lineto(ctx, path, args[0], p.y);
nargs = 0;
}
break;
case 'h':
if (nargs == 1)
{
p = fz_currentpoint(ctx, path);
fz_lineto(ctx, path, p.x + args[0], p.y);
nargs = 0;
}
break;
case 'V':
if (nargs == 1)
{
p = fz_currentpoint(ctx, path);
fz_lineto(ctx, path, p.x, args[0]);
nargs = 0;
}
break;
case 'v':
if (nargs == 1)
{
p = fz_currentpoint(ctx, path);
fz_lineto(ctx, path, p.x, p.y + args[0]);
nargs = 0;
}
break;
case 'C':
reset_smooth = 0;
if (nargs == 6)
{
fz_curveto(ctx, path, args[0], args[1], args[2], args[3], args[4], args[5]);
smooth_x = args[4] - args[2];
smooth_y = args[5] - args[3];
nargs = 0;
}
break;
case 'c':
reset_smooth = 0;
if (nargs == 6)
{
p = fz_currentpoint(ctx, path);
fz_curveto(ctx, path,
p.x + args[0], p.y + args[1],
p.x + args[2], p.y + args[3],
p.x + args[4], p.y + args[5]);
smooth_x = args[4] - args[2];
smooth_y = args[5] - args[3];
nargs = 0;
}
break;
case 'S':
reset_smooth = 0;
if (nargs == 4)
{
p = fz_currentpoint(ctx, path);
fz_curveto(ctx, path,
p.x + smooth_x, p.y + smooth_y,
args[0], args[1],
args[2], args[3]);
smooth_x = args[2] - args[0];
smooth_y = args[3] - args[1];
nargs = 0;
}
break;
case 's':
reset_smooth = 0;
if (nargs == 4)
{
p = fz_currentpoint(ctx, path);
fz_curveto(ctx, path,
p.x + smooth_x, p.y + smooth_y,
p.x + args[0], p.y + args[1],
p.x + args[2], p.y + args[3]);
smooth_x = args[2] - args[0];
smooth_y = args[3] - args[1];
nargs = 0;
}
break;
case 'Q':
reset_smooth = 0;
if (nargs == 4)
{
p = fz_currentpoint(ctx, path);
x1 = args[0];
y1 = args[1];
x2 = args[2];
y2 = args[3];
fz_curveto(ctx, path,
(p.x + 2 * x1) / 3, (p.y + 2 * y1) / 3,
(x2 + 2 * x1) / 3, (y2 + 2 * y1) / 3,
x2, y2);
smooth_x = x2 - x1;
smooth_y = y2 - y1;
nargs = 0;
}
break;
case 'q':
reset_smooth = 0;
if (nargs == 4)
{
p = fz_currentpoint(ctx, path);
x1 = args[0] + p.x;
y1 = args[1] + p.y;
x2 = args[2] + p.x;
y2 = args[3] + p.y;
fz_curveto(ctx, path,
(p.x + 2 * x1) / 3, (p.y + 2 * y1) / 3,
(x2 + 2 * x1) / 3, (y2 + 2 * y1) / 3,
x2, y2);
smooth_x = x2 - x1;
smooth_y = y2 - y1;
nargs = 0;
}
break;
case 'T':
reset_smooth = 0;
if (nargs == 4)
{
p = fz_currentpoint(ctx, path);
x1 = p.x + smooth_x;
y1 = p.y + smooth_y;
x2 = args[0];
y2 = args[1];
fz_curveto(ctx, path,
(p.x + 2 * x1) / 3, (p.y + 2 * y1) / 3,
(x2 + 2 * x1) / 3, (y2 + 2 * y1) / 3,
x2, y2);
smooth_x = x2 - x1;
smooth_y = y2 - y1;
nargs = 0;
}
break;
case 't':
reset_smooth = 0;
if (nargs == 4)
{
p = fz_currentpoint(ctx, path);
x1 = p.x + smooth_x;
y1 = p.y + smooth_y;
x2 = args[0] + p.x;
y2 = args[1] + p.y;
fz_curveto(ctx, path,
(p.x + 2 * x1) / 3, (p.y + 2 * y1) / 3,
(x2 + 2 * x1) / 3, (y2 + 2 * y1) / 3,
x2, y2);
smooth_x = x2 - x1;
smooth_y = y2 - y1;
nargs = 0;
}
break;
case 0:
if (nargs != 0)
fz_throw(ctx, FZ_ERROR_GENERIC, "path data must begin with a command");
break;
default:
fz_throw(ctx, FZ_ERROR_GENERIC, "unrecognized command in path data: '%c'", cmd);
}
}
}
fz_catch(ctx)
{
fz_drop_path(ctx, path);
fz_rethrow(ctx);
}
return path;
}
static font *
svg_dev_text_span_as_paths_defs(fz_context *ctx, fz_device *dev, fz_text_span *span, const fz_matrix *ctm)
{
svg_device *sdev = (svg_device*)dev;
fz_output *out = sdev->out;
int i, font_idx;
font *fnt;
fz_matrix shift = fz_identity;
for (font_idx = 0; font_idx < sdev->num_fonts; font_idx++)
{
if (sdev->fonts[font_idx].font == span->font)
break;
}
if (font_idx == sdev->num_fonts)
{
/* New font */
if (font_idx == sdev->max_fonts)
{
int newmax = sdev->max_fonts * 2;
if (newmax == 0)
newmax = 4;
sdev->fonts = fz_resize_array(ctx, sdev->fonts, newmax, sizeof(*sdev->fonts));
memset(&sdev->fonts[font_idx], 0, (newmax - font_idx) * sizeof(sdev->fonts[0]));
sdev->max_fonts = newmax;
}
sdev->fonts[font_idx].id = sdev->id++;
sdev->fonts[font_idx].font = fz_keep_font(ctx, span->font);
sdev->num_fonts++;
}
fnt = &sdev->fonts[font_idx];
for (i=0; i < span->len; i++)
{
fz_text_item *it = &span->items[i];
int gid = it->gid;
if (gid < 0)
continue;
if (gid >= fnt->max_sentlist)
{
int j;
fnt->sentlist = fz_resize_array(ctx, fnt->sentlist, gid+1, sizeof(fnt->sentlist[0]));
for (j = fnt->max_sentlist; j <= gid; j++)
{
fnt->sentlist[j].x_off = FLT_MIN;
fnt->sentlist[j].y_off = FLT_MIN;
}
fnt->max_sentlist = gid+1;
}
if (fnt->sentlist[gid].x_off == FLT_MIN)
{
/* Need to send this one */
fz_rect rect;
fz_path *path;
path = fz_outline_glyph(ctx, span->font, gid, &fz_identity);
if (path)
{
fz_bound_path(ctx, path, NULL, &fz_identity, &rect);
shift.e = -rect.x0;
shift.f = -rect.y0;
fz_transform_path(ctx, path, &shift);
out = start_def(ctx, sdev);
fz_printf(ctx, out, "<symbol id=\"font_%x_%x\">", fnt->id, gid);
fz_printf(ctx, out, "<path");
svg_dev_path(ctx, sdev, path);
fz_printf(ctx, out, "/>\n");
fz_drop_path(ctx, path);
}
else
{
fz_bound_glyph(ctx, span->font, gid, &fz_identity, &rect);
shift.e = -rect.x0;
shift.f = -rect.y0;
out = start_def(ctx, sdev);
fz_printf(ctx, out, "<symbol id=\"font_%x_%x\">", fnt->id, gid);
fz_run_t3_glyph(ctx, span->font, gid, &shift, dev);
}
fz_printf(ctx, out, "</symbol>");
out = end_def(ctx, sdev);
fnt->sentlist[gid].x_off = rect.x0;
fnt->sentlist[gid].y_off = rect.y0;
}
}
return fnt;
}
static int make_fake_doc(pdfapp_t *app)
{
fz_context *ctx = app->ctx;
fz_matrix ctm = { 1, 0, 0, 1, 0, 0 };
fz_rect bounds;
pdf_page *newpage = NULL;
pdf_document *pdf = NULL;
fz_device *dev = NULL;
fz_path *path = NULL;
fz_stroke_state stroke = fz_default_stroke_state;
float red[3] = { 1, 0, 0 };
int i;
fz_var(pdf);
fz_var(dev);
fz_var(newpage);
fz_try(ctx)
{
pdf = pdf_create_document(ctx);
app->doc = &pdf->super;
bounds.x0 = 0;
bounds.y0 = 0;
bounds.x1 = app->winw;
bounds.y1 = app->winh;
newpage = pdf_create_page(ctx, pdf, bounds, 72, 0);
dev = pdf_page_write(ctx, pdf, newpage);
/* Now the page content */
fz_begin_page(ctx, dev, &bounds, &ctm);
path = fz_new_path(ctx);
fz_moveto(ctx, path, 0, 0);
fz_lineto(ctx, path, bounds.x1, bounds.y1);
fz_moveto(ctx, path, 0, bounds.y1);
fz_lineto(ctx, path, bounds.x1, 0);
stroke.linewidth = fz_min(bounds.x1, bounds.y1)/4;
fz_stroke_path(ctx, dev, path, &stroke, &ctm, fz_device_rgb(ctx), red, 1);
fz_end_page(ctx, dev);
fz_drop_device(ctx, dev);
dev = NULL;
/* Create enough copies of our blank(ish) page so that the
* page number is preserved if and when a subsequent load
* works. */
for (i = 0; i < app->pagecount; i++)
pdf_insert_page(ctx, pdf, newpage, INT_MAX);
}
fz_always(ctx)
{
fz_drop_path(ctx, path);
pdf_drop_page(ctx, newpage);
fz_drop_device(ctx, dev);
dev = NULL;
}
fz_catch(ctx)
{
fz_rethrow(ctx);
}
return 0;
}
void
xps_parse_path(fz_context *ctx, xps_document *doc, fz_matrix ctm, char *base_uri, xps_resource *dict, fz_xml *root)
{
fz_device *dev = doc->dev;
fz_xml *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;
fz_xml *transform_tag = NULL;
fz_xml *clip_tag = NULL;
fz_xml *data_tag = NULL;
fz_xml *fill_tag = NULL;
fz_xml *stroke_tag = NULL;
fz_xml *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 = NULL;
float samples[FZ_MAX_COLORS];
fz_colorspace *colorspace;
fz_path *path = NULL;
fz_path *stroke_path = NULL;
fz_rect area;
int fill_rule;
int dash_len = 0;
/*
* Extract attributes and extended attributes.
*/
transform_att = fz_xml_att(root, "RenderTransform");
clip_att = fz_xml_att(root, "Clip");
data_att = fz_xml_att(root, "Data");
fill_att = fz_xml_att(root, "Fill");
stroke_att = fz_xml_att(root, "Stroke");
opacity_att = fz_xml_att(root, "Opacity");
opacity_mask_att = fz_xml_att(root, "OpacityMask");
stroke_dash_array_att = fz_xml_att(root, "StrokeDashArray");
stroke_dash_cap_att = fz_xml_att(root, "StrokeDashCap");
stroke_dash_offset_att = fz_xml_att(root, "StrokeDashOffset");
stroke_end_line_cap_att = fz_xml_att(root, "StrokeEndLineCap");
stroke_start_line_cap_att = fz_xml_att(root, "StrokeStartLineCap");
stroke_line_join_att = fz_xml_att(root, "StrokeLineJoin");
stroke_miter_limit_att = fz_xml_att(root, "StrokeMiterLimit");
stroke_thickness_att = fz_xml_att(root, "StrokeThickness");
for (node = fz_xml_down(root); node; node = fz_xml_next(node))
{
if (fz_xml_is_tag(node, "Path.RenderTransform"))
transform_tag = fz_xml_down(node);
if (fz_xml_is_tag(node, "Path.OpacityMask"))
opacity_mask_tag = fz_xml_down(node);
if (fz_xml_is_tag(node, "Path.Clip"))
clip_tag = fz_xml_down(node);
if (fz_xml_is_tag(node, "Path.Fill"))
fill_tag = fz_xml_down(node);
if (fz_xml_is_tag(node, "Path.Stroke"))
stroke_tag = fz_xml_down(node);
if (fz_xml_is_tag(node, "Path.Data"))
data_tag = fz_xml_down(node);
}
fill_uri = base_uri;
stroke_uri = base_uri;
opacity_mask_uri = base_uri;
xps_resolve_resource_reference(ctx, doc, dict, &data_att, &data_tag, NULL);
xps_resolve_resource_reference(ctx, doc, dict, &clip_att, &clip_tag, NULL);
xps_resolve_resource_reference(ctx, doc, dict, &transform_att, &transform_tag, NULL);
xps_resolve_resource_reference(ctx, doc, dict, &fill_att, &fill_tag, &fill_uri);
xps_resolve_resource_reference(ctx, doc, dict, &stroke_att, &stroke_tag, &stroke_uri);
xps_resolve_resource_reference(ctx, doc, dict, &opacity_mask_att, &opacity_mask_tag, &opacity_mask_uri);
/*
* Act on the information we have gathered:
*/
if (!data_att && !data_tag)
return;
if (fz_xml_is_tag(fill_tag, "SolidColorBrush"))
{
fill_opacity_att = fz_xml_att(fill_tag, "Opacity");
fill_att = fz_xml_att(fill_tag, "Color");
fill_tag = NULL;
}
if (fz_xml_is_tag(stroke_tag, "SolidColorBrush"))
{
stroke_opacity_att = fz_xml_att(stroke_tag, "Opacity");
stroke_att = fz_xml_att(stroke_tag, "Color");
stroke_tag = NULL;
}
if (stroke_att || stroke_tag)
{
if (stroke_dash_array_att)
{
char *s = stroke_dash_array_att;
while (*s)
{
while (*s == ' ')
s++;
if (*s) /* needed in case of a space before the last quote */
dash_len++;
while (*s && *s != ' ')
s++;
}
}
stroke = fz_new_stroke_state_with_dash_len(ctx, dash_len);
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 = FZ_LINEJOIN_MITER_XPS;
if (stroke_line_join_att)
{
if (!strcmp(stroke_line_join_att, "Miter")) stroke->linejoin = FZ_LINEJOIN_MITER_XPS;
if (!strcmp(stroke_line_join_att, "Round")) stroke->linejoin = FZ_LINEJOIN_ROUND;
if (!strcmp(stroke_line_join_att, "Bevel")) stroke->linejoin = FZ_LINEJOIN_BEVEL;
}
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)
{
while (*s == ' ')
s++;
if (*s) /* needed in case of a space before the last quote */
stroke->dash_list[stroke->dash_len++] = fz_atof(s) * stroke->linewidth;
while (*s && *s != ' ')
s++;
}
if (dash_len > 0)
{
/* fz_stroke_path doesn't draw non-empty paths with phase length zero */
float phase_len = 0;
int i;
for (i = 0; i < dash_len; i++)
phase_len += stroke->dash_list[i];
if (phase_len == 0)
dash_len = 0;
}
stroke->dash_len = dash_len;
}
}
ctm = xps_parse_transform(ctx, doc, transform_att, transform_tag, ctm);
if (clip_att || clip_tag)
xps_clip(ctx, doc, ctm, dict, clip_att, clip_tag);
fz_try(ctx)
{
fill_rule = 0;
if (data_att)
path = xps_parse_abbreviated_geometry(ctx, doc, data_att, &fill_rule);
else if (data_tag)
{
path = xps_parse_path_geometry(ctx, doc, dict, data_tag, 0, &fill_rule);
// /home/sebras/src/jxr/fts_06xx.xps
if (stroke_att || stroke_tag)
stroke_path = xps_parse_path_geometry(ctx, doc, dict, data_tag, 1, &fill_rule);
}
if (!stroke_path)
stroke_path = path;
if (stroke_att || stroke_tag)
{
area = fz_bound_path(ctx, stroke_path, stroke, ctm);
if (stroke_path != path && (fill_att || fill_tag)) {
fz_rect bounds = fz_bound_path(ctx, path, NULL, ctm);
area = fz_union_rect(area, bounds);
}
}
else
area = fz_bound_path(ctx, path, NULL, ctm);
xps_begin_opacity(ctx, doc, ctm, area, opacity_mask_uri, dict, opacity_att, opacity_mask_tag);
if (fill_att)
{
xps_parse_color(ctx, doc, base_uri, fill_att, &colorspace, samples);
if (fill_opacity_att)
samples[0] *= fz_atof(fill_opacity_att);
xps_set_color(ctx, doc, colorspace, samples);
fz_fill_path(ctx, dev, path, fill_rule == 0, ctm,
doc->colorspace, doc->color, doc->alpha, NULL);
}
if (fill_tag)
{
fz_clip_path(ctx, dev, path, fill_rule == 0, ctm, area);
xps_parse_brush(ctx, doc, ctm, area, fill_uri, dict, fill_tag);
fz_pop_clip(ctx, dev);
}
if (stroke_att)
{
xps_parse_color(ctx, doc, base_uri, stroke_att, &colorspace, samples);
if (stroke_opacity_att)
samples[0] *= fz_atof(stroke_opacity_att);
xps_set_color(ctx, doc, colorspace, samples);
fz_stroke_path(ctx, dev, stroke_path, stroke, ctm,
doc->colorspace, doc->color, doc->alpha, NULL);
}
if (stroke_tag)
{
fz_clip_stroke_path(ctx, dev, stroke_path, stroke, ctm, area);
xps_parse_brush(ctx, doc, ctm, area, stroke_uri, dict, stroke_tag);
fz_pop_clip(ctx, dev);
}
xps_end_opacity(ctx, doc, opacity_mask_uri, dict, opacity_att, opacity_mask_tag);
}
fz_always(ctx)
{
if (stroke_path != path)
fz_drop_path(ctx, stroke_path);
fz_drop_path(ctx, path);
fz_drop_stroke_state(ctx, stroke);
}
fz_catch(ctx)
fz_rethrow(ctx);
if (clip_att || clip_tag)
fz_pop_clip(ctx, dev);
}
fz_path *
xps_parse_path_geometry(fz_context *ctx, xps_document *doc, xps_resource *dict, fz_xml *root, int stroking, int *fill_rule)
{
fz_xml *node;
char *figures_att;
char *fill_rule_att;
char *transform_att;
fz_xml *transform_tag = NULL;
fz_xml *figures_tag = NULL; /* only used by resource */
fz_matrix transform;
fz_path *path;
figures_att = fz_xml_att(root, "Figures");
fill_rule_att = fz_xml_att(root, "FillRule");
transform_att = fz_xml_att(root, "Transform");
for (node = fz_xml_down(root); node; node = fz_xml_next(node))
{
if (fz_xml_is_tag(node, "PathGeometry.Transform"))
transform_tag = fz_xml_down(node);
}
xps_resolve_resource_reference(ctx, doc, dict, &transform_att, &transform_tag, NULL);
xps_resolve_resource_reference(ctx, doc, 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 = xps_parse_transform(ctx, doc, transform_att, transform_tag, fz_identity);
if (figures_att)
path = xps_parse_abbreviated_geometry(ctx, doc, figures_att, fill_rule);
else
path = fz_new_path(ctx);
fz_try(ctx)
{
if (figures_tag)
xps_parse_path_figure(ctx, doc, path, figures_tag, stroking);
for (node = fz_xml_down(root); node; node = fz_xml_next(node))
{
if (fz_xml_is_tag(node, "PathFigure"))
xps_parse_path_figure(ctx, doc, path, node, stroking);
}
if (transform_att || transform_tag)
fz_transform_path(ctx, path, transform);
}
fz_catch(ctx)
{
fz_drop_path(ctx, path);
fz_rethrow(ctx);
}
return path;
}
fz_path *
xps_parse_abbreviated_geometry(fz_context *ctx, xps_document *doc, char *geom, int *fill_rule)
{
fz_path *path;
char **args = NULL;
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;
fz_var(args);
path = fz_new_path(ctx);
fz_try(ctx)
{
args = fz_malloc_array(ctx, 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 = s;
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':
if (i >= n) break;
*fill_rule = atoi(args[i]);
i ++;
break;
case 'M':
if (i + 1 >= n) break;
fz_moveto(ctx, path, fz_atof(args[i]), fz_atof(args[i+1]));
i += 2;
break;
case 'm':
if (i + 1 >= n) break;
pt = fz_currentpoint(ctx, path);
fz_moveto(ctx, path, pt.x + fz_atof(args[i]), pt.y + fz_atof(args[i+1]));
i += 2;
break;
case 'L':
if (i + 1 >= n) break;
fz_lineto(ctx, path, fz_atof(args[i]), fz_atof(args[i+1]));
i += 2;
break;
case 'l':
if (i + 1 >= n) break;
pt = fz_currentpoint(ctx, path);
fz_lineto(ctx, path, pt.x + fz_atof(args[i]), pt.y + fz_atof(args[i+1]));
i += 2;
break;
case 'H':
if (i >= n) break;
pt = fz_currentpoint(ctx, path);
fz_lineto(ctx, path, fz_atof(args[i]), pt.y);
i += 1;
break;
case 'h':
if (i >= n) break;
pt = fz_currentpoint(ctx, path);
fz_lineto(ctx, path, pt.x + fz_atof(args[i]), pt.y);
i += 1;
break;
case 'V':
if (i >= n) break;
pt = fz_currentpoint(ctx, path);
fz_lineto(ctx, path, pt.x, fz_atof(args[i]));
i += 1;
break;
case 'v':
if (i >= n) break;
pt = fz_currentpoint(ctx, path);
fz_lineto(ctx, path, pt.x, pt.y + fz_atof(args[i]));
i += 1;
break;
case 'C':
if (i + 5 >= n) break;
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(ctx, path, x1, y1, x2, y2, x3, y3);
i += 6;
reset_smooth = 0;
smooth_x = x3 - x2;
smooth_y = y3 - y2;
break;
case 'c':
if (i + 5 >= n) break;
pt = fz_currentpoint(ctx, 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(ctx, path, x1, y1, x2, y2, x3, y3);
i += 6;
reset_smooth = 0;
smooth_x = x3 - x2;
smooth_y = y3 - y2;
break;
case 'S':
if (i + 3 >= n) break;
pt = fz_currentpoint(ctx, 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(ctx, 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':
if (i + 3 >= n) break;
pt = fz_currentpoint(ctx, 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(ctx, 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':
if (i + 3 >= n) break;
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_quadto(ctx, path, x1, y1, x2, y2);
i += 4;
break;
case 'q':
if (i + 3 >= n) break;
pt = fz_currentpoint(ctx, 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_quadto(ctx, path, x1, y1, x2, y2);
i += 4;
break;
case 'A':
if (i + 6 >= n) break;
xps_draw_arc(ctx, doc, 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':
if (i + 6 >= n) break;
pt = fz_currentpoint(ctx, path);
xps_draw_arc(ctx, doc, 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(ctx, path);
break;
default:
fz_warn(ctx, "ignoring invalid command '%c'", cmd);
if (old == cmd) /* avoid infinite loop */
i++;
break;
}
old = cmd;
}
}
fz_always(ctx)
fz_free(ctx, args);
fz_catch(ctx)
{
fz_drop_path(ctx, path);
fz_rethrow(ctx);
}
return path;
}
