From 715017613e56b3b01c6cc796ddc24ff353e79ace Mon Sep 17 00:00:00 2001 From: Michael Orlitzky Date: Sat, 7 Jun 2025 11:31:39 -0400 Subject: [PATCH] src/svgtiny{,_parse}.c: use a separate function for style application We've been doing CSS in svgtiny_parse_paint_attributes(), because we only support CSS paint attributes at the moment. But ultimately that won't be right. Let's separate it out now into its own function, svgtiny_parse_styles(). --- src/svgtiny.c | 129 ++++++++++++++++++++++++++++++++++++++++++++ src/svgtiny_parse.c | 102 +---------------------------------- 2 files changed, 130 insertions(+), 101 deletions(-) diff --git a/src/svgtiny.c b/src/svgtiny.c index 7794c6d..1cc003e 100644 --- a/src/svgtiny.c +++ b/src/svgtiny.c @@ -365,6 +365,128 @@ static svgtiny_code is_ancestor_node(dom_node *source, dom_node *target) } +/** + * Parse the contents of an inline style and return (a pointer to) the + * corresponding stylesheet for use with css_select_style(). Returns + * NULL if anything goes wrong. + */ +static css_stylesheet *svgtiny_parse_style_inline(const uint8_t *data, + size_t len) +{ + css_stylesheet *sheet; + css_error code; + + code = svgtiny_create_stylesheet(&sheet, true); + if (code != CSS_OK) { + return NULL; + } + + code = css_stylesheet_append_data(sheet, data, len); + if (code != CSS_OK && code != CSS_NEEDDATA) { + css_stylesheet_destroy(sheet); + return NULL; + } + + code = css_stylesheet_data_done(sheet); + if (code != CSS_OK) { + css_stylesheet_destroy(sheet); + return NULL; + } + + return sheet; +} + + +/** + * 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. + */ +static 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; + } + 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 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 + * 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); + } +} + + /** * Parse a element node. * @@ -383,6 +505,7 @@ svgtiny_parse_path(dom_element *path, struct svgtiny_parse_state state) 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); @@ -443,6 +566,7 @@ svgtiny_parse_rect(dom_element *rect, struct svgtiny_parse_state state) &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) { @@ -512,6 +636,7 @@ svgtiny_parse_circle(dom_element *circle, struct svgtiny_parse_state state) 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; */ @@ -616,6 +741,7 @@ svgtiny_parse_ellipse(dom_element *ellipse, struct svgtiny_parse_state state) 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; */ @@ -721,6 +847,7 @@ svgtiny_parse_line(dom_element *line, struct svgtiny_parse_state state) 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) { @@ -765,6 +892,7 @@ 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); @@ -971,6 +1099,7 @@ svgtiny_parse_svg(dom_element *svg, struct svgtiny_parse_state state) 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); diff --git a/src/svgtiny_parse.c b/src/svgtiny_parse.c index 180b50c..936f4f0 100644 --- a/src/svgtiny_parse.c +++ b/src/svgtiny_parse.c @@ -10,8 +10,6 @@ #include #include -#include - #include "svgtiny.h" #include "svgtiny_internal.h" #include "svgtiny_parse.h" @@ -1490,38 +1488,6 @@ svgtiny_parse_viewbox(const char *text, } -/** - * Parse the contents of an inline style and return (a pointer to) the - * corresponding stylesheet for use with css_select_style(). Returns - * NULL if anything goes wrong. - */ -static css_stylesheet *svgtiny_parse_style_inline(const uint8_t *data, - size_t len) -{ - css_stylesheet *sheet; - css_error code; - - code = svgtiny_create_stylesheet(&sheet, true); - if (code != CSS_OK) { - return NULL; - } - - code = css_stylesheet_append_data(sheet, data, len); - if (code != CSS_OK && code != CSS_NEEDDATA) { - css_stylesheet_destroy(sheet); - return NULL; - } - - code = css_stylesheet_data_done(sheet); - if (code != CSS_OK) { - css_stylesheet_destroy(sheet); - return NULL; - } - - return sheet; -} - - /** * parse an inline style */ @@ -1535,22 +1501,6 @@ svgtiny_parse_inline_style(dom_element *node, const char *declaration_start; 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; /* style attribute */ exc = dom_element_get_attribute(node, state->interned_style, &attr); @@ -1561,13 +1511,8 @@ svgtiny_parse_inline_style(dom_element *node, /* no style attribute */ return svgtiny_OK; } - /* 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. */ cursor = dom_string_data(attr); textend = cursor + dom_string_byte_length(attr); @@ -1587,51 +1532,6 @@ svgtiny_parse_inline_style(dom_element *node, } dom_string_unref(attr); - struct dom_element *parent; - dom_element_parent_node(node, &parent); - if (parent == NULL) { - /* This is the root 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 - * element. - */ - css_stylesheet_destroy(inline_sheet); - return svgtiny_OK; - } - 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 svgtiny_LIBCSS_ERROR; - } - - 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); - } - return svgtiny_OK; } -- 2.49.0