#include <string.h></string.h>

#include <stdlib.h></stdlib.h>

#include <math.h></math.h>

#include <qtextstream></qtextstream>

#include <qfile></qfile>

#include "tiio_svg.h"

#include "tvectorimage.h"

#include "tstroke.h"

#include "tstrokeoutline.h"

#include "tregion.h"

#include "tcurves.h"

#include "tpalette.h"

//=------------------------------------------------------------------------------------------------------------------------------

//=------------------------------------------------------------------------------------------------------------------------------

//=------------------------------------------------------------------------------------------------------------------------------

//=------------------------------------------------------------------------------------------------------------------------------

namespace //svg_parser

{

struct NSVGpath {

	float *pts;			   // Cubic bezier points: x0,y0, [cpx1,cpx1,cpx2,cpy2,x1,y1], ...

	int npts;			   // Total number of bezier points.

	char closed;		   // Flag indicating if shapes should be treated as closed.

	struct NSVGpath *next; // Pointer to next path, or NULL if last element.

};

struct NSVGshape {

	unsigned int fillColor;   // Fill color

	unsigned int strokeColor; // Stroke color

	float strokeWidth;		  // Stroke width (scaled)

	char hasFill;			  // Flag indicating if fill exists.

	char hasStroke;			  // Flag indicating id store exists

	struct NSVGpath *paths;   // Linked list of paths in the image.

	struct NSVGshape *next;   // Pointer to next shape, or NULL if last element.

};

struct NSVGimage {

	float width;			  // Width of the image, or -1.0f of not set.

	float height;			  // Height of the image, or -1.0f of not set.

	char wunits[8];			  // Units of the width attribute

	char hunits[8];			  // Units of the height attribute

	struct NSVGshape *shapes; // Linked list of shapes in the image.

};

#define NSVG_PI 3.14159265358979323846264338327f

#define NSVG_KAPPA90 0.5522847493f // Lenght proportional to radius of a cubic bezier handle for 90deg arcs.

#ifdef _MSC_VER

#pragma warning(disable : 4996) // Switch off security warnings

#pragma warning(disable : 4100) // Switch off unreferenced formal parameter warnings

#ifdef __cplusplus

#define NSVG_INLINE inline

#else

#define NSVG_INLINE

#endif

#else

#define NSVG_INLINE inline

#endif

int nsvg__isspace(char c)

{

	return strchr(" \t\n\v\f\r", c) != 0;

}

int nsvg__isdigit(char c)

{

	return strchr("0123456789", c) != 0;

}

int nsvg__isnum(char c)

{

	return strchr("0123456789+-.eE", c) != 0;

}

NSVG_INLINE float nsvg__maxf(float a, float b) { return a > b ? a : b; }

// Simple XML parser

#define NSVG_XML_TAG 1

#define NSVG_XML_CONTENT 2

#define NSVG_XML_MAX_ATTRIBS 256

void nsvg__parseContent(char *s,

						void (*contentCb)(void *ud, const char *s),

						void *ud)

{

	// Trim start white spaces

	while (*s && nsvg__isspace(*s))

		s++;

	if (!*s)

		return;

	if (contentCb)

		(*contentCb)(ud, s);

}

void nsvg__parseElement(char *s,

						void (*startelCb)(void *ud, const char *el, const char **attr),

						void (*endelCb)(void *ud, const char *el),

						void *ud)

{

	const char *attr[NSVG_XML_MAX_ATTRIBS];

	int nattr = 0;

	char *name;

	int start = 0;

	int end = 0;

	// Skip white space after the '<'

	while (*s && nsvg__isspace(*s))

		s++;

	// Check if the tag is end tag

	if (*s == '/') {

		s++;

		end = 1;

	} else {

		start = 1;

	}

	// Skip comments, data and preprocessor stuff.

	if (!*s || *s == '?' || *s == '!')

		return;

	// Get tag name

	name = s;

	while (*s && !nsvg__isspace(*s))

		s++;

	if (*s) {

		*s++ = '\0';

	}

	// Get attribs

	while (!end && *s && nattr < NSVG_XML_MAX_ATTRIBS - 3) {

		// Skip white space before the attrib name

		while (*s && nsvg__isspace(*s))

			s++;

		if (!*s)

			break;

		if (*s == '/') {

			end = 1;

			break;

		}

		attr[nattr++] = s;

		// Find end of the attrib name.

		while (*s && !nsvg__isspace(*s) && *s != '=')

			s++;

		if (*s) {

			*s++ = '\0';

		}

		// Skip until the beginning of the value.

		while (*s && *s != '\"')

			s++;

		if (!*s)

			break;

		s++;

		// Store value and find the end of it.

		attr[nattr++] = s;

		while (*s && *s != '\"')

			s++;

		if (*s) {

			*s++ = '\0';

		}

	}

	// List terminator

	attr[nattr++] = 0;

	attr[nattr++] = 0;

	// Call callbacks.

	if (start && startelCb)

		(*startelCb)(ud, name, attr);

	if (end && endelCb)

		(*endelCb)(ud, name);

}

int nsvg__parseXML(char *input,

				   void (*startelCb)(void *ud, const char *el, const char **attr),

				   void (*endelCb)(void *ud, const char *el),

				   void (*contentCb)(void *ud, const char *s),

				   void *ud)

{

	char *s = input;

	char *mark = s;

	int state = NSVG_XML_CONTENT;

	while (*s) {

		if (*s == '<' && state == NSVG_XML_CONTENT) {

			// Start of a tag

			*s++ = '\0';

			nsvg__parseContent(mark, contentCb, ud);

			mark = s;

			state = NSVG_XML_TAG;

		} else if (*s == '>' && state == NSVG_XML_TAG) {

			// Start of a content or new tag.

			*s++ = '\0';

			nsvg__parseElement(mark, startelCb, endelCb, ud);

			mark = s;

			state = NSVG_XML_CONTENT;

		} else {

			s++;

		}

	}

	return 1;

}

/* Simple SVG parser. */

#define NSVG_MAX_ATTR 128

struct NSVGAttrib {

