include/svgtiny.h: add fill_opacity and stroke_opacity to svgtiny_shape

[libsvgtiny.git] / src / svgtiny.c

diff --git a/src/svgtiny.c b/src/svgtiny.c
index db0d59b02cd72209a51f409d7f62aef338bb64e3..3ad6eecb192eaa90b84e0c94b4adff9815383064 100644 (file)
--- a/src/svgtiny.c
+++ b/src/svgtiny.c
@@ -697,22 +697,21 @@ svgtiny_code svgtiny_parse(struct svgtiny_diagram *diagram,
        lwc_string_unref(svg_name_lwc);
        dom_string_unref(svg_name);
 
-       /* get graphic dimensions */
+       /* initialize the state struct with zeros */
        memset(&state, 0, sizeof(state));
+
+       /* get graphic dimensions */
        state.diagram = diagram;
        state.document = document;
        state.viewport_width = viewport_width;
        state.viewport_height = viewport_height;
 
-
        /* Initialize CSS context */
-       if (state.select_ctx == NULL) {
-               css_code = css_select_ctx_create(&state.select_ctx);
-               if (css_code != CSS_OK) {
-                       dom_node_unref(svg);
-                       dom_node_unref(document);
-                       return svgtiny_LIBCSS_ERROR;
-               }
+       css_code = css_select_ctx_create(&state.select_ctx);
+       if (css_code != CSS_OK) {
+               dom_node_unref(svg);
+               dom_node_unref(document);
+               return svgtiny_LIBCSS_ERROR;
        }
 
 #define SVGTINY_STRING_ACTION2(s,n)                                    \
@@ -725,6 +724,19 @@ svgtiny_code svgtiny_parse(struct svgtiny_diagram *diagram,
 #include "svgtiny_strings.h"
 #undef SVGTINY_STRING_ACTION2
 
+       /* Intern SVG's xmlns separately because it's an lwc_string
+        * and not a dom_string. We initialize its pointer to NULL
+        * because the "cleanup:" test to see if it needs to be free'd
+        * looks for NULL. Returning a LIBDOM_ERROR on failure is not
+        * perfect but it's the closest of the available options. */
+       state.interned_svg_xmlns = NULL;
+       if (lwc_intern_string("http://www.w3.org/2000/svg",
+                             26,
+                             &state.interned_svg_xmlns) != lwc_error_ok) {
+               code = svgtiny_LIBDOM_ERROR;
+               goto cleanup;
+       }
+
        svgtiny_parse_position_attributes(svg, state, &x, &y, &width, &height);
        diagram->width = width;
        diagram->height = height;
@@ -762,6 +774,11 @@ cleanup:
                dom_string_unref(state.interned_##s);
 #include "svgtiny_strings.h"
 #undef SVGTINY_STRING_ACTION2
+
+       if (state.interned_svg_xmlns != NULL) {
+               lwc_string_unref(state.interned_svg_xmlns);
+       }
+
        return code;
 }
 
@@ -2054,6 +2071,22 @@ 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) {
@@ -2076,6 +2109,14 @@ 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
+                  be supported in libcss. */
                char *style = strndup(dom_string_data(attr),
                                      dom_string_byte_length(attr));
                const char *s;
@@ -2108,6 +2149,51 @@ 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);
+       }
 }