X-Git-Url: https://gitweb.michael.orlitzky.com/?a=blobdiff_plain;f=src%2Fsvgtiny.c;h=165fc215758f330d32beb0dc8dda704fd9e234c0;hb=864636d1ee1bfabe716d46697b097d577ba226f8;hp=d16a761300ad7b0657eb7b59478a085af06b1cae;hpb=b94bca14bb7cd65bda2a92454a17a2e0d0b7234c;p=libsvgtiny.git diff --git a/src/svgtiny.c b/src/svgtiny.c index d16a761..165fc21 100644 --- a/src/svgtiny.c +++ b/src/svgtiny.c @@ -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; @@ -697,24 +714,28 @@ 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; } + /* ...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) \ @@ -725,6 +746,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 +796,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; } @@ -933,7 +972,7 @@ svgtiny_code svgtiny_preparse_styles(dom_element *svg, } /** - * Parse a or element node. + * Parse , , and element nodes. */ svgtiny_code svgtiny_parse_svg(dom_element *svg, @@ -943,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); @@ -986,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); @@ -1049,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; } @@ -1080,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); @@ -1435,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) { @@ -1511,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; */ @@ -1627,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; */ @@ -1744,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) { @@ -1788,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); @@ -2055,13 +2113,6 @@ void svgtiny_parse_paint_attributes(dom_element *node, 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); @@ -2083,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)); @@ -2123,10 +2168,6 @@ void svgtiny_parse_paint_attributes(dom_element *node, free(style); dom_string_unref(attr); } - - if (inline_sheet != NULL) { - css_stylesheet_destroy(inline_sheet); - } } @@ -2253,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. @@ -2380,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)