	float xform[6];

	unsigned int fillColor;

	unsigned int strokeColor;

	float fillOpacity;

	float strokeOpacity;

	float strokeWidth;

	char hasFill;

	char hasStroke;

	char visible;

};

struct NSVGParser {

	struct NSVGAttrib attr[NSVG_MAX_ATTR];

	int attrHead;

	float *pts;

	int npts;

	int cpts;

	struct NSVGpath *plist;

	struct NSVGimage *image;

	char pathFlag;

	char defsFlag;

};

void nsvg__xformSetIdentity(float *t)

{

	t[0] = 1.0f;

	t[1] = 0.0f;

	t[2] = 0.0f;

	t[3] = 1.0f;

	t[4] = 0.0f;

	t[5] = 0.0f;

}

void nsvg__xformSetTranslation(float *t, float tx, float ty)

{

	t[0] = 1.0f;

	t[1] = 0.0f;

	t[2] = 0.0f;

	t[3] = 1.0f;

	t[4] = tx;

	t[5] = ty;

}

void nsvg__xformSetScale(float *t, float sx, float sy)

{

	t[0] = sx;

	t[1] = 0.0f;

	t[2] = 0.0f;

	t[3] = sy;

	t[4] = 0.0f;

	t[5] = 0.0f;

}

void nsvg__xformSetSkewX(float *t, float a)

{

	t[0] = 1.0f;

	t[1] = 0.0f;

	t[2] = tanf(a);

	t[3] = 1.0f;

	t[4] = 0.0f;

	t[5] = 0.0f;

}

void nsvg__xformSetSkewY(float *t, float a)

{

	t[0] = 1.0f;

	t[1] = tanf(a);

	t[2] = 0.0f;

	t[3] = 1.0f;

	t[4] = 0.0f;

	t[5] = 0.0f;

}

void nsvg__xformSetRotation(float *t, float a)

{

	float cs = cosf(a), sn = sinf(a);

	t[0] = cs;

	t[1] = sn;

	t[2] = -sn;

	t[3] = cs;

	t[4] = 0.0f;

	t[5] = 0.0f;

}

void nsvg__xformMultiply(float *t, float *s)

{

	float t0 = t[0] * s[0] + t[1] * s[2];

	float t2 = t[2] * s[0] + t[3] * s[2];

	float t4 = t[4] * s[0] + t[5] * s[2] + s[4];

	t[1] = t[0] * s[1] + t[1] * s[3];

	t[3] = t[2] * s[1] + t[3] * s[3];

	t[5] = t[4] * s[1] + t[5] * s[3] + s[5];

	t[0] = t0;

	t[2] = t2;

	t[4] = t4;

}

void nsvg__xformPremultiply(float *t, float *s)

{

	float s2[6];

	memcpy(s2, s, sizeof(float) * 6);

	nsvg__xformMultiply(s2, t);

	memcpy(t, s2, sizeof(float) * 6);

}

void nsvg__xformPoint(float *dx, float *dy, float x, float y, float *t)

{

	*dx = x * t[0] + y * t[2] + t[4];

	*dy = x * t[1] + y * t[3] + t[5];

}

void nsvg__xformVec(float *dx, float *dy, float x, float y, float *t)

{

	*dx = x * t[0] + y * t[2];

	*dy = x * t[1] + y * t[3];

}

struct NSVGParser *nsvg__createParser()

{

