X-Git-Url: https://gitweb.michael.orlitzky.com/?a=blobdiff_plain;f=src%2Fsvgtiny.c;h=74ce7eb1775cb92315ac8d7d521ef1533ab2c4a2;hb=aae96e5998971764de34a5e1755a8b27568e5605;hp=13249b62cdeb45068dfe7deb5b6ba8572ad2c1c2;hpb=15f6e2250a9c70e622ff2973a7b359b9e9c4619c;p=libsvgtiny.git

diff --git a/src/svgtiny.c b/src/svgtiny.c
index 13249b6..74ce7eb 100644
--- a/src/svgtiny.c
+++ b/src/svgtiny.c
@@ -17,15 +17,35 @@
 #include <dom/dom.h>
 #include <dom/bindings/xml/xmlparser.h>
 
+#include <libcss/libcss.h>
+
 #include "svgtiny.h"
 #include "svgtiny_internal.h"
 
+/* Source file generated by `gperf`. */
+#include "autogenerated_colors.c"
+
+#define TAU             6.28318530717958647692
+
 #ifndef M_PI
 #define M_PI		3.14159265358979323846
 #endif
 
+#ifndef M_PI_2
+#define M_PI_2          1.57079632679489661923
+#endif
+
 #define KAPPA		0.5522847498
 
