svgtiny_code svgtiny_parse_rect(xmlNode *rect,
struct svgtiny_parse_state state)
{
float x, y, width, height;
float *p;
svgtiny_parse_position_attributes(rect, state,
&x, &y, &width, &height);
svgtiny_parse_paint_attributes(rect, &state);
svgtiny_parse_transform_attributes(rect, &state);
p = malloc(13 * sizeof p[0]);
if (!p)
return svgtiny_OUT_OF_MEMORY;
p[0] = svgtiny_PATH_MOVE;
p[1] = x;
p[2] = y;
p[3] = svgtiny_PATH_LINE;
p[4] = x + width;
p[5] = y;
p[6] = svgtiny_PATH_LINE;
p[7] = x + width;
p[8] = y + height;
p[9] = svgtiny_PATH_LINE;
p[10] = x;
p[11] = y + height;
p[12] = svgtiny_PATH_CLOSE;
return svgtiny_add_path(p, 13, &state);
}
svgtiny_code svgtiny_parse_svg(svgInfo &info,Poco::XML::Element *svg,
struct svgtiny_parse_state state, ofPtr<svgNode> currnode){
float x, y, width, height;
Poco::XML::Attr *view_box;
Poco::XML::Element *child;
svgtiny_parse_position_attributes(svg, state, &x, &y, &width, &height);
svgtiny_parse_paint_attributes(svg, &state);
svgtiny_parse_font_attributes(svg, &state);
view_box = svg->getAttributeNode("viewBox");
if (view_box) {
//const char *s = (const char *) view_box->children->content;
const char *s = (const char *) view_box->getValue().c_str();
float min_x, min_y, vwidth, vheight;
if (sscanf(s, "%f,%f,%f,%f",
&min_x, &min_y, &vwidth, &vheight) == 4 ||
sscanf(s, "%f %f %f %f",
&min_x, &min_y, &vwidth, &vheight) == 4) {
state.ctm.a = (float) state.viewport_width / vwidth;
state.ctm.d = (float) state.viewport_height / vheight;
state.ctm.e += -min_x * state.ctm.a;
state.ctm.f += -min_y * state.ctm.d;
}
}
svgtiny_parse_transform_attributes(svg, &state);
// this is how this should work, but it doesn't
//Poco::XML::NodeIterator it(svg, Poco::XML::NodeFilter::SHOW_ELEMENT | Poco::XML::NodeFilter::SHOW_TEXT);
//Poco::XML::Node* pNode = it.nextNode();
//while (pNode)
// Note: this should be using the NodeIterator, but it doesn't seem to work as advertised when using
// a Node as the root for the iterator constructor. Really weird.
Poco::XML::ChildNodesList *cnl = ( Poco::XML::ChildNodesList *) svg->childNodes();
svgtiny_code code = processChildren(info,currnode,cnl,state);
if (code != svgtiny_OK){
return code;
}
return svgtiny_OK;
}
svgtiny_code svgtiny_parse_text(xmlNode *text,
struct svgtiny_parse_state state)
{
float x, y, width, height;
float px, py;
xmlNode *child;
svgtiny_parse_position_attributes(text, state,
&x, &y, &width, &height);
svgtiny_parse_font_attributes(text, &state);
svgtiny_parse_transform_attributes(text, &state);
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; */
/*struct css_style style = state.style;
style.font_size.value.length.value *= state.ctm.a;*/
for (child = text->children; child; child = child->next) {
svgtiny_code code = svgtiny_OK;
if (child->type == XML_TEXT_NODE) {
struct svgtiny_shape *shape = svgtiny_add_shape(&state);
if (!shape)
return svgtiny_OUT_OF_MEMORY;
shape->text = strdup((const char *) child->content);
shape->text_x = px;
shape->text_y = py;
state.diagram->shape_count++;
} else if (child->type == XML_ELEMENT_NODE &&
strcmp((const char *) child->name,
"tspan") == 0) {
code = svgtiny_parse_text(child, state);
}
if (!code != svgtiny_OK)
return code;
}
return svgtiny_OK;
}
svgtiny_code svgtiny_parse_rect(dom_element *rect,
struct svgtiny_parse_state state)
{
svgtiny_code err;
float x, y, width, height;
float *p;
svgtiny_setup_state_local(&state);
svgtiny_parse_position_attributes(rect, state,
&x, &y, &width, &height);
svgtiny_parse_paint_attributes(rect, &state);
svgtiny_parse_transform_attributes(rect, &state);
p = malloc(13 * sizeof p[0]);
if (!p) {
svgtiny_cleanup_state_local(&state);
return svgtiny_OUT_OF_MEMORY;
}
p[0] = svgtiny_PATH_MOVE;
p[1] = x;
p[2] = y;
p[3] = svgtiny_PATH_LINE;
p[4] = x + width;
p[5] = y;
p[6] = svgtiny_PATH_LINE;
p[7] = x + width;
p[8] = y + height;
p[9] = svgtiny_PATH_LINE;
p[10] = x;
p[11] = y + height;
p[12] = svgtiny_PATH_CLOSE;
err = svgtiny_add_path(p, 13, &state);
svgtiny_cleanup_state_local(&state);
return err;
}
svgtiny_code svgtiny_parse_svg(dom_element *svg,
struct svgtiny_parse_state state)
{
float x, y, width, height;
dom_string *view_box;
dom_element *child;
dom_exception exc;
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);
exc = dom_element_get_attribute(svg, state.interned_viewBox,
&view_box);
if (exc != DOM_NO_ERR) {
svgtiny_cleanup_state_local(&state);
return svgtiny_LIBDOM_ERROR;
}
if (view_box) {
char *s = strndup(dom_string_data(view_box),
dom_string_byte_length(view_box));
float min_x, min_y, vwidth, vheight;
if (sscanf(s, "%f,%f,%f,%f",
&min_x, &min_y, &vwidth, &vheight) == 4 ||
sscanf(s, "%f %f %f %f",
&min_x, &min_y, &vwidth, &vheight) == 4) {
state.ctm.a = (float) state.viewport_width / vwidth;
state.ctm.d = (float) state.viewport_height / vheight;
state.ctm.e += -min_x * state.ctm.a;
state.ctm.f += -min_y * state.ctm.d;
}
free(s);
dom_string_unref(view_box);
}
svgtiny_parse_transform_attributes(svg, &state);
exc = dom_node_get_first_child(svg, (dom_node **) (void *) &child);
if (exc != DOM_NO_ERR) {
svgtiny_cleanup_state_local(&state);
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);
svgtiny_cleanup_state_local(&state);
return svgtiny_LIBDOM_ERROR;
}
if (dom_string_caseless_isequal(state.interned_svg,
nodename))
code = svgtiny_parse_svg(child, state);
else if (dom_string_caseless_isequal(state.interned_g,
nodename))
code = svgtiny_parse_svg(child, state);
else if (dom_string_caseless_isequal(state.interned_a,
nodename))
code = svgtiny_parse_svg(child, state);
else if (dom_string_caseless_isequal(state.interned_path,
nodename))
code = svgtiny_parse_path(child, state);
else if (dom_string_caseless_isequal(state.interned_rect,
nodename))
code = svgtiny_parse_rect(child, state);
else if (dom_string_caseless_isequal(state.interned_circle,
nodename))
code = svgtiny_parse_circle(child, state);
else if (dom_string_caseless_isequal(state.interned_ellipse,
nodename))
code = svgtiny_parse_ellipse(child, state);
else if (dom_string_caseless_isequal(state.interned_line,
nodename))
code = svgtiny_parse_line(child, state);
else if (dom_string_caseless_isequal(state.interned_polyline,
nodename))
code = svgtiny_parse_poly(child, state, false);
else if (dom_string_caseless_isequal(state.interned_polygon,
nodename))
code = svgtiny_parse_poly(child, state, true);
else if (dom_string_caseless_isequal(state.interned_text,
nodename))
code = svgtiny_parse_text(child, state);
dom_string_unref(nodename);
}
if (code != svgtiny_OK) {
dom_node_unref(child);
svgtiny_cleanup_state_local(&state);
return code;
}
exc = dom_node_get_next_sibling(child,
(dom_node **) (void *) &next);
dom_node_unref(child);
if (exc != DOM_NO_ERR) {
svgtiny_cleanup_state_local(&state);
return svgtiny_LIBDOM_ERROR;
}
child = next;
}
svgtiny_cleanup_state_local(&state);
return svgtiny_OK;
}
svgtiny_code svgtiny_parse_svg_from_dom(struct svgtiny_diagram *diagram,
dom_document *document, int viewport_width, int viewport_height)
{
dom_element *svg;
dom_exception exc;
svgtiny_code code;
exc = dom_document_get_document_element(document, &svg);
if (exc != DOM_NO_ERR) {
dom_node_unref(document);
return svgtiny_LIBDOM_ERROR;
}
struct svgtiny_parse_state state;
float x, y, width, height;
assert(diagram);
state.gradient_x1 = NULL;
state.gradient_y1 = NULL;
state.gradient_x2 = NULL;
state.gradient_y2 = NULL;
/* get graphic dimensions */
memset(&state, 0, sizeof(state));
state.diagram = diagram;
state.document = document;
state.viewport_width = viewport_width;
state.viewport_height = viewport_height;
#define SVGTINY_STRING_ACTION2(s,n) \
if (dom_string_create_interned((const uint8_t *) #n, \
strlen(#n), &state.interned_##s) \
!= DOM_NO_ERR) { \
code = svgtiny_LIBDOM_ERROR; \
goto cleanup; \
}
#include "svgtiny_strings.h"
#undef SVGTINY_STRING_ACTION2
svgtiny_parse_position_attributes(svg, state, &x, &y, &width, &height);
diagram->width = width;
diagram->height = height;
/* set up parsing state */
state.viewport_width = width;
state.viewport_height = height;
state.ctm.a = 1; /*(float) viewport_width / (float) width;*/
state.ctm.b = 0;
state.ctm.c = 0;
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);
dom_node_unref(svg);
cleanup:
svgtiny_cleanup_state_local(&state);
#define SVGTINY_STRING_ACTION2(s,n) \
if (state.interned_##s != NULL) \
dom_string_unref(state.interned_##s);
#include "svgtiny_strings.h"
#undef SVGTINY_STRING_ACTION2
return code;
}
svgtiny_code svgtiny_parse_text(dom_element *text,
struct svgtiny_parse_state state)
{
float x, y, width, height;
float px, py;
dom_node *child;
dom_exception exc;
svgtiny_setup_state_local(&state);
svgtiny_parse_position_attributes(text, state,
&x, &y, &width, &height);
svgtiny_parse_font_attributes(text, &state);
svgtiny_parse_transform_attributes(text, &state);
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; */
/*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;
svgtiny_cleanup_state_local(&state);
}
while (child != NULL) {
dom_node *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);
svgtiny_cleanup_state_local(&state);
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);
svgtiny_cleanup_state_local(&state);
return svgtiny_LIBDOM_ERROR;
}
if (dom_string_caseless_isequal(nodename,
state.interned_tspan))
code = svgtiny_parse_text((dom_element *)child,
state);
dom_string_unref(nodename);
} else if (nodetype == DOM_TEXT_NODE) {
struct svgtiny_shape *shape = svgtiny_add_shape(&state);
dom_string *content;
if (shape == NULL) {
dom_node_unref(child);
svgtiny_cleanup_state_local(&state);
return svgtiny_OUT_OF_MEMORY;
}
exc = dom_text_get_whole_text(child, &content);
if (exc != DOM_NO_ERR) {
dom_node_unref(child);
svgtiny_cleanup_state_local(&state);
return svgtiny_LIBDOM_ERROR;
}
if (content != NULL) {
shape->text = strndup(dom_string_data(content),
dom_string_byte_length(content));
dom_string_unref(content);
} else {
shape->text = strdup("");
}
shape->text_x = px;
shape->text_y = py;
state.diagram->shape_count++;
}
if (code != svgtiny_OK) {
dom_node_unref(child);
svgtiny_cleanup_state_local(&state);
return code;
}
exc = dom_node_get_next_sibling(child, &next);
dom_node_unref(child);
if (exc != DOM_NO_ERR) {
svgtiny_cleanup_state_local(&state);
return svgtiny_LIBDOM_ERROR;
}
child = next;
}
svgtiny_cleanup_state_local(&state);
return svgtiny_OK;
}
svgtiny_code svgtiny_parse(struct svgtiny_diagram *diagram,
const char *buffer, size_t size, const char *url,
int viewport_width, int viewport_height)
{
xmlDoc *document;
xmlNode *svg;
struct svgtiny_parse_state state;
float x, y, width, height;
svgtiny_code code;
assert(diagram);
assert(buffer);
assert(url);
/* parse XML to tree */
document = xmlReadMemory(buffer, size, url, 0,
XML_PARSE_NONET | XML_PARSE_COMPACT);
if (!document)
return svgtiny_LIBXML_ERROR;
/*xmlDebugDumpDocument(stderr, document);*/
/* find root <svg> element */
svg = xmlDocGetRootElement(document);
if (!svg)
return svgtiny_NOT_SVG;
if (strcmp((const char *) svg->name, "svg") != 0)
return svgtiny_NOT_SVG;
/* get graphic dimensions */
state.diagram = diagram;
state.document = document;
state.viewport_width = viewport_width;
state.viewport_height = viewport_height;
svgtiny_parse_position_attributes(svg, state, &x, &y, &width, &height);
diagram->width = width;
diagram->height = height;
/* set up parsing state */
state.viewport_width = width;
state.viewport_height = height;
state.ctm.a = 1; /*(float) viewport_width / (float) width;*/
state.ctm.b = 0;
state.ctm.c = 0;
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);
/* free XML tree */
xmlFreeDoc(document);
return code;
}
svgtiny_code svgtiny_parse_svg(xmlNode *svg,
struct svgtiny_parse_state state)
{
float x, y, width, height;
xmlAttr *view_box;
xmlNode *child;
svgtiny_parse_position_attributes(svg, state, &x, &y, &width, &height);
svgtiny_parse_paint_attributes(svg, &state);
svgtiny_parse_font_attributes(svg, &state);
/* parse viewBox */
view_box = xmlHasProp(svg, (const xmlChar *) "viewBox");
if (view_box) {
const char *s = (const char *) view_box->children->content;
float min_x, min_y, vwidth, vheight;
if (sscanf(s, "%f,%f,%f,%f",
&min_x, &min_y, &vwidth, &vheight) == 4 ||
sscanf(s, "%f %f %f %f",
&min_x, &min_y, &vwidth, &vheight) == 4) {
state.ctm.a = (float) state.viewport_width / vwidth;
state.ctm.d = (float) state.viewport_height / vheight;
state.ctm.e += -min_x * state.ctm.a;
state.ctm.f += -min_y * state.ctm.d;
}
}
svgtiny_parse_transform_attributes(svg, &state);
for (child = svg->children; child; child = child->next) {
svgtiny_code code = svgtiny_OK;
if (child->type == XML_ELEMENT_NODE) {
const char *name = (const char *) child->name;
if (strcmp(name, "svg") == 0)
code = svgtiny_parse_svg(child, state);
else if (strcmp(name, "g") == 0)
code = svgtiny_parse_svg(child, state);
else if (strcmp(name, "a") == 0)
code = svgtiny_parse_svg(child, state);
else if (strcmp(name, "path") == 0)
code = svgtiny_parse_path(child, state);
else if (strcmp(name, "rect") == 0)
code = svgtiny_parse_rect(child, state);
else if (strcmp(name, "circle") == 0)
code = svgtiny_parse_circle(child, state);
else if (strcmp(name, "ellipse") == 0)
code = svgtiny_parse_ellipse(child, state);
else if (strcmp(name, "line") == 0)
code = svgtiny_parse_line(child, state);
else if (strcmp(name, "polyline") == 0)
code = svgtiny_parse_poly(child, state, false);
else if (strcmp(name, "polygon") == 0)
code = svgtiny_parse_poly(child, state, true);
else if (strcmp(name, "text") == 0)
code = svgtiny_parse_text(child, state);
}
if (code != svgtiny_OK)
return code;
}
return svgtiny_OK;
}
svgtiny_code svgtiny_parse(svgInfo &info,struct svgtiny_diagram *diagram, const char *buffer,int viewport_width, int viewport_height){
Poco::XML::Document *document;
Poco::XML::Element *svg;
struct svgtiny_parse_state state;
float x, y, width, height;
svgtiny_code code;
assert(diagram);
assert(buffer);
string rawXMLstring(buffer);
//info.rawXML = rawXMLstring;
//parser is statically allocated
Poco::XML::DOMParser parser;
/*
Why does this upset the internal SVG parser?
*/
//parser.setFeature(Poco::XML::XMLReader::FEATURE_NAMESPACES, false);
document = parser.parseString(rawXMLstring);
svg = document->documentElement();
//std::cout << svg->localName() << std::endl;
if (!svg){
code = svgtiny_NOT_SVG;
return code;
}else if(svg->localName().compare("svg") != 0){
code= svgtiny_NOT_SVG;
return code;
}else{
/* get graphic dimensions */
state.diagram = diagram;
state.document = document;
state.viewport_width = viewport_width;
state.viewport_height = viewport_height;
svgtiny_parse_position_attributes(svg, state, &x, &y, &width, &height);
diagram->width = width;
diagram->height = height;
/* set up parsing state */
state.viewport_width = width;
state.viewport_height = height;
state.ctm.a = 1; /*(float) viewport_width / (float) width;*/
state.ctm.b = 0;
state.ctm.c = 0;
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;
//borg
state.info = &info;
/* parse tree */
ofPtr<svgNode> rootnode(new svgNode());
rootnode->type = SVG_TAG_TYPE_DOCUMENT;
info.rootnode = rootnode;
//store root svg info
info.width = ofToString(svg->getAttribute("width").c_str());
info.height = ofToString(svg->getAttribute("height").c_str());
info.x = ofToString(svg->getAttribute("x").c_str());
info.y = ofToString(svg->getAttribute("y").c_str());
info.viewbox = ofToString(svg->getAttribute("viewBox").c_str());
info.id = ofToString(svg->getAttribute("id").c_str());
info.xmlns = ofToString(svg->getAttribute("xmlns").c_str());
info.version = ofToString(svg->getAttribute("version").c_str());
info.preserveAspectRatio = ofToString(svg->getAttribute("preserveAspectRatio").c_str());
code = svgtiny_parse_svg(info,svg, state,rootnode);
}
/* free XML tree */
//xmlFreeDoc(document);
//return without namespace
//parser.setFeature(Poco::XML::XMLReader::FEATURE_NAMESPACES, false);
//document = parser.parseString(rawXMLstring);
return code;
}
svgtiny_code svgtiny_parse_text(Poco::XML::Element *text,
struct svgtiny_parse_state state)
{
float x, y, width, height;
float px, py;
Poco::XML::Element *child;
svgtiny_parse_position_attributes(text, state,
&x, &y, &width, &height);
svgtiny_parse_font_attributes(text, &state);
svgtiny_parse_transform_attributes(text, &state);
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; */
/*struct css_style style = state.style;
style.font_size.value.length.value *= state.ctm.a;*/
//for (child = text->children; child; child = child->next) {
//for( child = (Poco::XML::Element*) text->FirstChild( false ); child; child = (Poco::XML::Element*) child->NextSibling( false ) ) {
Poco::XML::NodeIterator it(text, Poco::XML::NodeFilter::SHOW_ELEMENT | Poco::XML::NodeFilter::SHOW_TEXT);
Poco::XML::Node* pNode = it.nextNode();
while (pNode) {
svgtiny_code code = svgtiny_OK;
if (pNode->getNodeValue().compare("text") == 0)
{
struct svgtiny_shape *shape = svgtiny_add_shape(&state);
if (!shape)
return svgtiny_OUT_OF_MEMORY;
//shape->text = strdup((const char *) child->content);
shape->text = strdup((const char *) pNode->getNodeValue().c_str());
shape->text_x = px;
shape->text_y = py;
state.diagram->shape_count++;
}
//else if (strcmp((const char *) child->Value(), "tspan") == 0)
else if (pNode->getNodeValue().compare("tspan") == 0)
{
code = svgtiny_parse_text(child, state);
}
pNode = it.nextNode();
if (!code != svgtiny_OK)
return code;
}
return svgtiny_OK;
}
svgtiny_code svgtiny_parse(struct svgtiny_diagram *diagram,
const char *buffer, size_t size, const char *url,
int viewport_width, int viewport_height)
{
dom_document *document;
dom_exception exc;
dom_xml_parser *parser;
dom_xml_error err;
dom_element *svg;
dom_string *svg_name;
lwc_string *svg_name_lwc;
struct svgtiny_parse_state state;
float x, y, width, height;
svgtiny_code code;
assert(diagram);
assert(buffer);
assert(url);
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);
if (parser == NULL)
return svgtiny_LIBDOM_ERROR;
err = dom_xml_parser_parse_chunk(parser, (uint8_t *)buffer, size);
if (err != DOM_XML_OK) {
dom_node_unref(document);
dom_xml_parser_destroy(parser);
return svgtiny_LIBDOM_ERROR;
}
err = dom_xml_parser_completed(parser);
if (err != DOM_XML_OK) {
dom_node_unref(document);
dom_xml_parser_destroy(parser);
return svgtiny_LIBDOM_ERROR;
}
/* We're done parsing, drop the parser.
* We now own the document entirely.
*/
dom_xml_parser_destroy(parser);
/* find root <svg> element */
exc = dom_document_get_document_element(document, &svg);
if (exc != DOM_NO_ERR) {
dom_node_unref(document);
return svgtiny_LIBDOM_ERROR;
}
exc = dom_node_get_node_name(svg, &svg_name);
if (exc != DOM_NO_ERR) {
dom_node_unref(svg);
dom_node_unref(document);
return svgtiny_LIBDOM_ERROR;
}
if (lwc_intern_string("svg", 3 /* SLEN("svg") */,
&svg_name_lwc) != lwc_error_ok) {
dom_string_unref(svg_name);
dom_node_unref(svg);
dom_node_unref(document);
return svgtiny_LIBDOM_ERROR;
}
if (!dom_string_caseless_lwc_isequal(svg_name, svg_name_lwc)) {
lwc_string_unref(svg_name_lwc);
dom_string_unref(svg_name);
dom_node_unref(svg);
dom_node_unref(document);
return svgtiny_NOT_SVG;
}
lwc_string_unref(svg_name_lwc);
dom_string_unref(svg_name);
/* get graphic dimensions */
memset(&state, 0, sizeof(state));
state.diagram = diagram;
state.document = document;
state.viewport_width = viewport_width;
state.viewport_height = viewport_height;
#define SVGTINY_STRING_ACTION2(s,n) \
if (dom_string_create_interned((const uint8_t *) #n, \
strlen(#n), &state.interned_##s) \
!= DOM_NO_ERR) { \
code = svgtiny_LIBDOM_ERROR; \
goto cleanup; \
}
#include "svgtiny_strings.h"
#undef SVGTINY_STRING_ACTION2
svgtiny_parse_position_attributes(svg, state, &x, &y, &width, &height);
diagram->width = width;
diagram->height = height;
/* set up parsing state */
state.viewport_width = width;
state.viewport_height = height;
state.ctm.a = 1; /*(float) viewport_width / (float) width;*/
state.ctm.b = 0;
state.ctm.c = 0;
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);
dom_node_unref(svg);
dom_node_unref(document);
cleanup:
svgtiny_cleanup_state_local(&state);
#define SVGTINY_STRING_ACTION2(s,n) \
if (state.interned_##s != NULL) \
dom_string_unref(state.interned_##s);
#include "svgtiny_strings.h"
#undef SVGTINY_STRING_ACTION2
return code;
}
