]> gitweb.michael.orlitzky.com - libsvgtiny.git/blobdiff - src/svgtiny.c
src/svgtiny*.{c,h}: move the libcss unit context into the parser state
[libsvgtiny.git] / src / svgtiny.c
index e80404a58da00ebd0182e25090836e5bfcd10537..a70be0f50643530e86d9639204cc64b4569e3764 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 void 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;
 
@@ -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) \
@@ -966,6 +988,7 @@ svgtiny_code svgtiny_parse_svg(dom_element *svg,
        svgtiny_parse_position_attributes(svg, state, &x, &y, &width, &height);
        svgtiny_parse_paint_attributes(svg, &state);
        svgtiny_parse_font_attributes(svg, &state);
+       svgtiny_parse_styles(svg, &state);
 
        exc = dom_element_get_attribute(svg, state.interned_viewBox,
                                        &view_box);
@@ -1097,6 +1120,7 @@ svgtiny_code svgtiny_parse_path(dom_element *path,
 
        svgtiny_parse_paint_attributes(path, &state);
        svgtiny_parse_transform_attributes(path, &state);
+       svgtiny_parse_styles(path, &state);
 
        /* read d attribute */
        exc = dom_element_get_attribute(path, state.interned_d, &path_d_str);
@@ -1452,6 +1476,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);
+       svgtiny_parse_styles(rect, &state);
 
        p = malloc(13 * sizeof p[0]);
        if (!p) {
@@ -1528,6 +1553,7 @@ svgtiny_code svgtiny_parse_circle(dom_element *circle,
 
        svgtiny_parse_paint_attributes(circle, &state);
        svgtiny_parse_transform_attributes(circle, &state);
+       svgtiny_parse_styles(circle, &state);
 
        if (r < 0) {
                state.diagram->error_line = -1; /* circle->line; */
@@ -1644,6 +1670,7 @@ svgtiny_code svgtiny_parse_ellipse(dom_element *ellipse,
 
        svgtiny_parse_paint_attributes(ellipse, &state);
        svgtiny_parse_transform_attributes(ellipse, &state);
+       svgtiny_parse_styles(ellipse, &state);
 
        if (rx < 0 || ry < 0) {
                state.diagram->error_line = -1; /* ellipse->line; */
@@ -1761,6 +1788,7 @@ svgtiny_code svgtiny_parse_line(dom_element *line,
 
        svgtiny_parse_paint_attributes(line, &state);
        svgtiny_parse_transform_attributes(line, &state);
+       svgtiny_parse_styles(line, &state);
 
        p = malloc(7 * sizeof p[0]);
        if (!p) {
@@ -1805,6 +1833,7 @@ svgtiny_code svgtiny_parse_poly(dom_element *poly,
 
        svgtiny_parse_paint_attributes(poly, &state);
        svgtiny_parse_transform_attributes(poly, &state);
+       svgtiny_parse_styles(poly, &state);
 
        exc = dom_element_get_attribute(poly, state.interned_points,
                                        &points_str);
@@ -2071,22 +2100,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 +2122,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 +2156,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 +2282,94 @@ 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.
+ */
+void 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;
+
+
+       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);
+       }
+
+       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 NULL;
+       }
+       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 NULL;
+       }
+
+       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);
+       }
+}
 
 /**
  * Parse a transform string.