	struct NSVGParser *p;

	p = (struct NSVGParser *)malloc(sizeof(struct NSVGParser));

	if (p == NULL)

		goto error;

	memset(p, 0, sizeof(struct NSVGParser));

	p->image = (struct NSVGimage *)malloc(sizeof(struct NSVGimage));

	if (p->image == NULL)

		goto error;

	memset(p->image, 0, sizeof(struct NSVGimage));

	p->image->width = -1.0f;

	p->image->height = -1.0f;

	// Init style

	nsvg__xformSetIdentity(p->attr[0].xform);

	p->attr[0].fillColor = 0;

	p->attr[0].strokeColor = 0;

	p->attr[0].fillOpacity = 1;

	p->attr[0].strokeOpacity = 1;

	p->attr[0].strokeWidth = 1;

	p->attr[0].hasFill = 0;

	p->attr[0].hasStroke = 0;

	p->attr[0].visible = 1;

	return p;

error:

	if (p) {

		if (p->image)

			free(p->image);

		free(p);

	}

	return NULL;

}

void nsvg__deletePaths(struct NSVGpath *path)

{

	while (path) {

		struct NSVGpath *next = path->next;

		if (path->pts != NULL)

			free(path->pts);

		free(path);

		path = next;

	}

}

void nsvgDelete(struct NSVGimage *image)

{

	struct NSVGshape *next, *shape;

	if (image == NULL)

		return;

	shape = image->shapes;

	while (shape != NULL) {

		next = shape->next;

		nsvg__deletePaths(shape->paths);

		free(shape);

		shape = next;

	}

	free(image);

}

void nsvg__deleteParser(struct NSVGParser *p)

{

	if (p != NULL) {

		nsvg__deletePaths(p->plist);

		nsvgDelete(p->image);

		free(p->pts);

		free(p);

	}

}

void nsvg__resetPath(struct NSVGParser *p)

{

	p->npts = 0;

}

void nsvg__addPoint(struct NSVGParser *p, float x, float y)

{

	if (p->npts + 1 > p->cpts) {

		p->cpts = p->cpts ? p->cpts * 2 : 8;

		p->pts = (float *)realloc(p->pts, p->cpts * 2 * sizeof(float));

		if (!p->pts)

			return;

	}

	p->pts[p->npts * 2 + 0] = x;

	p->pts[p->npts * 2 + 1] = y;

	p->npts++;

}

void nsvg__moveTo(struct NSVGParser *p, float x, float y)

{

	nsvg__addPoint(p, x, y);

}

void nsvg__lineTo(struct NSVGParser *p, float x, float y)

{

	float px, py, dx, dy;

	if (p->npts > 0) {

		px = p->pts[(p->npts - 1) * 2 + 0];

		py = p->pts[(p->npts - 1) * 2 + 1];

		dx = x - px;

		dy = y - py;

		nsvg__addPoint(p, px + dx / 3.0f, py + dy / 3.0f);

		nsvg__addPoint(p, x - dx / 3.0f, y - dy / 3.0f);

		nsvg__addPoint(p, x, y);

	}

}

void nsvg__cubicBezTo(struct NSVGParser *p, float cpx1, float cpy1, float cpx2, float cpy2, float x, float y)

{

	nsvg__addPoint(p, cpx1, cpy1);

	nsvg__addPoint(p, cpx2, cpy2);

	nsvg__addPoint(p, x, y);

}

struct NSVGAttrib *nsvg__getAttr(struct NSVGParser *p)

{

