]> gitweb.michael.orlitzky.com - libsvgtiny.git/blobdiff - src/svgtiny.c
src/svgtiny.c: use case-sensitive comparisons for SVG element names
[libsvgtiny.git] / src / svgtiny.c
index 3ad6eecb192eaa90b84e0c94b4adff9815383064..98a84d44d7921635a03f67d7188a453a2aaf8ae2 100644 (file)
@@ -71,6 +71,8 @@ static void svgtiny_parse_font_attributes(dom_element *node,
                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,
@@ -626,7 +628,22 @@ svgtiny_code svgtiny_parse(struct svgtiny_diagram *diagram,
        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;
 
@@ -686,7 +703,7 @@ svgtiny_code svgtiny_parse(struct svgtiny_diagram *diagram,
                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);
@@ -714,6 +731,11 @@ svgtiny_code svgtiny_parse(struct svgtiny_diagram *diagram,
                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) \
@@ -923,7 +945,7 @@ svgtiny_code svgtiny_preparse_styles(dom_element *svg,
                                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,
@@ -950,7 +972,7 @@ svgtiny_code svgtiny_preparse_styles(dom_element *svg,
 }
 
 /**
- * Parse a <svg> or <g> element node.
+ * Parse <svg>, <g>, and <a> element nodes.
  */
 
 svgtiny_code svgtiny_parse_svg(dom_element *svg,
@@ -960,12 +982,14 @@ 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);
@@ -1003,6 +1027,14 @@ svgtiny_code svgtiny_parse_svg(dom_element *svg,
                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);
@@ -1016,37 +1048,37 @@ svgtiny_code svgtiny_parse_svg(dom_element *svg,
                                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);
@@ -1066,6 +1098,9 @@ svgtiny_code svgtiny_parse_svg(dom_element *svg,
                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;
 }
@@ -1097,6 +1132,7 @@ svgtiny_code svgtiny_parse_path(dom_element *path,
 
        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);
@@ -1452,6 +1488,7 @@ svgtiny_code svgtiny_parse_rect(dom_element *rect,
                        &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) {
@@ -1528,6 +1565,7 @@ svgtiny_code svgtiny_parse_circle(dom_element *circle,
 
        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; */
@@ -1644,6 +1682,7 @@ svgtiny_code svgtiny_parse_ellipse(dom_element *ellipse,
 
        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; */
@@ -1761,6 +1800,7 @@ svgtiny_code svgtiny_parse_line(dom_element *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) {
@@ -1805,6 +1845,7 @@ svgtiny_code svgtiny_parse_poly(dom_element *poly,
 
        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);
@@ -1919,8 +1960,8 @@ svgtiny_code svgtiny_parse_text(dom_element *text,
                                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);
@@ -2071,22 +2112,6 @@ void svgtiny_parse_paint_attributes(dom_element *node,
 {
        dom_string *attr;
        dom_exception exc;
-       css_error code;
-       uint8_t   fill_opacity_type;
-       css_fixed fill_opacity;
-       uint8_t   stroke_opacity_type;
-       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;
 
        exc = dom_element_get_attribute(node, state->interned_fill, &attr);
        if (exc == DOM_NO_ERR && attr != NULL) {
@@ -2109,13 +2134,7 @@ void svgtiny_parse_paint_attributes(dom_element *node,
 
        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));
@@ -2149,51 +2168,6 @@ void svgtiny_parse_paint_attributes(dom_element *node,
                free(style);
                dom_string_unref(attr);
        }
-
-       struct dom_element *parent;
-       dom_element_parent_node(node, &parent);
-       if (parent == NULL) {
-               /* This is the root <svg> node, skip it.
-                *
-                * While initialising its selection state, libcss sets its
-                * node_data->bloom pointer using css__get_parent_bloom().
-                * But if there is no parent, that function returns,
-                *
-                *   static css_bloom empty_bloom[CSS_BLOOM_SIZE];
-                *
-                * A problem later arises because when libcss FINALISES its
-                * selection state, it frees node_data->bloom! That obviously
-                * won't work then node has no parent, i.e. if it's the root
-                * <svg> element.
-                */
-               css_stylesheet_destroy(inline_sheet);
-               return;
-       }
-       else {
-               /* We only needed to know if it was NULL */
-               dom_node_unref(parent);
-       }
-
-       code = svgtiny_select_style(state, node, inline_sheet, &styles);
-       css_stylesheet_destroy(inline_sheet);
-       if (code != CSS_OK) {
-               return;
-       }
-
-       fill_opacity_type = css_computed_fill_opacity(
-                               styles->styles[CSS_PSEUDO_ELEMENT_NONE],
-                               &fill_opacity);
-       stroke_opacity_type = css_computed_stroke_opacity(
-                               styles->styles[CSS_PSEUDO_ELEMENT_NONE],
-                               &stroke_opacity);
-       css_select_results_destroy(styles);
-
-       if (fill_opacity_type == CSS_FILL_OPACITY_SET) {
-               state->fill_opacity = FIXTOFLT(fill_opacity);
-       }
-       if (stroke_opacity_type == CSS_STROKE_OPACITY_SET) {
-               state->stroke_opacity = FIXTOFLT(stroke_opacity);
-       }
 }
 
 
@@ -2320,6 +2294,92 @@ void svgtiny_parse_transform_attributes(dom_element *node,
        }
 }
 
+/**
+ * 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;
+       uint8_t   fill_opacity_type;
+       css_fixed fill_opacity;
+       uint8_t   stroke_opacity_type;
+       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;
+       }
+
+       fill_opacity_type = css_computed_fill_opacity(
+                               styles->styles[CSS_PSEUDO_ELEMENT_NONE],
+                               &fill_opacity);
+       stroke_opacity_type = 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.
@@ -2447,6 +2507,8 @@ struct svgtiny_shape *svgtiny_add_shape(struct svgtiny_parse_state *state)
        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)