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,
+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);
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;
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) \
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);
- svgtiny_parse_styles(svg, &state);
+ styles = svgtiny_parse_styles(svg, &state);
exc = dom_element_get_attribute(svg, state.interned_viewBox,
&view_box);
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);
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;
}
svgtiny_parse_paint_attributes(path, &state);
svgtiny_parse_transform_attributes(path, &state);
- svgtiny_parse_styles(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);
&x, &y, &width, &height);
svgtiny_parse_paint_attributes(rect, &state);
svgtiny_parse_transform_attributes(rect, &state);
- svgtiny_parse_styles(rect, &state);
+ css_select_results_destroy(svgtiny_parse_styles(rect, &state));
p = malloc(13 * sizeof p[0]);
if (!p) {
svgtiny_parse_paint_attributes(circle, &state);
svgtiny_parse_transform_attributes(circle, &state);
- svgtiny_parse_styles(circle, &state);
+ css_select_results_destroy(svgtiny_parse_styles(circle, &state));
if (r < 0) {
state.diagram->error_line = -1; /* circle->line; */
svgtiny_parse_paint_attributes(ellipse, &state);
svgtiny_parse_transform_attributes(ellipse, &state);
- svgtiny_parse_styles(ellipse, &state);
+ css_select_results_destroy(svgtiny_parse_styles(ellipse, &state));
if (rx < 0 || ry < 0) {
state.diagram->error_line = -1; /* ellipse->line; */
svgtiny_parse_paint_attributes(line, &state);
svgtiny_parse_transform_attributes(line, &state);
- svgtiny_parse_styles(line, &state);
+ css_select_results_destroy(svgtiny_parse_styles(line, &state));
p = malloc(7 * sizeof p[0]);
if (!p) {
svgtiny_parse_paint_attributes(poly, &state);
svgtiny_parse_transform_attributes(poly, &state);
- svgtiny_parse_styles(poly, &state);
+ css_select_results_destroy(svgtiny_parse_styles(poly, &state));
exc = dom_element_get_attribute(poly, state.interned_points,
&points_str);
* 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_select_results *svgtiny_parse_styles(dom_element *node,
+ struct svgtiny_parse_state *state)
{
css_error code;
uint8_t fill_opacity_type;
* 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;
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);
- 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);
- }
+ state->fill_opacity = FIXTOFLT(fill_opacity);
+ state->stroke_opacity = FIXTOFLT(stroke_opacity);
+
+ return styles;
}
/**