	return &p->attr[p->attrHead];

}

void nsvg__pushAttr(struct NSVGParser *p)

{

	if (p->attrHead < NSVG_MAX_ATTR - 1) {

		p->attrHead++;

		memcpy(&p->attr[p->attrHead], &p->attr[p->attrHead - 1], sizeof(struct NSVGAttrib));

	}

}

void nsvg__popAttr(struct NSVGParser *p)

{

	if (p->attrHead > 0)

		p->attrHead--;

}

void nsvg__addShape(struct NSVGParser *p)

{

	struct NSVGAttrib *attr = nsvg__getAttr(p);

	float scale = 1.0f;

	struct NSVGshape *shape, *cur, *prev;

	if (p->plist == NULL)

		return;

	shape = (struct NSVGshape *)malloc(sizeof(struct NSVGshape));

	if (shape == NULL)

		goto error;

	memset(shape, 0, sizeof(struct NSVGshape));

	scale = nsvg__maxf(fabsf(attr->xform[0]), fabsf(attr->xform[3]));

	shape->hasFill = attr->hasFill;

	shape->hasStroke = attr->hasStroke;

	shape->strokeWidth = attr->strokeWidth * scale;

	shape->fillColor = attr->fillColor;

	if (shape->hasFill)

		shape->fillColor |= (unsigned int)(attr->fillOpacity * 255) << 24;

	shape->strokeColor = attr->strokeColor;

	if (shape->hasStroke)

		shape->strokeColor |= (unsigned int)(attr->strokeOpacity * 255) << 24;

	shape->paths = p->plist;

	p->plist = NULL;

	// Add to tail

	prev = NULL;

	cur = p->image->shapes;

	while (cur != NULL) {

		prev = cur;

		cur = cur->next;

	}

	if (prev == NULL)

		p->image->shapes = shape;

	else

		prev->next = shape;

	return;

error:

	if (shape)

		free(shape);

}

void nsvg__addPath(struct NSVGParser *p, char closed)

{

	struct NSVGAttrib *attr = nsvg__getAttr(p);

	struct NSVGpath *path = NULL;

	int i;

	if (p->npts == 0)

		return;

	if (closed)

		nsvg__lineTo(p, p->pts[0], p->pts[1]);

	path = (struct NSVGpath *)malloc(sizeof(struct NSVGpath));

	if (path == NULL)

		goto error;

	memset(path, 0, sizeof(struct NSVGpath));

	path->pts = (float *)malloc(p->npts * 2 * sizeof(float));

	if (path->pts == NULL)

		goto error;

	path->closed = closed;

	path->npts = p->npts;

	// Transform path.

	for (i = 0; i < p->npts; ++i)

		nsvg__xformPoint(&path->pts[i * 2], &path->pts[i * 2 + 1], p->pts[i * 2], p->pts[i * 2 + 1], attr->xform);

	path->next = p->plist;

	p->plist = path;

	return;

error:

	if (path != NULL) {

		if (path->pts != NULL)

			free(path->pts);

		free(path);

	}

}

const char *nsvg__getNextPathItem(const char *s, char *it)

{

	int i = 0;

	it[0] = '\0';

	// Skip white spaces and commas

	while (*s && (nsvg__isspace(*s) || *s == ','))

		s++;

	if (!*s)

		return s;

	if (*s == '-' || *s == '+' || nsvg__isdigit(*s)) {

		// sign

		if (*s == '-' || *s == '+') {

			if (i < 63)

				it[i++] = *s;

			s++;

		}

		// integer part

		while (*s && nsvg__isdigit(*s)) {

			if (i < 63)

				it[i++] = *s;

			s++;

		}

		if (*s == '.') {

			// decimal point

			if (i < 63)

				it[i++] = *s;

			s++;

			// fraction part

			while (*s && nsvg__isdigit(*s)) {

				if (i < 63)

					it[i++] = *s;

				s++;

			}

		}

		// exponent

		if (*s == 'e' || *s == 'E') {

			if (i < 63)

				it[i++] = *s;

			s++;

			if (*s == '-' || *s == '+') {

				if (i < 63)

					it[i++] = *s;

				s++;

			}

			while (*s && nsvg__isdigit(*s)) {

				if (i < 63)

					it[i++] = *s;

				s++;

			}

		}

		it[i] = '\0';

	} else {

		// Parse command

		it[0] = *s++;

		it[1] = '\0';

		return s;

	}

	return s;

}

#define NSVG_RGB(r, g, b) (((unsigned int)r) | ((unsigned int)g << 8) | ((unsigned int)b << 16))

unsigned int nsvg__parseColorHex(const char *str)

{

	unsigned int c = 0, r = 0, g = 0, b = 0;

	int n = 0;

	str++; // skip #

	// Calculate number of characters.

	while (str[n] && !nsvg__isspace(str[n]))

		n++;

	if (n == 6) {

		sscanf(str, "%x", &c);

	} else if (n == 3) {

		sscanf(str, "%x", &c);

		c = (c & 0xf) | ((c & 0xf0) << 4) | ((c & 0xf00) << 8);

		c |= c << 4;

	}

	r = (c >> 16) & 0xff;

	g = (c >> 8) & 0xff;

	b = c & 0xff;

	return NSVG_RGB(r, g, b);

}

unsigned int nsvg__parseColorRGB(const char *str)

{

	int r = -1, g = -1, b = -1;

	char s1[32] = "", s2[32] = "";

	sscanf(str + 4, "%d%[%%, \t]%d%[%%, \t]%d", &r, s1, &g, s2, &b);

	if (strchr(s1, '%')) {

		return NSVG_RGB((r * 255) / 100, (g * 255) / 100, (b * 255) / 100);

	} else {

		return NSVG_RGB(r, g, b);

	}

}

struct NSVGNamedColor {

