struct svgtiny_parse_state *state);
static void svgtiny_parse_transform_attributes(dom_element *node,
struct svgtiny_parse_state *state);
+static css_select_results *svgtiny_parse_styles(dom_element *node,
+ struct svgtiny_parse_state *state);
static svgtiny_code svgtiny_add_path(float *p, unsigned int n,
struct svgtiny_parse_state *state);
static void _svgtiny_parse_color(const char *s, svgtiny_colour *c,
dom_element *svg;
dom_string *svg_name;
lwc_string *svg_name_lwc;
- struct svgtiny_parse_state state;
+ struct svgtiny_parse_state state = {
+ /* Initialize the unit context here because it has a
+ * const member and doing it any other way subverts
+ * the type system. The magic numbers below were taken
+ * from the libcss example program without much
+ * thought, because at the moment we don't support any
+ * properties with units. */
+ .unit_ctx = {
+ .font_size_default = FLTTOFIX(16.0),
+ .font_size_minimum = FLTTOFIX(6.0),
+ .device_dpi = FLTTOFIX(96.0),
+ .root_style = NULL,
+ .pw = NULL,
+ .measure = NULL,
+ }
+ };
float x, y, width, height;
svgtiny_code code;
dom_node_unref(document);
return svgtiny_LIBDOM_ERROR;
}
- if (svg == NULL) {
- /* no root svg element */
- dom_node_unref(document);
+ if (svg == NULL) {
+ /* no root svg element */
+ dom_node_unref(document);
return svgtiny_SVG_ERROR;
- }
+ }
exc = dom_node_get_node_name(svg, &svg_name);
if (exc != DOM_NO_ERR) {
dom_node_unref(document);
return svgtiny_LIBDOM_ERROR;
}
- if (!dom_string_caseless_lwc_isequal(svg_name, svg_name_lwc)) {
+ if (!dom_string_lwc_isequal(svg_name, svg_name_lwc)) {
lwc_string_unref(svg_name_lwc);
dom_string_unref(svg_name);
dom_node_unref(svg);
return svgtiny_LIBCSS_ERROR;
}
+ /* ...and the unit context, whose other fields were
+ * initialized along with the parser state itself */
+ state.unit_ctx.viewport_width = FLTTOFIX(viewport_width);
+ state.unit_ctx.viewport_height = FLTTOFIX(viewport_height);
+
#define SVGTINY_STRING_ACTION2(s,n) \
if (dom_string_create_interned((const uint8_t *) #n, \
strlen(#n), &state.interned_##s) \
return svgtiny_LIBDOM_ERROR;
}
- if (dom_string_caseless_isequal(state.interned_style,
+ if (dom_string_isequal(state.interned_style,
nodename)) {
/* We have a <style> element, parse it */
code = svgtiny_parse_style_element(child,
}
/**
- * Parse a <svg> or <g> element node.
+ * Parse <svg>, <g>, and <a> element nodes.
*/
svgtiny_code svgtiny_parse_svg(dom_element *svg,
dom_string *view_box;
dom_element *child;
dom_exception exc;
+ css_select_results *styles;
svgtiny_setup_state_local(&state);
svgtiny_parse_position_attributes(svg, state, &x, &y, &width, &height);
svgtiny_parse_paint_attributes(svg, &state);
svgtiny_parse_font_attributes(svg, &state);
+ styles = svgtiny_parse_styles(svg, &state);
exc = dom_element_get_attribute(svg, state.interned_viewBox,
&view_box);
dom_node_type nodetype;
svgtiny_code code = svgtiny_OK;
+ /* Before we descend to one of my child elements, set
+ * the "parent style" to my style. */
+ if (styles) {
+ /* For now at least, the root element won't
+ * have any styles; hence the null check. */
+ state.parent_style = styles->styles[CSS_PSEUDO_ELEMENT_NONE];
+ }
+
exc = dom_node_get_node_type(child, &nodetype);
if (exc != DOM_NO_ERR) {
dom_node_unref(child);
svgtiny_cleanup_state_local(&state);
return svgtiny_LIBDOM_ERROR;
}
- if (dom_string_caseless_isequal(state.interned_svg,
+ if (dom_string_isequal(state.interned_svg,
nodename))
code = svgtiny_parse_svg(child, state);
- else if (dom_string_caseless_isequal(state.interned_g,
+ else if (dom_string_isequal(state.interned_g,
nodename))
code = svgtiny_parse_svg(child, state);
- else if (dom_string_caseless_isequal(state.interned_a,
+ else if (dom_string_isequal(state.interned_a,
nodename))
code = svgtiny_parse_svg(child, state);
- else if (dom_string_caseless_isequal(state.interned_path,
+ else if (dom_string_isequal(state.interned_path,
nodename))
code = svgtiny_parse_path(child, state);
- else if (dom_string_caseless_isequal(state.interned_rect,
+ else if (dom_string_isequal(state.interned_rect,
nodename))
code = svgtiny_parse_rect(child, state);
- else if (dom_string_caseless_isequal(state.interned_circle,
+ else if (dom_string_isequal(state.interned_circle,
nodename))
code = svgtiny_parse_circle(child, state);
- else if (dom_string_caseless_isequal(state.interned_ellipse,
+ else if (dom_string_isequal(state.interned_ellipse,
nodename))
code = svgtiny_parse_ellipse(child, state);
- else if (dom_string_caseless_isequal(state.interned_line,
+ else if (dom_string_isequal(state.interned_line,
nodename))
code = svgtiny_parse_line(child, state);
- else if (dom_string_caseless_isequal(state.interned_polyline,
+ else if (dom_string_isequal(state.interned_polyline,
nodename))
code = svgtiny_parse_poly(child, state, false);
- else if (dom_string_caseless_isequal(state.interned_polygon,
+ else if (dom_string_isequal(state.interned_polygon,
nodename))
code = svgtiny_parse_poly(child, state, true);
- else if (dom_string_caseless_isequal(state.interned_text,
+ else if (dom_string_isequal(state.interned_text,
nodename))
code = svgtiny_parse_text(child, state);
dom_string_unref(nodename);
child = next;
}
+ /* Hoping that destroying "styles" destroys state.parent_style
+ * as well. */
+ css_select_results_destroy(styles);
svgtiny_cleanup_state_local(&state);
return svgtiny_OK;
}
dom_exception exc;
char *s, *path_d;
float *p; /* path elemets */
- unsigned int palloc; /* number of path elements allocated */
+ unsigned int palloc; /* number of path elements allocated */
unsigned int i;
float last_x = 0, last_y = 0;
float last_cubic_x = 0, last_cubic_y = 0;
svgtiny_parse_paint_attributes(path, &state);
svgtiny_parse_transform_attributes(path, &state);
+ css_select_results_destroy(svgtiny_parse_styles(path, &state));
/* read d attribute */
exc = dom_element_get_attribute(path, state.interned_d, &path_d_str);
return svgtiny_SVG_ERROR;
}
- /* empty path is permitted it just disables the path */
- palloc = dom_string_byte_length(path_d_str);
- if (palloc == 0) {
+ /* empty path is permitted it just disables the path */
+ palloc = dom_string_byte_length(path_d_str);
+ if (palloc == 0) {
dom_string_unref(path_d_str);
svgtiny_cleanup_state_local(&state);
return svgtiny_OK;
- }
+ }
- /* local copy of the path data allowing in-place modification */
+ /* local copy of the path data allowing in-place modification */
s = path_d = strndup(dom_string_data(path_d_str), palloc);
dom_string_unref(path_d_str);
if (s == NULL) {
return svgtiny_OUT_OF_MEMORY;
}
- /* ensure path element allocation is sensibly bounded */
- if (palloc < 8) {
- palloc = 8;
- } else if (palloc > 64) {
- palloc = palloc / 2;
- }
+ /* ensure path element allocation is sensibly bounded */
+ if (palloc < 8) {
+ palloc = 8;
+ } else if (palloc > 64) {
+ palloc = palloc / 2;
+ }
/* allocate initial space for path elements */
p = malloc(sizeof p[0] * palloc);
float x, y, x1, y1, x2, y2, rx, ry, rotation, large_arc, sweep;
int n;
- /* Ensure there is sufficient space for path elements */
+ /* Ensure there is sufficient space for path elements */
#define ALLOC_PATH_ELEMENTS(NUM_ELEMENTS) \
do { \
if ((palloc - i) < NUM_ELEMENTS) { \
else
plot_command = svgtiny_PATH_LINE;
do {
- ALLOC_PATH_ELEMENTS(3);
+ ALLOC_PATH_ELEMENTS(3);
p[i++] = plot_command;
if ('a' <= *command) {
x += last_x;
/* closepath (Z, z) (no arguments) */
} else if (sscanf(s, " %1[Zz] %n", command, &n) == 1) {
/*LOG(("closepath"));*/
- ALLOC_PATH_ELEMENTS(1);
+ ALLOC_PATH_ELEMENTS(1);
p[i++] = svgtiny_PATH_CLOSE;
s += n;
} else if (sscanf(s, " %1[Hh] %f %n", command, &x, &n) == 2) {
/*LOG(("horizontal lineto"));*/
do {
- ALLOC_PATH_ELEMENTS(3);
+ ALLOC_PATH_ELEMENTS(3);
p[i++] = svgtiny_PATH_LINE;
if (*command == 'h')
} else if (sscanf(s, " %1[Vv] %f %n", command, &y, &n) == 2) {
/*LOG(("vertical lineto"));*/
do {
- ALLOC_PATH_ELEMENTS(3);
+ ALLOC_PATH_ELEMENTS(3);
p[i++] = svgtiny_PATH_LINE;
if (*command == 'v')
&x1, &y1, &x2, &y2, &x, &y, &n) == 7) {
/*LOG(("curveto"));*/
do {
- ALLOC_PATH_ELEMENTS(7);
+ ALLOC_PATH_ELEMENTS(7);
p[i++] = svgtiny_PATH_BEZIER;
if (*command == 'c') {
&x2, &y2, &x, &y, &n) == 5) {
/*LOG(("shorthand/smooth curveto"));*/
do {
- ALLOC_PATH_ELEMENTS(7);
+ ALLOC_PATH_ELEMENTS(7);
p[i++] = svgtiny_PATH_BEZIER;
x1 = last_x + (last_x - last_cubic_x);
&x1, &y1, &x, &y, &n) == 5) {
/*LOG(("quadratic Bezier curveto"));*/
do {
- ALLOC_PATH_ELEMENTS(7);
+ ALLOC_PATH_ELEMENTS(7);
p[i++] = svgtiny_PATH_BEZIER;
last_quad_x = x1;
&x, &y, &n) == 3) {
/*LOG(("shorthand/smooth quadratic Bezier curveto"));*/
do {
- ALLOC_PATH_ELEMENTS(7);
+ ALLOC_PATH_ELEMENTS(7);
p[i++] = svgtiny_PATH_BEZIER;
x1 = last_x + (last_x - last_quad_x);
return svgtiny_OK;
}
- /* resize path element array to not be over allocated */
- if (palloc != i) {
- float *tp;
+ /* resize path element array to not be over allocated */
+ if (palloc != i) {
+ float *tp;
- /* try the resize, if it fails just continue to use the old
- * allocation
- */
- tp = realloc(p, sizeof p[0] * i);
- if (tp != NULL) {
- p = tp;
- }
- }
+ /* try the resize, if it fails just continue to use the old
+ * allocation
+ */
+ tp = realloc(p, sizeof p[0] * i);
+ if (tp != NULL) {
+ p = tp;
+ }
+ }
err = svgtiny_add_path(p, i, &state);
&x, &y, &width, &height);
svgtiny_parse_paint_attributes(rect, &state);
svgtiny_parse_transform_attributes(rect, &state);
+ css_select_results_destroy(svgtiny_parse_styles(rect, &state));
p = malloc(13 * sizeof p[0]);
if (!p) {
svgtiny_parse_paint_attributes(circle, &state);
svgtiny_parse_transform_attributes(circle, &state);
+ css_select_results_destroy(svgtiny_parse_styles(circle, &state));
if (r < 0) {
state.diagram->error_line = -1; /* circle->line; */
svgtiny_parse_paint_attributes(ellipse, &state);
svgtiny_parse_transform_attributes(ellipse, &state);
+ css_select_results_destroy(svgtiny_parse_styles(ellipse, &state));
if (rx < 0 || ry < 0) {
state.diagram->error_line = -1; /* ellipse->line; */
svgtiny_parse_paint_attributes(line, &state);
svgtiny_parse_transform_attributes(line, &state);
+ css_select_results_destroy(svgtiny_parse_styles(line, &state));
p = malloc(7 * sizeof p[0]);
if (!p) {
svgtiny_parse_paint_attributes(poly, &state);
svgtiny_parse_transform_attributes(poly, &state);
+ css_select_results_destroy(svgtiny_parse_styles(poly, &state));
exc = dom_element_get_attribute(poly, state.interned_points,
&points_str);
p[i++] = x;
p[i++] = y;
s += n;
- } else {
+ } else {
break;
- }
- }
- if (polygon)
+ }
+ }
+ if (polygon)
p[i++] = svgtiny_PATH_CLOSE;
free(points);
/* state.ctm.e = px - state.origin_x; */
/* state.ctm.f = py - state.origin_y; */
- exc = dom_node_get_first_child(text, &child);
+ exc = dom_node_get_first_child(text, &child);
if (exc != DOM_NO_ERR) {
return svgtiny_LIBDOM_ERROR;
svgtiny_cleanup_state_local(&state);
svgtiny_cleanup_state_local(&state);
return svgtiny_LIBDOM_ERROR;
}
- if (dom_string_caseless_isequal(nodename,
- state.interned_tspan))
+ if (dom_string_isequal(nodename,
+ state.interned_tspan))
code = svgtiny_parse_text((dom_element *)child,
state);
dom_string_unref(nodename);
dom_string *attr;
dom_exception exc;
- /* We store the result of svgtiny_parse_style_inline() in
- * inline_sheet, and that function returns NULL on error; in
- * particular you do not need to css_stylesheet_destroy() the
- * result if it is NULL. We initialize inline_sheet to NULL to
- * retain the same semantics. */
- css_stylesheet *inline_sheet = NULL;
-
exc = dom_element_get_attribute(node, state->interned_fill, &attr);
if (exc == DOM_NO_ERR && attr != NULL) {
svgtiny_parse_color(attr, &state->fill, &state->fill_grad, state);
exc = dom_element_get_attribute(node, state->interned_style, &attr);
if (exc == DOM_NO_ERR && attr != NULL) {
- /* First parse the style attribute into a libcss stylesheet
- in case any of its properties are known to libcss. */
- inline_sheet = svgtiny_parse_style_inline(
- (uint8_t *)dom_string_data(attr),
- dom_string_byte_length(attr));
-
- /* Parse any other properties "by hand" until they can
+ /* Parse a few properties "by hand" until they can
be supported in libcss. */
char *style = strndup(dom_string_data(attr),
dom_string_byte_length(attr));
free(style);
dom_string_unref(attr);
}
-
- if (inline_sheet != NULL) {
- css_stylesheet_destroy(inline_sheet);
- }
}
if (strcmp((const char *) attr->name, "font-size") == 0) {
/* TODO */
}
- }
+ }
#endif
}
}
}
+/**
+ * Parse element styles.
+ *
+ * First we parse any inline "style" attributes. We then compose the
+ * element's style with any parent styles. Finally, we compute any
+ * styles that we support and set the corresponding fields in the
+ * parser state.
+ */
+css_select_results *svgtiny_parse_styles(dom_element *node,
+ struct svgtiny_parse_state *state)
+{
+ css_error code;
+ css_fixed fill_opacity;
+ css_fixed stroke_opacity;
+
+ /* We store the result of svgtiny_parse_style_inline() in
+ * inline_sheet, and that function returns NULL on error; in
+ * particular you do not need to css_stylesheet_destroy() the
+ * result if it is NULL, and css_stylesheet_destroy() checks
+ * for that case. */
+ css_stylesheet *inline_sheet = NULL;
+
+ /* Initialize this to NULL for the same reason: so that we can
+ * safely destroy it later even if we never populated it. */
+ css_select_results *styles = NULL;
+
+ /* The result of composing this node's styles with its
+ * parent's styles. */
+ css_computed_style *composed = NULL;
+
+ dom_exception exc;
+ dom_string *attr;
+
+ exc = dom_element_get_attribute(node, state->interned_style, &attr);
+ if (exc != DOM_NO_ERR) {
+ return NULL;
+ }
+ if (attr != NULL) {
+ inline_sheet = svgtiny_parse_style_inline(
+ (uint8_t *)dom_string_data(attr),
+ dom_string_byte_length(attr));
+ dom_string_unref(attr);
+ }
+
+ code = svgtiny_select_style(state, node, inline_sheet, &styles);
+ css_stylesheet_destroy(inline_sheet);
+ if (code != CSS_OK) {
+ return NULL;
+ }
+
+ if (state->parent_style != NULL) {
+ code = css_computed_style_compose(
+ state->parent_style,
+ styles->styles[CSS_PSEUDO_ELEMENT_NONE],
+ &state->unit_ctx,
+ &composed);
+
+ if (code != CSS_OK || composed == NULL) {
+ /* This function promises to return a
+ * fully-composed set of styles, so if
+ * we can't do that, we should fail. */
+ css_select_results_destroy(styles);
+ return NULL;
+ }
+
+ /* Replace my original computed styles with the
+ * composed ones */
+ css_computed_style_destroy(
+ styles->styles[CSS_PSEUDO_ELEMENT_NONE]);
+ styles->styles[CSS_PSEUDO_ELEMENT_NONE] = composed;
+ }
+
+ css_computed_fill_opacity(
+ styles->styles[CSS_PSEUDO_ELEMENT_NONE],
+ &fill_opacity);
+ css_computed_stroke_opacity(
+ styles->styles[CSS_PSEUDO_ELEMENT_NONE],
+ &stroke_opacity);
+
+ state->fill_opacity = FIXTOFLT(fill_opacity);
+ state->stroke_opacity = FIXTOFLT(stroke_opacity);
+
+ return styles;
+}
/**
* Parse a transform string.
e = f = 0;
n = 0;
if ((sscanf(s, " matrix (%f %f %f %f %f %f ) %n",
- &a, &b, &c, &d, &e, &f, &n) == 6) && (n > 0))
+ &a, &b, &c, &d, &e, &f, &n) == 6) && (n > 0))
;
else if ((sscanf(s, " translate (%f %f ) %n",
- &e, &f, &n) == 2) && (n > 0))
+ &e, &f, &n) == 2) && (n > 0))
;
else if ((sscanf(s, " translate (%f ) %n",
- &e, &n) == 1) && (n > 0))
+ &e, &n) == 1) && (n > 0))
;
else if ((sscanf(s, " scale (%f %f ) %n",
- &a, &d, &n) == 2) && (n > 0))
+ &a, &d, &n) == 2) && (n > 0))
;
else if ((sscanf(s, " scale (%f ) %n",
- &a, &n) == 1) && (n > 0))
+ &a, &n) == 1) && (n > 0))
d = a;
else if ((sscanf(s, " rotate (%f %f %f ) %n",
- &angle, &x, &y, &n) == 3) && (n > 0)) {
+ &angle, &x, &y, &n) == 3) && (n > 0)) {
angle = angle / 180 * M_PI;
a = cos(angle);
b = sin(angle);
e = -x * cos(angle) + y * sin(angle) + x;
f = -x * sin(angle) - y * cos(angle) + y;
} else if ((sscanf(s, " rotate (%f ) %n",
- &angle, &n) == 1) && (n > 0)) {
+ &angle, &n) == 1) && (n > 0)) {
angle = angle / 180 * M_PI;
a = cos(angle);
b = sin(angle);
c = -sin(angle);
d = cos(angle);
} else if ((sscanf(s, " skewX (%f ) %n",
- &angle, &n) == 1) && (n > 0)) {
+ &angle, &n) == 1) && (n > 0)) {
angle = angle / 180 * M_PI;
c = tan(angle);
} else if ((sscanf(s, " skewY (%f ) %n",
- &angle, &n) == 1) && (n > 0)) {
+ &angle, &n) == 1) && (n > 0)) {
angle = angle / 180 * M_PI;
b = tan(angle);
} else
shape->text = 0;
shape->fill = state->fill;
shape->stroke = state->stroke;
+ shape->fill_opacity = state->fill_opacity;
+ shape->stroke_opacity = state->stroke_opacity;
shape->stroke_width = lroundf((float) state->stroke_width *
(state->ctm.a + state->ctm.d) / 2.0);
if (0 < state->stroke_width && shape->stroke_width == 0)
projects / libsvgtiny.git / blobdiff