X-Git-Url: https://gitweb.michael.orlitzky.com/?a=blobdiff_plain;f=src%2Fsvgtiny.c;h=98a84d44d7921635a03f67d7188a453a2aaf8ae2;hb=099cae0989f0ef3db52de99fb0d1e562465f5a02;hp=f6319305c3d2f1c76504766879b9ef55a9e219ea;hpb=545123c6ec9a3d3903e713c1c2919762417538dd;p=libsvgtiny.git

diff --git a/src/svgtiny.c b/src/svgtiny.c
index f631930..98a84d4 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;
 
@@ -686,7 +703,7 @@ svgtiny_code svgtiny_parse(struct svgtiny_diagram *diagram,
 		dom_node_unref(document);
 		return svgtiny_LIBDOM_ERROR;
 	}
-	if (!dom_string_caseless_lwc_isequal(svg_name, svg_name_lwc)) {
+	if (!dom_string_lwc_isequal(svg_name, svg_name_lwc)) {
 		lwc_string_unref(svg_name_lwc);
 		dom_string_unref(svg_name);
 		dom_node_unref(svg);
@@ -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)	\
@@ -924,7 +945,7 @@ svgtiny_code svgtiny_preparse_styles(dom_element *svg,
 				return svgtiny_LIBDOM_ERROR;
 			}
 
-			if (dom_string_caseless_isequal(state.interned_style,
+			if (dom_string_isequal(state.interned_style,
 							nodename)) {
 				/* We have a <style> element, parse it */
 				code = svgtiny_parse_style_element(child,
@@ -951,7 +972,7 @@ svgtiny_code svgtiny_preparse_styles(dom_element *svg,
 }
 
 /**
- * Parse a <svg> or <g> element node.
+ * Parse <svg>, <g>, and <a> element nodes.
  */
 
 svgtiny_code svgtiny_parse_svg(dom_element *svg,
@@ -961,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);
@@ -1004,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);
@@ -1017,37 +1048,37 @@ svgtiny_code svgtiny_parse_svg(dom_element *svg,
 				svgtiny_cleanup_state_local(&state);
 				return svgtiny_LIBDOM_ERROR;
 			}
-			if (dom_string_caseless_isequal(state.interned_svg,
+			if (dom_string_isequal(state.interned_svg,
 							nodename))
 				code = svgtiny_parse_svg(child, state);
-			else if (dom_string_caseless_isequal(state.interned_g,
+			else if (dom_string_isequal(state.interned_g,
 							     nodename))
 				code = svgtiny_parse_svg(child, state);
-			else if (dom_string_caseless_isequal(state.interned_a,
+			else if (dom_string_isequal(state.interned_a,
 							     nodename))
 				code = svgtiny_parse_svg(child, state);
-			else if (dom_string_caseless_isequal(state.interned_path,
+			else if (dom_string_isequal(state.interned_path,
 							     nodename))
 				code = svgtiny_parse_path(child, state);
-			else if (dom_string_caseless_isequal(state.interned_rect,
+			else if (dom_string_isequal(state.interned_rect,
 							     nodename))
 				code = svgtiny_parse_rect(child, state);
-			else if (dom_string_caseless_isequal(state.interned_circle,
+			else if (dom_string_isequal(state.interned_circle,
 							     nodename))
 				code = svgtiny_parse_circle(child, state);
-			else if (dom_string_caseless_isequal(state.interned_ellipse,
+			else if (dom_string_isequal(state.interned_ellipse,
 							     nodename))
 				code = svgtiny_parse_ellipse(child, state);
-			else if (dom_string_caseless_isequal(state.interned_line,
+			else if (dom_string_isequal(state.interned_line,
 							     nodename))
 				code = svgtiny_parse_line(child, state);
-			else if (dom_string_caseless_isequal(state.interned_polyline,
+			else if (dom_string_isequal(state.interned_polyline,
 							     nodename))
 				code = svgtiny_parse_poly(child, state, false);
-			else if (dom_string_caseless_isequal(state.interned_polygon,
+			else if (dom_string_isequal(state.interned_polygon,
 							     nodename))
 				code = svgtiny_parse_poly(child, state, true);
-			else if (dom_string_caseless_isequal(state.interned_text,
+			else if (dom_string_isequal(state.interned_text,
 							     nodename))
 				code = svgtiny_parse_text(child, state);
 			dom_string_unref(nodename);
@@ -1067,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;
 }
@@ -1098,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);
@@ -1453,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) {
@@ -1529,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; */
@@ -1645,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; */
@@ -1762,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) {
@@ -1806,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);
@@ -1920,8 +1960,8 @@ svgtiny_code svgtiny_parse_text(dom_element *text,
 				svgtiny_cleanup_state_local(&state);
 				return svgtiny_LIBDOM_ERROR;
 			}
-			if (dom_string_caseless_isequal(nodename,
-							state.interned_tspan))
+			if (dom_string_isequal(nodename,
+						state.interned_tspan))
 				code = svgtiny_parse_text((dom_element *)child,
 							  state);
 			dom_string_unref(nodename);
@@ -2073,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);
@@ -2101,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));
@@ -2141,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);
-	}
 }
 
 
@@ -2271,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.
@@ -2398,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)