	const char *name;

	unsigned int color;

};

struct NSVGNamedColor nsvg__colors[] = {

	{"red", NSVG_RGB(255, 0, 0)},

	{"green", NSVG_RGB(0, 128, 0)},

	{"blue", NSVG_RGB(0, 0, 255)},

	{"yellow", NSVG_RGB(255, 255, 0)},

	{"cyan", NSVG_RGB(0, 255, 255)},

	{"magenta", NSVG_RGB(255, 0, 255)},

	{"black", NSVG_RGB(0, 0, 0)},

	{"grey", NSVG_RGB(128, 128, 128)},

	{"gray", NSVG_RGB(128, 128, 128)},

	{"white", NSVG_RGB(255, 255, 255)},

	{"aliceblue", NSVG_RGB(240, 248, 255)},

	{"antiquewhite", NSVG_RGB(250, 235, 215)},

	{"aqua", NSVG_RGB(0, 255, 255)},

	{"aquamarine", NSVG_RGB(127, 255, 212)},

	{"azure", NSVG_RGB(240, 255, 255)},

	{"beige", NSVG_RGB(245, 245, 220)},

	{"bisque", NSVG_RGB(255, 228, 196)},

	{"blanchedalmond", NSVG_RGB(255, 235, 205)},

	{"blueviolet", NSVG_RGB(138, 43, 226)},

	{"brown", NSVG_RGB(165, 42, 42)},

	{"burlywood", NSVG_RGB(222, 184, 135)},

	{"cadetblue", NSVG_RGB(95, 158, 160)},

	{"chartreuse", NSVG_RGB(127, 255, 0)},

	{"chocolate", NSVG_RGB(210, 105, 30)},

	{"coral", NSVG_RGB(255, 127, 80)},

	{"cornflowerblue", NSVG_RGB(100, 149, 237)},

	{"cornsilk", NSVG_RGB(255, 248, 220)},

	{"crimson", NSVG_RGB(220, 20, 60)},

	{"darkblue", NSVG_RGB(0, 0, 139)},

	{"darkcyan", NSVG_RGB(0, 139, 139)},

	{"darkgoldenrod", NSVG_RGB(184, 134, 11)},

	{"darkgray", NSVG_RGB(169, 169, 169)},

	{"darkgreen", NSVG_RGB(0, 100, 0)},

	{"darkgrey", NSVG_RGB(169, 169, 169)},

	{"darkkhaki", NSVG_RGB(189, 183, 107)},

	{"darkmagenta", NSVG_RGB(139, 0, 139)},

	{"darkolivegreen", NSVG_RGB(85, 107, 47)},

	{"darkorange", NSVG_RGB(255, 140, 0)},

	{"darkorchid", NSVG_RGB(153, 50, 204)},

	{"darkred", NSVG_RGB(139, 0, 0)},

	{"darksalmon", NSVG_RGB(233, 150, 122)},

	{"darkseagreen", NSVG_RGB(143, 188, 143)},

	{"darkslateblue", NSVG_RGB(72, 61, 139)},

	{"darkslategray", NSVG_RGB(47, 79, 79)},

	{"darkslategrey", NSVG_RGB(47, 79, 79)},

	{"darkturquoise", NSVG_RGB(0, 206, 209)},

