#include <dom/dom.h>
#include <dom/bindings/xml/xmlparser.h>
+#include <libcss/libcss.h>
+
#include "svgtiny.h"
#include "svgtiny_internal.h"
#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,
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,
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;
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;
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;
+ }
+
+ /* ...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) \
#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;
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;
/* 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);
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 <svg> or <g> element node.
+ * 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 <svg>, <g>, and <a> element nodes.
*/
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);
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);
+ 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);
+ 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);
+ 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);
+ 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);
+ 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);
+ css_select_results_destroy(svgtiny_parse_styles(poly, &state));
exc = dom_element_get_attribute(poly, state.interned_points,
&points_str);
/* 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;
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);
exc = dom_element_get_attribute(node, state->interned_style, &attr);
if (exc == DOM_NO_ERR && attr != NULL) {
+ /* 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));
const char *s;
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
}
}
+/**
+ * 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);
+ }
+
+ 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 NULL;
+ }
+ 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 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.
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)