+#define degToRad(angleInDegrees) ((angleInDegrees) * M_PI / 180.0)
+#define radToDeg(angleInRadians) ((angleInRadians) * 180.0 / M_PI)
+
+static svgtiny_code svgtiny_parse_style_element(dom_element *style,
+		struct svgtiny_parse_state state);
+static css_stylesheet *svgtiny_parse_style_inline(const uint8_t *data,
+		size_t len);
+static svgtiny_code svgtiny_preparse_styles(dom_element *svg,
+		struct svgtiny_parse_state state);
 static svgtiny_code svgtiny_parse_svg(dom_element *svg,
 		struct svgtiny_parse_state state);
 static svgtiny_code svgtiny_parse_path(dom_element *path,
@@ -54,54 +74,517 @@ static void svgtiny_parse_transform_attributes(dom_element *node,
 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,
+		struct svgtiny_parse_state_gradient *grad,
 		struct svgtiny_parse_state *state);
 
 /**
- * Set the local externally-stored parts of a parse state.
- * Call this in functions that made a new state on the stack.
- * Doesn't make own copy of global state, such as the interned string list.
+ * rotate midpoint vector
  */
-static void svgtiny_setup_state_local(struct svgtiny_parse_state *state)
+static void
+rotate_midpoint_vector(float ax, float ay,
+		       float bx, float by,
+		       double radangle,
+		       double *x_out, double *y_out)
+{
+	double dx2; /* midpoint x coordinate */
+	double dy2; /* midpoint y coordinate */
+	double cosangle; /* cosine of rotation angle */
+	double sinangle; /* sine of rotation angle */
+
+	/* compute the sin and cos of the angle */
+	cosangle = cos(radangle);
+	sinangle = sin(radangle);
+
+	/* compute the midpoint between start and end points */
+	dx2 = (ax - bx) / 2.0;
+	dy2 = (ay - by) / 2.0;
+
+	/* rotate vector to remove angle */
+	*x_out = ((cosangle * dx2) + (sinangle * dy2));
+	*y_out = ((-sinangle * dx2) + (cosangle * dy2));
+}
+
+
+/**
+ * ensure the arc radii are large enough and scale as appropriate
+ *
+ * the radii need to be large enough if they are not they must be
+ *  adjusted. This allows for elimination of differences between
+ *  implementations especialy with rounding.
+ */
+static void
+ensure_radii_scale(double x1_sq, double y1_sq,
+		   float *rx, float *ry,
+		   double *rx_sq, double *ry_sq)
 {
-	if (state->gradient_x1 != NULL) {
-		dom_string_ref(state->gradient_x1);
+	double radiisum;
+	double radiiscale;
+
+	/* set radii square values */
+	(*rx_sq) = (*rx) * (*rx);
+	(*ry_sq) = (*ry) * (*ry);
+
+	radiisum = (x1_sq / (*rx_sq)) + (y1_sq / (*ry_sq));
+	if (radiisum > 0.99999) {
+		/* need to scale radii */
+		radiiscale = sqrt(radiisum) * 1.00001;
+		*rx = (float)(radiiscale * (*rx));
+		*ry = (float)(radiiscale * (*ry));
+		/* update squares too */
+		(*rx_sq) = (*rx) * (*rx);
+		(*ry_sq) = (*ry) * (*ry);
 	}
-	if (state->gradient_y1 != NULL) {
-		dom_string_ref(state->gradient_y1);
+}
+
+
+/**
+ * compute the transformed centre point
+ */
+static void
+compute_transformed_centre_point(double sign, float rx, float ry,
+				 double rx_sq, double ry_sq,
+				 double x1, double y1,
+				 double x1_sq, double y1_sq,
+				 double *cx1, double *cy1)
+{
+	double sq;
+	double coef;
+	sq = ((rx_sq * ry_sq) - (rx_sq * y1_sq) - (ry_sq * x1_sq)) /
+		((rx_sq * y1_sq) + (ry_sq * x1_sq));
+	sq = (sq < 0) ? 0 : sq;
+
+	coef = (sign * sqrt(sq));
+
+	*cx1 = coef * ((rx * y1) / ry);
+	*cy1 = coef * -((ry * x1) / rx);
+}
+
+
+/**
+ * compute untransformed centre point
+ *
+ * \param ax The first point x coordinate
+ * \param ay The first point y coordinate
+ * \param bx The second point x coordinate
+ * \param ay The second point y coordinate
+ */
+static void
+compute_centre_point(float ax, float ay,
+		     float bx, float by,
+		     double cx1, double cy1,
+		     double radangle,
+		     double *x_out, double *y_out)
+{
+	double sx2;
+	double sy2;
+	double cosangle; /* cosine of rotation angle */
+	double sinangle; /* sine of rotation angle */
+
+	/* compute the sin and cos of the angle */
+	cosangle = cos(radangle);
+	sinangle = sin(radangle);
+
+	sx2 = (ax + bx) / 2.0;
+	sy2 = (ay + by) / 2.0;
+
+	*x_out = sx2 + (cosangle * cx1 - sinangle * cy1);
+	*y_out = sy2 + (sinangle * cx1 + cosangle * cy1);
+}
+
+
+/**
+ * compute the angle start and extent
+ */
+static void
+compute_angle_start_extent(float rx, float ry,
+			   double x1, double y1,
+			   double cx1, double cy1,
+			   double *start, double *extent)
+{
+	double sign;
+	double ux;
+	double uy;
+	double vx;
+	double vy;
+	double p, n;
+	double actmp;
+
+	/*
+	 * Angle betwen two vectors is +/- acos( u.v / len(u) * len(v))
+	 * Where:
+	 *  '.' is the dot product.
+	 *  +/- is calculated from the sign of the cross product (u x v)
+	 */
+
+	ux = (x1 - cx1) / rx;
+	uy = (y1 - cy1) / ry;
+	vx = (-x1 - cx1) / rx;
+	vy = (-y1 - cy1) / ry;
+
+	/* compute the start angle */
+	/* The angle between (ux, uy) and the 0 angle */
+
+	/* len(u) * len(1,0) == len(u) */
+	n = sqrt((ux * ux) + (uy * uy));
+	/* u.v == (ux,uy).(1,0) == (1 * ux) + (0 * uy) == ux */
+	p = ux;
+	/* u x v == (1 * uy - ux * 0) == uy */
+	sign = (uy < 0) ? -1.0 : 1.0;
+	/* (p >= n) so safe */
+	*start = sign * acos(p / n);
+
+	/* compute the extent angle */
+	n = sqrt(((ux * ux) + (uy * uy)) * ((vx * vx) + (vy * vy)));
+	p = (ux * vx) + (uy * vy);
+	sign = ((ux * vy) - (uy * vx) < 0) ? -1.0f : 1.0f;
+
+	/* arc cos must operate between -1 and 1 */
+	actmp = p / n;
+	if (actmp < -1.0) {
+		*extent = sign * M_PI;
+	} else if (actmp > 1.0) {
+		*extent = 0;
+	} else {
+		*extent = sign * acos(actmp);
 	}
-	if (state->gradient_x2 != NULL) {
-		dom_string_ref(state->gradient_x2);
+}
+
+
+/**
+ * converts a circle centered unit circle arc to a series of bezier curves
+ *
+ * Each bezier is stored as six values of three pairs of coordinates
+ *
+ * The beziers are stored without their start point as that is assumed
+ *   to be the preceding elements end point.
+ *
+ * \param start The start angle of the arc (in radians)
+ * \param extent The size of the arc (in radians)
+ * \param bzpt The array to store the bezier values in
+ * \return The number of bezier segments output (max 4)
+ */
+static int
+circle_arc_to_bezier(double start, double extent, double *bzpt)
+{
+	int bzsegments;
+	double increment;
+	double controllen;
+	int pos = 0;
+	int segment;
+	double angle;
+	double dx, dy;
+
+	bzsegments = (int) ceil(fabs(extent) / M_PI_2);
+	increment = extent / bzsegments;
+	controllen = 4.0 / 3.0 * sin(increment / 2.0) / (1.0 + cos(increment / 2.0));
+
+	for (segment = 0; segment < bzsegments; segment++) {
+		/* first control point */
+		angle = start + (segment * increment);
+		dx = cos(angle);
+		dy = sin(angle);
+		bzpt[pos++] = dx - controllen * dy;
+		bzpt[pos++] = dy + controllen * dx;
+		/* second control point */
+		angle+=increment;
+		dx = cos(angle);
+		dy = sin(angle);
+		bzpt[pos++] = dx + controllen * dy;
+		bzpt[pos++] = dy - controllen * dx;
+		/* endpoint */
+		bzpt[pos++] = dx;
+		bzpt[pos++] = dy;
+
+	}
+	return bzsegments;
+}
+
+
+/**
+ * transform coordinate list
+ *
+ * perform a scale, rotate and translate on list of coordinates
+ *
+ * scale(rx,ry)
+ * rotate(an)
+ * translate (cx, cy)
+ *
+ * homogeneous transforms
+ *
+ * scaling
+ *     |   rx        0        0   |
+ * S = |    0       ry        0   |
+ *     |    0        0        1   |
+ *
+ * rotate
+ *     | cos(an)  -sin(an)    0   |
+ * R = | sin(an)   cos(an)    0   |
+ *     |    0        0        1   |
+ *
+ * {{cos(a), -sin(a) 0}, {sin(a), cos(a),0}, {0,0,1}}
+ *
+ * translate
+ *     |    1        0       cx   |
+ * T = |    0        1       cy   |
+ *     |    0        0        1   |
+ *
+ * note order is significat here and the combined matrix is
+ * M = T.R.S
+ *
+ *       | cos(an)  -sin(an)    cx   |
+ * T.R = | sin(an)   cos(an)    cy   |
+ *       |    0        0        1    |
+ *
+ *         | rx * cos(an)  ry * -sin(an)   cx  |
+ * T.R.S = | rx * sin(an)  ry * cos(an)    cy  |
+ *         | 0             0               1   |
+ *
+ * {{Cos[a], -Sin[a], c}, {Sin[a], Cos[a], d}, {0, 0, 1}} . {{r, 0, 0}, {0, s, 0}, {0, 0, 1}}
+ *
+ * Each point
+ *     | x1 |
+ * P = | y1 |
+ *     |  1 |
+ *
+ * output
+ * | x2 |
+ * | y2 | = M . P
+ * | 1  |
+ *
+ * x2 = cx + (rx * x1 * cos(a)) + (ry * y1 * -1 * sin(a))
+ * y2 = cy + (ry * y1 * cos(a)) + (rx * x1 * sin(a))
+ *
+ *
+ * \param rx X scaling to apply
+ * \param ry Y scaling to apply
+ * \param radangle rotation to apply (in radians)
+ * \param cx X translation to apply
+ * \param cy Y translation to apply
+ * \param points The size of the bzpoints array
+ * \param bzpoints an array of x,y values to apply the transform to
+ */
+static void
+scale_rotate_translate_points(double rx, double ry,
+			      double radangle,
+			      double cx, double cy,
+			      int pntsize,
+			      double *points)
+{
+	int pnt;
+	double cosangle; /* cosine of rotation angle */
+	double sinangle; /* sine of rotation angle */
+	double rxcosangle, rxsinangle, rycosangle, rynsinangle;
+	double x2,y2;
+
+	/* compute the sin and cos of the angle */
+	cosangle = cos(radangle);
+	sinangle = sin(radangle);
+
+	rxcosangle = rx * cosangle;
+	rxsinangle = rx * sinangle;
+	rycosangle = ry * cosangle;
+	rynsinangle = ry * -1 * sinangle;
+
+	for (pnt = 0; pnt < pntsize; pnt+=2) {
+		x2 = cx + (points[pnt] * rxcosangle) + (points[pnt + 1] * rynsinangle);
+		y2 = cy + (points[pnt + 1] * rycosangle) + (points[pnt] * rxsinangle);
+		points[pnt] = x2;
+		points[pnt + 1] = y2;
 	}
-	if (state->gradient_y2 != NULL) {
-		dom_string_ref(state->gradient_y2);
+}
+
+
+/**
+ * convert an svg path arc to a bezier curve
+ *
+ * This function perfoms a transform on the nine arc parameters
+ *  (coordinate pairs for start and end together with the radii of the
+ *  elipse, the rotation angle and which of the four arcs to draw)
+ *  which generates the parameters (coordinate pairs for start,
+ *  end and their control points) for a set of up to four bezier curves.
+ *
+ * Obviously the start and end coordinates are not altered between
+ * representations so the aim is to calculate the coordinate pairs for
+ * the bezier control points.
+ *
+ * \param bzpoints the array to fill with bezier curves
+ * \return the number of bezier segments generated or -1 for a line
+ */
+static int
+svgarc_to_bezier(float start_x,
+		 float start_y,
+		 float end_x,
+		 float end_y,
+		 float rx,
+		 float ry,
+		 float angle,
+		 bool largearc,
+		 bool sweep,
+		 double *bzpoints)
+{
+	double radangle; /* normalised elipsis rotation angle in radians */
+	double rx_sq; /* x radius squared */
+	double ry_sq; /* y radius squared */
+	double x1, y1; /* rotated midpoint vector */
+	double x1_sq, y1_sq; /* x1 vector squared */
+	double cx1,cy1; /* transformed circle center */
+	double cx,cy; /* circle center */
+	double start, extent;
+	int bzsegments;
+
+	if ((start_x == end_x) && (start_y == end_y)) {
+		/*
+		 * if the start and end coordinates are the same the
+		 *  svg spec says this is equivalent to having no segment
+		 *  at all
+		 */
+		return 0;
 	}
+
+	if ((rx == 0) || (ry == 0)) {
+		/*
+		 * if either radii is zero the specified behaviour is a line
+		 */
+		return -1;
+	}
+
+	/* obtain the absolute values of the radii */
+	rx = fabsf(rx);
+	ry = fabsf(ry);
+
+	/* convert normalised angle to radians */
+	radangle = degToRad(fmod(angle, 360.0));
+
+	/* step 1 */
+	/* x1,x2 is the midpoint vector rotated to remove the arc angle */
+	rotate_midpoint_vector(start_x, start_y, end_x, end_y, radangle, &x1, &y1);
+
+	/* step 2 */
+	/* get squared x1 values */
+	x1_sq = x1 * x1;
+	y1_sq = y1 * y1;
+
+	/* ensure radii are correctly scaled  */
+	ensure_radii_scale(x1_sq, y1_sq, &rx, &ry, &rx_sq, &ry_sq);
+
+	/* compute the transformed centre point */
+	compute_transformed_centre_point(largearc == sweep?-1:1,
+					 rx, ry,
+					 rx_sq, ry_sq,
+					 x1, y1,
+					 x1_sq, y1_sq,
+					 &cx1, &cy1);
+
+	/* step 3 */
+	/* get the untransformed centre point */
+	compute_centre_point(start_x, start_y,
+			     end_x, end_y,
+			     cx1, cy1,
+			     radangle,
+			     &cx, &cy);
+
+	/* step 4 */
+	/* compute anglestart and extent */
+	compute_angle_start_extent(rx,ry,
+				   x1,y1,
+				   cx1, cy1,
+				   &start, &extent);
+
+	/* extent of 0 is a straight line */
+	if (extent == 0) {
+		return -1;
+	}
+
+	/* take account of sweep */
+	if (!sweep && extent > 0) {
+		extent -= TAU;
+	} else if (sweep && extent < 0) {
+		extent += TAU;
+	}
+
+	/* normalise start and extent */
+	extent = fmod(extent, TAU);
+	start = fmod(start, TAU);
+
+	/* convert the arc to unit circle bezier curves */
+	bzsegments = circle_arc_to_bezier(start, extent, bzpoints);
+
+	/* transform the bezier curves */
+	scale_rotate_translate_points(rx, ry,
+				      radangle,
+				      cx, cy,
+				      bzsegments * 6,
+				      bzpoints);
+
+	return bzsegments;
 }
 
+
 /**
- * Cleanup the local externally-stored parts of a parse state.
- * Call this in functions that made a new state on the stack.
- * Doesn't cleanup global state, such as the interned string list.
+ * Call this to ref the strings in a gradient state.
  */
-static void svgtiny_cleanup_state_local(struct svgtiny_parse_state *state)
+static void svgtiny_grad_string_ref(struct svgtiny_parse_state_gradient *grad)
+{
+	if (grad->gradient_x1 != NULL) {
+		dom_string_ref(grad->gradient_x1);
+	}
+	if (grad->gradient_y1 != NULL) {
+		dom_string_ref(grad->gradient_y1);
+	}
+	if (grad->gradient_x2 != NULL) {
+		dom_string_ref(grad->gradient_x2);
+	}
+	if (grad->gradient_y2 != NULL) {
+		dom_string_ref(grad->gradient_y2);
+	}
+}
+
+/**
+ * Call this to clean up the strings in a gradient state.
+ */
+static void svgtiny_grad_string_cleanup(
+		struct svgtiny_parse_state_gradient *grad)
 {
-	if (state->gradient_x1 != NULL) {
-		dom_string_unref(state->gradient_x1);
-		state->gradient_x1 = NULL;
+	if (grad->gradient_x1 != NULL) {
+		dom_string_unref(grad->gradient_x1);
+		grad->gradient_x1 = NULL;
 	}
-	if (state->gradient_y1 != NULL) {
-		dom_string_unref(state->gradient_y1);
-		state->gradient_y1 = NULL;
+	if (grad->gradient_y1 != NULL) {
+		dom_string_unref(grad->gradient_y1);
+		grad->gradient_y1 = NULL;
 	}
-	if (state->gradient_x2 != NULL) {
-		dom_string_unref(state->gradient_x2);
-		state->gradient_x2 = NULL;
+	if (grad->gradient_x2 != NULL) {
+		dom_string_unref(grad->gradient_x2);
+		grad->gradient_x2 = NULL;
 	}
-	if (state->gradient_y2 != NULL) {
-		dom_string_unref(state->gradient_y2);
-		state->gradient_y2 = NULL;
+	if (grad->gradient_y2 != NULL) {
+		dom_string_unref(grad->gradient_y2);
+		grad->gradient_y2 = NULL;
 	}
 }
 
+/**
+ * Set the local externally-stored parts of a parse state.
+ * Call this in functions that made a new state on the stack.
+ * Doesn't make own copy of global state, such as the interned string list.
+ */
+static void svgtiny_setup_state_local(struct svgtiny_parse_state *state)
+{
+	svgtiny_grad_string_ref(&(state->fill_grad));
+	svgtiny_grad_string_ref(&(state->stroke_grad));
+}
+
+/**
+ * Cleanup the local externally-stored parts of a parse state.
+ * Call this in functions that made a new state on the stack.
+ * Doesn't cleanup global state, such as the interned string list.
+ */
+static void svgtiny_cleanup_state_local(struct svgtiny_parse_state *state)
+{
+	svgtiny_grad_string_cleanup(&(state->fill_grad));
+	svgtiny_grad_string_cleanup(&(state->stroke_grad));
+}
+
 
 /**
  * Create a new svgtiny_diagram structure.
@@ -135,6 +618,7 @@ svgtiny_code svgtiny_parse(struct svgtiny_diagram *diagram,
 		const char *buffer, size_t size, const char *url,
 		int viewport_width, int viewport_height)
 {
+	css_error css_code;
 	dom_document *document;
 	dom_exception exc;
 	dom_xml_parser *parser;
@@ -152,11 +636,6 @@ svgtiny_code svgtiny_parse(struct svgtiny_diagram *diagram,
 
 	UNUSED(url);
 
-	state.gradient_x1 = NULL;
-	state.gradient_y1 = NULL;
-	state.gradient_x2 = NULL;
-	state.gradient_y2 = NULL;
-
 	parser = dom_xml_parser_create(NULL, NULL,
 				       ignore_msg, NULL, &document);
 
@@ -188,6 +667,12 @@ svgtiny_code svgtiny_parse(struct svgtiny_diagram *diagram,
 		dom_node_unref(document);
 		return svgtiny_LIBDOM_ERROR;
 	}
+        if (svg == NULL) {
+                /* no root svg element */
+                dom_node_unref(document);
+		return svgtiny_SVG_ERROR;
+        }
+
 	exc = dom_node_get_node_name(svg, &svg_name);
 	if (exc != DOM_NO_ERR) {
 		dom_node_unref(svg);
@@ -212,13 +697,23 @@ 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 */
+	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)					\
 	if (dom_string_create_interned((const uint8_t *) #n,		\
 				       strlen(#n), &state.interned_##s)	\
@@ -229,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;
@@ -242,18 +750,22 @@ svgtiny_code svgtiny_parse(struct svgtiny_diagram *diagram,
 	state.ctm.d = 1; /*(float) viewport_height / (float) height;*/
 	state.ctm.e = 0; /*x;*/
 	state.ctm.f = 0; /*y;*/
-	/*state.style = css_base_style;
-	state.style.font_size.value.length.value = option_font_size * 0.1;*/
 	state.fill = 0x000000;
 	state.stroke = svgtiny_TRANSPARENT;
 	state.stroke_width = 1;
-	state.linear_gradient_stop_count = 0;
 
 	/* parse tree */
-	code = svgtiny_parse_svg(svg, state);
+	code = svgtiny_preparse_styles(svg, state);
+	if (code == svgtiny_OK) {
+		code = svgtiny_parse_svg(svg, state);
+	}
 
 	dom_node_unref(svg);
 	dom_node_unref(document);
+	css_code = css_select_ctx_destroy(state.select_ctx);
+	if (css_code != CSS_OK) {
+		code = svgtiny_LIBCSS_ERROR;
+	}
 
 cleanup:
 	svgtiny_cleanup_state_local(&state);
@@ -262,10 +774,181 @@ 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;
 }
 
 
+/**
+ * Parse a single <style> element, appending the result to the CSS
+ * select context within the given parser state.
+ */
+svgtiny_code svgtiny_parse_style_element(dom_element *style,
+		struct svgtiny_parse_state state)
+{
+	css_stylesheet *sheet;
+	css_error code;
+	dom_exception exc;
+
+	code = svgtiny_create_stylesheet(&sheet, false);
+	if (code != CSS_OK) {
+		return svgtiny_LIBCSS_ERROR;
+	}
+
+	/* Parse the style element's "media" attribute if it has
+	   one. We don't do anything with it right now. */
+	dom_string *media_attr;
+	exc = dom_element_get_attribute(style, state.interned_media,
+					&media_attr);
+	if (exc != DOM_NO_ERR) {
+		css_stylesheet_destroy(sheet);
+		return svgtiny_LIBDOM_ERROR;
+	}
+
+	if (media_attr) {
+		/* Here's where we'd actually change the media type if
+		   we were going to use it */
+		dom_string_unref(media_attr);
+	}
+
+	dom_string *data;
+	dom_node_get_text_content(style, &data);
+	if (data == NULL) {
+		/* Empty stylesheet? That's fine. */
+		css_stylesheet_destroy(sheet);
+		return svgtiny_OK;
+	}
+
+	code = css_stylesheet_append_data(sheet,
+					  (uint8_t *)dom_string_data(data),
+					  dom_string_byte_length(data));
+	if (code != CSS_OK && code != CSS_NEEDDATA) {
+		dom_string_unref(data);
+		css_stylesheet_destroy(sheet);
+		return svgtiny_LIBCSS_ERROR;
+	}
+
+	code = css_stylesheet_data_done(sheet);
+	if (code != CSS_OK) {
+		dom_string_unref(data);
+		css_stylesheet_destroy(sheet);
+		return svgtiny_LIBCSS_ERROR;
+	}
+
+	code = css_select_ctx_append_sheet(state.select_ctx,
+		sheet,
+		CSS_ORIGIN_AUTHOR,
+		NULL);
+	if (code != CSS_OK) {
+		dom_string_unref(data);
+		return svgtiny_LIBCSS_ERROR;
+	}
+
+	dom_string_unref(data);
+	return svgtiny_OK;
+}
+
+
+/**
+ * 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.
+ */
+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 all <style> elements within a root <svg> element. This
+ * should be called before svgtiny_parse_svg() because that function
+ * makes a single pass through the document and we'd like all style
+ * information to be available during that pass. Specifically, we'd
+ * like a <style> sheet at the end of the document to affect the
+ * rendering of elements at its beginning.
+ *
+ * The element-parsing inner loop here is essentially the same as
+ * that within svgtiny_parse_svg().
+ */
+svgtiny_code svgtiny_preparse_styles(dom_element *svg,
+		struct svgtiny_parse_state state)
+{
+	dom_element *child;
+	dom_exception exc;
+
+	exc = dom_node_get_first_child(svg, (dom_node **) (void *) &child);
+	if (exc != DOM_NO_ERR) {
+		return svgtiny_LIBDOM_ERROR;
+	}
+	while (child != NULL) {
+		dom_element *next;
+		dom_node_type nodetype;
+		svgtiny_code code = svgtiny_OK;
+
+		exc = dom_node_get_node_type(child, &nodetype);
+		if (exc != DOM_NO_ERR) {
+			dom_node_unref(child);
+			return svgtiny_LIBDOM_ERROR;
+		}
+		if (nodetype == DOM_ELEMENT_NODE) {
+			dom_string *nodename;
+			exc = dom_node_get_node_name(child, &nodename);
+			if (exc != DOM_NO_ERR) {
+				dom_node_unref(child);
+				return svgtiny_LIBDOM_ERROR;
+			}
+
+			if (dom_string_caseless_isequal(state.interned_style,
+							nodename)) {
+				/* We have a <style> element, parse it */
+				code = svgtiny_parse_style_element(child,
+								state);
+			}
+
+
+			dom_string_unref(nodename);
+		}
+		if (code != svgtiny_OK) {
+			dom_node_unref(child);
+			return code;
+		}
+		exc = dom_node_get_next_sibling(child,
+						(dom_node **) (void *) &next);
+		dom_node_unref(child);
+		if (exc != DOM_NO_ERR) {
+			return svgtiny_LIBDOM_ERROR;
+		}
+		child = next;
+	}
+
+	return svgtiny_OK;
+}
+
 /**
  * Parse a <svg> or <g> element node.
  */
@@ -402,11 +1085,13 @@ svgtiny_code svgtiny_parse_path(dom_element *path,
 	dom_string *path_d_str;
 	dom_exception exc;
 	char *s, *path_d;
-	float *p;
+	float *p; /* path elemets */
+        unsigned int palloc; /* number of path elements allocated */
 	unsigned int i;
 	float last_x = 0, last_y = 0;
 	float last_cubic_x = 0, last_cubic_y = 0;
 	float last_quad_x = 0, last_quad_y = 0;
+	float subpath_first_x = 0, subpath_first_y = 0;
 
 	svgtiny_setup_state_local(&state);
 
@@ -429,16 +1114,32 @@ svgtiny_code svgtiny_parse_path(dom_element *path,
 		return svgtiny_SVG_ERROR;
 	}
 
-	s = path_d = strndup(dom_string_data(path_d_str),
-			     dom_string_byte_length(path_d_str));
+        /* empty path is permitted it just disables the path */
+        palloc = dom_string_byte_length(path_d_str);
+        if (palloc == 0) {
+		dom_string_unref(path_d_str);
+		svgtiny_cleanup_state_local(&state);
+		return svgtiny_OK;
+        }
+
+        /* local copy of the path data allowing in-place modification */
+	s = path_d = strndup(dom_string_data(path_d_str), palloc);
 	dom_string_unref(path_d_str);
 	if (s == NULL) {
 		svgtiny_cleanup_state_local(&state);
 		return svgtiny_OUT_OF_MEMORY;
 	}
-	/* allocate space for path: it will never have more elements than d */
-	p = malloc(sizeof p[0] * strlen(s));
-	if (!p) {
+
+        /* ensure path element allocation is sensibly bounded */
+        if (palloc < 8) {
+            palloc = 8;
+        } else if (palloc > 64) {
+            palloc = palloc / 2;
+        }
+
+	/* allocate initial space for path elements */
+	p = malloc(sizeof p[0] * palloc);
+	if (p == NULL) {
 		free(path_d);
 		svgtiny_cleanup_state_local(&state);
 		return svgtiny_OUT_OF_MEMORY;
@@ -455,6 +1156,24 @@ svgtiny_code svgtiny_parse_path(dom_element *path,
 		float x, y, x1, y1, x2, y2, rx, ry, rotation, large_arc, sweep;
 		int n;
 
+                /* Ensure there is sufficient space for path elements */
+#define ALLOC_PATH_ELEMENTS(NUM_ELEMENTS)                               \
+                do {                                                    \
+                        if ((palloc - i) < NUM_ELEMENTS) {              \
+                                float *tp;                              \
+                                palloc = (palloc * 2) + (palloc / 2);   \
+                                tp = realloc(p, sizeof p[0] * palloc);  \
+                                if (tp == NULL) {                       \
+                                        free(p);                        \
+                                        free(path_d);                   \
+                                        svgtiny_cleanup_state_local(&state); \
+                                        return svgtiny_OUT_OF_MEMORY;   \
+                                }                                       \
+                                p = tp;                                 \
+                        }                                               \
+                } while(0)
+
+
 		/* moveto (M, m), lineto (L, l) (2 arguments) */
 		if (sscanf(s, " %1[MmLl] %f %f %n", command, &x, &y, &n) == 3) {
 			/*LOG(("moveto or lineto"));*/
@@ -463,11 +1182,16 @@ svgtiny_code svgtiny_parse_path(dom_element *path,
 			else
 				plot_command = svgtiny_PATH_LINE;
 			do {
+                                ALLOC_PATH_ELEMENTS(3);
 				p[i++] = plot_command;
 				if ('a' <= *command) {
 					x += last_x;
 					y += last_y;
 				}
+				if (plot_command == svgtiny_PATH_MOVE) {
+					subpath_first_x = x;
+					subpath_first_y = y;
+				}
 				p[i++] = last_cubic_x = last_quad_x = last_x
 						= x;
 				p[i++] = last_cubic_y = last_quad_y = last_y
@@ -479,13 +1203,19 @@ svgtiny_code svgtiny_parse_path(dom_element *path,
 		/* closepath (Z, z) (no arguments) */
 		} else if (sscanf(s, " %1[Zz] %n", command, &n) == 1) {
 			/*LOG(("closepath"));*/
+                        ALLOC_PATH_ELEMENTS(1);
+
 			p[i++] = svgtiny_PATH_CLOSE;
 			s += n;
+			last_cubic_x = last_quad_x = last_x = subpath_first_x;
+			last_cubic_y = last_quad_y = last_y = subpath_first_y;
 
 		/* horizontal lineto (H, h) (1 argument) */
 		} else if (sscanf(s, " %1[Hh] %f %n", command, &x, &n) == 2) {
 			/*LOG(("horizontal lineto"));*/
 			do {
+                                ALLOC_PATH_ELEMENTS(3);
+
 				p[i++] = svgtiny_PATH_LINE;
 				if (*command == 'h')
 					x += last_x;
@@ -499,6 +1229,8 @@ svgtiny_code svgtiny_parse_path(dom_element *path,
 		} else if (sscanf(s, " %1[Vv] %f %n", command, &y, &n) == 2) {
 			/*LOG(("vertical lineto"));*/
 			do {
+                                ALLOC_PATH_ELEMENTS(3);
+
 				p[i++] = svgtiny_PATH_LINE;
 				if (*command == 'v')
 					y += last_y;
@@ -506,13 +1238,15 @@ svgtiny_code svgtiny_parse_path(dom_element *path,
 				p[i++] = last_cubic_y = last_quad_y = last_y
 						= y;
 				s += n;
-			} while (sscanf(s, "%f %n", &x, &n) == 1);
+			} while (sscanf(s, "%f %n", &y, &n) == 1);
 
 		/* curveto (C, c) (6 arguments) */
 		} else if (sscanf(s, " %1[Cc] %f %f %f %f %f %f %n", command,
 				&x1, &y1, &x2, &y2, &x, &y, &n) == 7) {
 			/*LOG(("curveto"));*/
 			do {
+                                ALLOC_PATH_ELEMENTS(7);
+
 				p[i++] = svgtiny_PATH_BEZIER;
 				if (*command == 'c') {
 					x1 += last_x;
@@ -537,6 +1271,8 @@ svgtiny_code svgtiny_parse_path(dom_element *path,
 				&x2, &y2, &x, &y, &n) == 5) {
 			/*LOG(("shorthand/smooth curveto"));*/
 			do {
+                                ALLOC_PATH_ELEMENTS(7);
+
 				p[i++] = svgtiny_PATH_BEZIER;
 				x1 = last_x + (last_x - last_cubic_x);
 				y1 = last_y + (last_y - last_cubic_y);
@@ -561,6 +1297,8 @@ svgtiny_code svgtiny_parse_path(dom_element *path,
 				&x1, &y1, &x, &y, &n) == 5) {
 			/*LOG(("quadratic Bezier curveto"));*/
 			do {
+                                ALLOC_PATH_ELEMENTS(7);
+
 				p[i++] = svgtiny_PATH_BEZIER;
 				last_quad_x = x1;
 				last_quad_y = y1;
@@ -586,6 +1324,8 @@ svgtiny_code svgtiny_parse_path(dom_element *path,
 				&x, &y, &n) == 3) {
 			/*LOG(("shorthand/smooth quadratic Bezier curveto"));*/
 			do {
+                                ALLOC_PATH_ELEMENTS(7);
+
 				p[i++] = svgtiny_PATH_BEZIER;
 				x1 = last_x + (last_x - last_quad_x);
 				y1 = last_y + (last_y - last_quad_y);
@@ -612,22 +1352,53 @@ svgtiny_code svgtiny_parse_path(dom_element *path,
 				&rx, &ry, &rotation, &large_arc, &sweep,
 				&x, &y, &n) == 8) {
 			do {
-				p[i++] = svgtiny_PATH_LINE;
+				int bzsegments;
+				double bzpoints[6*4]; /* allow for up to four bezier segments per arc */
+
 				if (*command == 'a') {
 					x += last_x;
 					y += last_y;
 				}
-				p[i++] = last_cubic_x = last_quad_x = last_x
-						= x;
-				p[i++] = last_cubic_y = last_quad_y = last_y
-						= y;
+
+				bzsegments = svgarc_to_bezier(last_x, last_y,
+							      x, y,
+							      rx, ry,
+							      rotation,
+							      large_arc,
+							      sweep,
+							      bzpoints);
+				if (bzsegments == -1) {
+					/* draw a line */
+					ALLOC_PATH_ELEMENTS(3);
+					p[i++] = svgtiny_PATH_LINE;
+					p[i++] = x;
+					p[i++] = y;
+				} else if (bzsegments > 0) {
+					int bzpnt;
+					ALLOC_PATH_ELEMENTS((unsigned int)bzsegments * 7);
+					for (bzpnt = 0;bzpnt < (bzsegments * 6); bzpnt+=6) {
+						p[i++] = svgtiny_PATH_BEZIER;
+						p[i++] = bzpoints[bzpnt];
+						p[i++] = bzpoints[bzpnt+1];
+						p[i++] = bzpoints[bzpnt+2];
+						p[i++] = bzpoints[bzpnt+3];
+						p[i++] = bzpoints[bzpnt+4];
+						p[i++] = bzpoints[bzpnt+5];
+					}
+				}
+				if (bzsegments != 0) {
+					last_cubic_x = last_quad_x = last_x = p[i-2];
+					last_cubic_y = last_quad_y = last_y = p[i-1];
+				}
+
+
 				s += n;
 			} while (sscanf(s, "%f %f %f %f %f %f %f %n",
 				&rx, &ry, &rotation, &large_arc, &sweep,
 				&x, &y, &n) == 7);
 
 		} else {
-			fprintf(stderr, "parse failed at \"%s\"\n", s);
+			/* fprintf(stderr, "parse failed at \"%s\"\n", s); */
 			break;
 		}
 	}
@@ -641,6 +1412,19 @@ svgtiny_code svgtiny_parse_path(dom_element *path,
 		return svgtiny_OK;
 	}
 
+        /* resize path element array to not be over allocated */
+        if (palloc != i) {
+                float *tp;
+
+                /* try the resize, if it fails just continue to use the old
+                 * allocation
+                 */
+                tp = realloc(p, sizeof p[0] * i);
+                if (tp != NULL) {
+                        p = tp;
+                }
+        }
+
 	err = svgtiny_add_path(p, i, &state);
 
 	svgtiny_cleanup_state_local(&state);
@@ -798,7 +1582,7 @@ svgtiny_code svgtiny_parse_circle(dom_element *circle,
 	err = svgtiny_add_path(p, 32, &state);
 
 	svgtiny_cleanup_state_local(&state);
-	
+
 	return err;
 }
 
@@ -911,7 +1695,7 @@ svgtiny_code svgtiny_parse_ellipse(dom_element *ellipse,
 	p[29] = x + rx;
 	p[30] = y;
 	p[31] = svgtiny_PATH_CLOSE;
-	
+
 	err = svgtiny_add_path(p, 32, &state);
 
 	svgtiny_cleanup_state_local(&state);
@@ -1021,14 +1805,14 @@ svgtiny_code svgtiny_parse_poly(dom_element *poly,
 
 	svgtiny_parse_paint_attributes(poly, &state);
 	svgtiny_parse_transform_attributes(poly, &state);
-	
+
 	exc = dom_element_get_attribute(poly, state.interned_points,
 					&points_str);
 	if (exc != DOM_NO_ERR) {
 		svgtiny_cleanup_state_local(&state);
 		return svgtiny_LIBDOM_ERROR;
 	}
-	
+
 	if (points_str == NULL) {
 		state.diagram->error_line = -1; /* poly->line; */
 		state.diagram->error_message =
@@ -1071,7 +1855,7 @@ svgtiny_code svgtiny_parse_poly(dom_element *poly,
 			p[i++] = y;
 			s += n;
                 } else {
-                	break;
+			break;
                 }
         }
         if (polygon)
@@ -1108,12 +1892,9 @@ svgtiny_code svgtiny_parse_text(dom_element *text,
 
 	px = state.ctm.a * x + state.ctm.c * y + state.ctm.e;
 	py = state.ctm.b * x + state.ctm.d * y + state.ctm.f;
-/* 	state.ctm.e = px - state.origin_x; */
-/* 	state.ctm.f = py - state.origin_y; */
+/*	state.ctm.e = px - state.origin_x; */
+/*	state.ctm.f = py - state.origin_y; */
 
-	/*struct css_style style = state.style;
-	style.font_size.value.length.value *= state.ctm.a;*/
-	
         exc = dom_node_get_first_child(text, &child);
 	if (exc != DOM_NO_ERR) {
 		return svgtiny_LIBDOM_ERROR;
@@ -1243,7 +2024,7 @@ static float _svgtiny_parse_length(const char *s, int viewport_size,
 	int num_length = strspn(s, "0123456789+-.");
 	const char *unit = s + num_length;
 	float n = atof((const char *) s);
-	float font_size = 20; /*css_len2px(&state.style.font_size.value.length, 0);*/
+	float font_size = 20;
 
 	UNUSED(state);
 
@@ -1290,16 +2071,32 @@ 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) {
-		svgtiny_parse_color(attr, &state->fill, state);
+		svgtiny_parse_color(attr, &state->fill, &state->fill_grad, state);
 		dom_string_unref(attr);
 	}
 
 	exc = dom_element_get_attribute(node, state->interned_stroke, &attr);
 	if (exc == DOM_NO_ERR && attr != NULL) {
-		svgtiny_parse_color(attr, &state->stroke, state);
+		svgtiny_parse_color(attr, &state->stroke, &state->stroke_grad, state);
 		dom_string_unref(attr);
 	}
 
@@ -1312,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;
@@ -1321,7 +2126,7 @@ void svgtiny_parse_paint_attributes(dom_element *node,
 			while (*s == ' ')
 				s++;
 			value = strndup(s, strcspn(s, "; "));
-			_svgtiny_parse_color(value, &state->fill, state);
+			_svgtiny_parse_color(value, &state->fill, &state->fill_grad, state);
 			free(value);
 		}
 		if ((s = strstr(style, "stroke:"))) {
@@ -1329,7 +2134,7 @@ void svgtiny_parse_paint_attributes(dom_element *node,
 			while (*s == ' ')
 				s++;
 			value = strndup(s, strcspn(s, "; "));
-			_svgtiny_parse_color(value, &state->stroke, state);
+			_svgtiny_parse_color(value, &state->stroke, &state->stroke_grad, state);
 			free(value);
 		}
 		if ((s = strstr(style, "stroke-width:"))) {
@@ -1344,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);
+	}
 }
 
 
@@ -1352,6 +2202,7 @@ void svgtiny_parse_paint_attributes(dom_element *node,
  */
 
 static void _svgtiny_parse_color(const char *s, svgtiny_colour *c,
+		struct svgtiny_parse_state_gradient *grad,
 		struct svgtiny_parse_state *state)
 {
 	unsigned int r, g, b;
@@ -1383,21 +2234,21 @@ static void _svgtiny_parse_color(const char *s, svgtiny_colour *c,
 
 	} else if (5 < len && s[0] == 'u' && s[1] == 'r' && s[2] == 'l' &&
 			s[3] == '(') {
-		if (s[4] == '#') {
+		if (grad == NULL) {
+			*c = svgtiny_RGB(0, 0, 0);
+		} else if (s[4] == '#') {
 			id = strdup(s + 5);
 			if (!id)
 				return;
 			rparen = strchr(id, ')');
 			if (rparen)
 				*rparen = 0;
-			svgtiny_find_gradient(id, state);
+			svgtiny_find_gradient(id, grad, state);
 			free(id);
-			fprintf(stderr, "linear_gradient_stop_count %i\n",
-					state->linear_gradient_stop_count);
-			if (state->linear_gradient_stop_count == 0)
+			if (grad->linear_gradient_stop_count == 0)
 				*c = svgtiny_TRANSPARENT;
-			else if (state->linear_gradient_stop_count == 1)
-				*c = state->gradient_stop[0].color;
+			else if (grad->linear_gradient_stop_count == 1)
+				*c = grad->gradient_stop[0].color;
 			else
 				*c = svgtiny_LINEAR_GRADIENT;
 		}
@@ -1411,11 +2262,12 @@ static void _svgtiny_parse_color(const char *s, svgtiny_colour *c,
 }
 
 void svgtiny_parse_color(dom_string *s, svgtiny_colour *c,
+		struct svgtiny_parse_state_gradient *grad,
 		struct svgtiny_parse_state *state)
 {
-	char *ss = strndup(dom_string_data(s), dom_string_byte_length(s));
-	_svgtiny_parse_color(ss, c, state);
-	free(ss);
+	dom_string_ref(s);
+	_svgtiny_parse_color(dom_string_data(s), c, grad, state);
+	dom_string_unref(s);
 }
 
 /**
@@ -1435,13 +2287,7 @@ void svgtiny_parse_font_attributes(dom_element *node,
 
 	for (attr = node->properties; attr; attr = attr->next) {
 		if (strcmp((const char *) attr->name, "font-size") == 0) {
-			/*if (css_parse_length(
-					(const char *) attr->children->content,
-					&state->style.font_size.value.length,
-					true, true)) {
-				state->style.font_size.size =
-						CSS_FONT_SIZE_LENGTH;
-			}*/
+			/* TODO */
 		}
         }
 #endif
@@ -1460,7 +2306,7 @@ void svgtiny_parse_transform_attributes(dom_element *node,
 	char *transform;
 	dom_string *attr;
 	dom_exception exc;
-	
+
 	exc = dom_element_get_attribute(node, state->interned_transform,
 					&attr);
 	if (exc == DOM_NO_ERR && attr != NULL) {
@@ -1496,23 +2342,24 @@ void svgtiny_parse_transform(char *s, float *ma, float *mb,
 		a = d = 1;
 		b = c = 0;
 		e = f = 0;
-		if (sscanf(s, "matrix (%f %f %f %f %f %f) %n",
-					&a, &b, &c, &d, &e, &f, &n) == 6)
+		n = 0;
+		if ((sscanf(s, " matrix (%f %f %f %f %f %f ) %n",
+                            &a, &b, &c, &d, &e, &f, &n) == 6) && (n > 0))
 			;
-		else if (sscanf(s, "translate (%f %f) %n",
-					&e, &f, &n) == 2)
+		else if ((sscanf(s, " translate (%f %f ) %n",
+                                 &e, &f, &n) == 2) && (n > 0))
 			;
-		else if (sscanf(s, "translate (%f) %n",
-					&e, &n) == 1)
+		else if ((sscanf(s, " translate (%f ) %n",
+                                 &e, &n) == 1) && (n > 0))
 			;
-		else if (sscanf(s, "scale (%f %f) %n",
-					&a, &d, &n) == 2)
+		else if ((sscanf(s, " scale (%f %f ) %n",
+                                 &a, &d, &n) == 2) && (n > 0))
 			;
-		else if (sscanf(s, "scale (%f) %n",
-					&a, &n) == 1)
+		else if ((sscanf(s, " scale (%f ) %n",
+                                 &a, &n) == 1) && (n > 0))
 			d = a;
-		else if (sscanf(s, "rotate (%f %f %f) %n",
-					&angle, &x, &y, &n) == 3) {
+		else if ((sscanf(s, " rotate (%f %f %f ) %n",
+                                 &angle, &x, &y, &n) == 3) && (n > 0)) {
 			angle = angle / 180 * M_PI;
 			a = cos(angle);
 			b = sin(angle);
@@ -1520,19 +2367,19 @@ void svgtiny_parse_transform(char *s, float *ma, float *mb,
 			d = cos(angle);
 			e = -x * cos(angle) + y * sin(angle) + x;
 			f = -x * sin(angle) - y * cos(angle) + y;
-		} else if (sscanf(s, "rotate (%f) %n",
-					&angle, &n) == 1) {
+		} else if ((sscanf(s, " rotate (%f ) %n",
+                                   &angle, &n) == 1) && (n > 0)) {
 			angle = angle / 180 * M_PI;
 			a = cos(angle);
 			b = sin(angle);
 			c = -sin(angle);
 			d = cos(angle);
-		} else if (sscanf(s, "skewX (%f) %n",
-					&angle, &n) == 1) {
+		} else if ((sscanf(s, " skewX (%f ) %n",
+                                   &angle, &n) == 1) && (n > 0)) {
 			angle = angle / 180 * M_PI;
 			c = tan(angle);
-		} else if (sscanf(s, "skewY (%f) %n",
-					&angle, &n) == 1) {
+		} else if ((sscanf(s, " skewY (%f ) %n",
+                                   &angle, &n) == 1) && (n > 0)) {
 			angle = angle / 180 * M_PI;
 			b = tan(angle);
 		} else
@@ -1600,6 +2447,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)
@@ -1663,7 +2512,7 @@ void svgtiny_free(struct svgtiny_diagram *svg)
 		free(svg->shape[i].path);
 		free(svg->shape[i].text);
 	}
-	
+
 	free(svg->shape);
 
 	free(svg);
@@ -1688,4 +2537,3 @@ char *svgtiny_strndup(const char *s, size_t n)
 	return s2;
 }
 #endif
-