	{"darkviolet", NSVG_RGB(148, 0, 211)},

	{"deeppink", NSVG_RGB(255, 20, 147)},

	{"deepskyblue", NSVG_RGB(0, 191, 255)},

	{"dimgray", NSVG_RGB(105, 105, 105)},

	{"dimgrey", NSVG_RGB(105, 105, 105)},

	{"dodgerblue", NSVG_RGB(30, 144, 255)},

	{"firebrick", NSVG_RGB(178, 34, 34)},

	{"floralwhite", NSVG_RGB(255, 250, 240)},

	{"forestgreen", NSVG_RGB(34, 139, 34)},

	{"fuchsia", NSVG_RGB(255, 0, 255)},

	{"gainsboro", NSVG_RGB(220, 220, 220)},

	{"ghostwhite", NSVG_RGB(248, 248, 255)},

	{"gold", NSVG_RGB(255, 215, 0)},

	{"goldenrod", NSVG_RGB(218, 165, 32)},

	{"greenyellow", NSVG_RGB(173, 255, 47)},

	{"honeydew", NSVG_RGB(240, 255, 240)},

	{"hotpink", NSVG_RGB(255, 105, 180)},

	{"indianred", NSVG_RGB(205, 92, 92)},

	{"indigo", NSVG_RGB(75, 0, 130)},

	{"ivory", NSVG_RGB(255, 255, 240)},

	{"khaki", NSVG_RGB(240, 230, 140)},

	{"lavender", NSVG_RGB(230, 230, 250)},

	{"lavenderblush", NSVG_RGB(255, 240, 245)},

	{"lawngreen", NSVG_RGB(124, 252, 0)},

	{"lemonchiffon", NSVG_RGB(255, 250, 205)},

	{"lightblue", NSVG_RGB(173, 216, 230)},

	{"lightcoral", NSVG_RGB(240, 128, 128)},

	{"lightcyan", NSVG_RGB(224, 255, 255)},

	{"lightgoldenrodyellow", NSVG_RGB(250, 250, 210)},

	{"lightgray", NSVG_RGB(211, 211, 211)},

	{"lightgreen", NSVG_RGB(144, 238, 144)},

	{"lightgrey", NSVG_RGB(211, 211, 211)},

	{"lightpink", NSVG_RGB(255, 182, 193)},

	{"lightsalmon", NSVG_RGB(255, 160, 122)},

	{"lightseagreen", NSVG_RGB(32, 178, 170)},

	{"lightskyblue", NSVG_RGB(135, 206, 250)},

	{"lightslategray", NSVG_RGB(119, 136, 153)},

	{"lightslategrey", NSVG_RGB(119, 136, 153)},

	{"lightsteelblue", NSVG_RGB(176, 196, 222)},

	{"lightyellow", NSVG_RGB(255, 255, 224)},

	{"lime", NSVG_RGB(0, 255, 0)},

	{"limegreen", NSVG_RGB(50, 205, 50)},

	{"linen", NSVG_RGB(250, 240, 230)},

	{"maroon", NSVG_RGB(128, 0, 0)},

	{"mediumaquamarine", NSVG_RGB(102, 205, 170)},

	{"mediumblue", NSVG_RGB(0, 0, 205)},

	{"mediumorchid", NSVG_RGB(186, 85, 211)},

	{"mediumpurple", NSVG_RGB(147, 112, 219)},

	{"mediumseagreen", NSVG_RGB(60, 179, 113)},

	{"mediumslateblue", NSVG_RGB(123, 104, 238)},

	{"mediumspringgreen", NSVG_RGB(0, 250, 154)},

	{"mediumturquoise", NSVG_RGB(72, 209, 204)},

	{"mediumvioletred", NSVG_RGB(199, 21, 133)},

	{"midnightblue", NSVG_RGB(25, 25, 112)},

	{"mintcream", NSVG_RGB(245, 255, 250)},

	{"mistyrose", NSVG_RGB(255, 228, 225)},

	{"moccasin", NSVG_RGB(255, 228, 181)},

	{"navajowhite", NSVG_RGB(255, 222, 173)},

	{"navy", NSVG_RGB(0, 0, 128)},

	{"oldlace", NSVG_RGB(253, 245, 230)},

	{"olive", NSVG_RGB(128, 128, 0)},

	{"olivedrab", NSVG_RGB(107, 142, 35)},

	{"orange", NSVG_RGB(255, 165, 0)},

	{"orangered", NSVG_RGB(255, 69, 0)},

	{"orchid", NSVG_RGB(218, 112, 214)},

	{"palegoldenrod", NSVG_RGB(238, 232, 170)},

	{"palegreen", NSVG_RGB(152, 251, 152)},

	{"paleturquoise", NSVG_RGB(175, 238, 238)},

	{"palevioletred", NSVG_RGB(219, 112, 147)},

	{"papayawhip", NSVG_RGB(255, 239, 213)},

	{"peachpuff", NSVG_RGB(255, 218, 185)},

	{"peru", NSVG_RGB(205, 133, 63)},

	{"pink", NSVG_RGB(255, 192, 203)},

	{"plum", NSVG_RGB(221, 160, 221)},

	{"powderblue", NSVG_RGB(176, 224, 230)},

	{"purple", NSVG_RGB(128, 0, 128)},

	{"rosybrown", NSVG_RGB(188, 143, 143)},

	{"royalblue", NSVG_RGB(65, 105, 225)},

	{"saddlebrown", NSVG_RGB(139, 69, 19)},

	{"salmon", NSVG_RGB(250, 128, 114)},

	{"sandybrown", NSVG_RGB(244, 164, 96)},

	{"seagreen", NSVG_RGB(46, 139, 87)},

	{"seashell", NSVG_RGB(255, 245, 238)},

	{"sienna", NSVG_RGB(160, 82, 45)},

	{"silver", NSVG_RGB(192, 192, 192)},

	{"skyblue", NSVG_RGB(135, 206, 235)},

	{"slateblue", NSVG_RGB(106, 90, 205)},

	{"slategray", NSVG_RGB(112, 128, 144)},

	{"slategrey", NSVG_RGB(112, 128, 144)},

	{"snow", NSVG_RGB(255, 250, 250)},

	{"springgreen", NSVG_RGB(0, 255, 127)},

	{"steelblue", NSVG_RGB(70, 130, 180)},

	{"tan", NSVG_RGB(210, 180, 140)},

	{"teal", NSVG_RGB(0, 128, 128)},

	{"thistle", NSVG_RGB(216, 191, 216)},

	{"tomato", NSVG_RGB(255, 99, 71)},

	{"turquoise", NSVG_RGB(64, 224, 208)},

	{"violet", NSVG_RGB(238, 130, 238)},

	{"wheat", NSVG_RGB(245, 222, 179)},

	{"whitesmoke", NSVG_RGB(245, 245, 245)},

	{"yellowgreen", NSVG_RGB(154, 205, 50)},

};

unsigned int nsvg__parseColorName(const char *str)

{

	int i, ncolors = sizeof(nsvg__colors) / sizeof(struct NSVGNamedColor);

	for (i = 0; i < ncolors; i++) {

		if (strcmp(nsvg__colors[i].name, str) == 0) {

			return nsvg__colors[i].color;

		}

	}

	return NSVG_RGB(128, 128, 128);

}

unsigned int nsvg__parseColor(const char *str)

{

	int len = 0;

	while (*str == ' ')

		++str;

	len = (int)strlen(str);

	if (len >= 1 && *str == '#')

		return nsvg__parseColorHex(str);

	else if (len >= 4 && str[0] == 'r' && str[1] == 'g' && str[2] == 'b' && str[3] == '(')

		return nsvg__parseColorRGB(str);

	return nsvg__parseColorName(str);

}

float nsvg__parseFloat(const char *str)

{

	while (*str == ' ')

		++str;

	return (float)atof(str);

}

int nsvg__parseTransformArgs(const char *str, float *args, int maxNa, int *na)

{

	const char *end;

	const char *ptr;

	*na = 0;

	ptr = str;

	while (*ptr && *ptr != '(')

		++ptr;

	if (*ptr == 0)

		return 1;

	end = ptr;

	while (*end && *end != ')')

		++end;

	if (*end == 0)

		return 1;

	while (ptr < end) {

		if (nsvg__isnum(*ptr)) {

			if (*na >= maxNa)

				return 0;

			args[(*na)++] = (float)atof(ptr);

			while (ptr < end && nsvg__isnum(*ptr))

				++ptr;

		} else {

			++ptr;

		}

	}

	return (int)(end - str);

}

int nsvg__parseMatrix(struct NSVGParser *p, const char *str)

{

	float t[6];