swfmill 0.0.1

data/ext/swfmill/src/swft/Parser.cpp

@@ -0,0 +1,76 @@
+#include "Parser.h"
+#include <cstring>
+
+namespace SWF {
+
+Parser::Parser(const char begin, const char end, const char parameter) {
+	expectedDelimiter = begin;
+	otherDelimiter = end;
+	parameterDelimiter = parameter;
+}
+
+Parser::~Parser() {
+}
+
+void Parser::swapDelimiters() {
+	char tmp = otherDelimiter;
+	otherDelimiter = expectedDelimiter;
+	expectedDelimiter = tmp;
+}
+
+bool Parser::isWhitespace(const char c) {
+	return (c == 0 || c == '\n' || c == '\r' || c == '\t' || c == ' '); 	
+}
+
+void Parser::doParse(const char* str) {
+	string tmp;
+		
+	insideParams = false;
+	params.clear();
+
+	for (size_t i = 0; i < strlen(str); i++) {
+		if(str[i] == expectedDelimiter) {
+			handleDelimiter(tmp);	
+		} else if(str[i] == otherDelimiter) {
+			cerr << "WARNING: Unexpected delimiter while parsing" << endl;
+		} else {
+			if(tmp.length() > 0 && (str[i] == parameterDelimiter || isWhitespace(str[i]))) {
+				trimString(tmp);
+				params.push_back(tmp);
+				tmp.clear();
+			} else {
+				tmp += str[i];
+			}
+		}
+	}
+		
+	if (tmp.length() > 0) {
+		//cerr << "WARNING: Reached end of line while parsing" << endl;
+		handleDelimiter(tmp);
+	}
+}
+
+void Parser::handleDelimiter(string& tmp) {
+	trimString(tmp);
+		
+	if(insideParams) {
+		if(tmp.length() > 0) {
+			params.push_back(tmp);
+		}
+		handleData(outside, params);
+		params.clear();
+	} else {
+		outside = tmp;
+	}
+	
+	insideParams = !insideParams;
+	tmp.clear();
+	swapDelimiters();
+}
+
+void Parser::trimString(string& s) {
+	s.erase(0, s.find_first_not_of(" \t\r\n"));
+	s.erase(s.find_last_not_of(" \t\r\n") + 1);
+}
+
+}

data/ext/swfmill/src/swft/Parser.h

@@ -0,0 +1,37 @@
+#ifndef PARSER_H
+#define PARSER_H
+
+#include <iostream>
+#include <string>
+#include <vector>
+
+using namespace std;
+
+namespace SWF {
+
+class Parser {
+	public:
+		Parser(const char begin, const char end, const char parameter = 0);
+		virtual ~Parser();
+		
+	protected:
+		virtual void handleData(const string& outside, const vector<string>& inside) = 0;
+		void doParse(const char* str);
+		void trimString(string& s);			
+		
+	private:
+		void handleDelimiter(string& tmp);
+		void swapDelimiters();
+		bool isWhitespace(const char c);
+				
+		char expectedDelimiter;
+		char otherDelimiter;
+		char parameterDelimiter;
+		bool insideParams;
+		vector<string> params;
+		string outside;
+};
+
+}
+
+#endif

data/ext/swfmill/src/swft/SVGAttributeParser.cpp

@@ -0,0 +1,78 @@
+#include "SVGAttributeParser.h"
+
+#define DPI 90.0
+
+using namespace std;
+
+namespace SWF {
+
+void AttributeParser::parseNode(xmlNodePtr node) {
+	for(xmlAttrPtr attr = node->properties; attr != NULL; attr = attr->next) {
+		xmlChar *tmp = xmlGetProp(node, attr->name);
+		if(tmp) {
+			attributes[(char *)attr->name] = (char *)tmp;
+			xmlFree(tmp);
+		}
+	}	
+
+	xmlChar *tmp = xmlGetProp(node, (const xmlChar *)"style");
+	if(tmp) {
+		doParse((char *)tmp);
+		xmlFree(tmp);
+	}
+}
+
+
+double AttributeParser::getDouble(const char* attribute, double defaultValue, double value100) {
+	const char *tmp = getString(attribute);
+	if(tmp) {
+		string tmpStr = tmp;
+
+		char *tailPtr;
+		double value = strtod(tmpStr.c_str(), &tailPtr);
+				
+		string unit = tailPtr;
+		trimString(unit);
+
+		if(unit == "in") {
+			value *= DPI;
+		} else if(unit == "cm") {
+			value *= DPI / 2.54;
+		} else if(unit == "mm") {
+			value *= DPI / 25.4;
+		} else if(unit == "pt") {
+			value *= DPI / 72.0;
+		} else if(unit == "pc") {
+			value *= DPI / 72.0 * 12.0;
+		} else if(unit == "%") {
+			value *= value100 / 100;
+		}
+	
+		return value;
+	} else {
+		return defaultValue;
+	}
+}
+
+const char *AttributeParser::getString(const char* attribute) {
+	map<string, string>::iterator iter = attributes.find(attribute);
+	if(iter != attributes.end()) {
+		return (*iter).second.c_str();
+	} else {
+		return NULL;
+	}
+}
+
+const char *AttributeParser::operator[](const char* attribute) {
+	return getString(attribute);
+}
+
+map<string, string> &AttributeParser::getAttributes() {
+	return attributes;
+}
+
+void AttributeParser::handleData(const string& attrib, const vector<string>& value) {
+	attributes[attrib] = value[0];
+}
+
+}

data/ext/swfmill/src/swft/SVGAttributeParser.h

@@ -0,0 +1,35 @@
+#ifndef SVG_ATTRIBUTE_PARSER_H
+#define SVG_ATTRIBUTE_PARSER_H
+
+#include <string>
+#include <map>
+#include <iostream>
+#include <libxml/tree.h>
+#include "Parser.h"
+
+
+
+namespace SWF {
+
+class AttributeParser : public Parser {
+	public:
+		AttributeParser() :
+			Parser(':', ';') {
+		}
+
+		void parseNode(xmlNodePtr node);
+		std::map<std::string, std::string>& getAttributes();
+
+		double getDouble(const char* attribute, double defaultValue = 0,
+				double value100 = 1);
+		const char* getString(const char* attribute);
+		const char* operator[](const char* attribute);
+
+	private:
+		std::map<std::string, std::string> attributes;
+		void handleData(const std::string& attrib, const std::vector<std::string>& value);
+};
+
+}
+
+#endif

data/ext/swfmill/src/swft/SVGColor.cpp

@@ -0,0 +1,116 @@
+#include "SVGColor.h"
+#include "SVGColors.h"
+
+#define TMP_STRLEN 0xFF
+
+using namespace std;
+
+namespace SWF {
+
+SVGColor::SVGColor() {
+	r = 0;
+	g = 0;
+	b = 0;
+	a = 0;
+}
+
+SVGColor::SVGColor(unsigned char _r, unsigned char _g, unsigned char _b, unsigned char _a) {
+	setColor(_r, _g, _b, _a);
+}
+
+void SVGColor::setColor(unsigned char _r, unsigned char _g, unsigned char _b, unsigned char _a) {
+	r = _r;
+	g = _g;
+	b = _b;
+	a = _a;
+}
+
+void SVGColor::setAlpha(unsigned char _a) {
+	a = _a;
+}
+
+void SVGColor::setAlpha(double _a) {
+	a = (unsigned char)(_a * 255.0);
+}
+
+bool SVGColor::parse(string &color) {
+	if(color == "none" || color == "") {
+		return false;
+	} else {
+		if(color[0] == '#') {
+			if(color.length() == 4) {
+				int c[3];
+				
+				for(int i = 0; i < 3; i++)
+					sscanf(color.substr(1 + i, 1).c_str(), "%x", &c[i]);
+				
+				r = (c[0] << 4) + c[0];
+				g = (c[1] << 4) + c[1];
+				b = (c[2] << 4) + c[2];
+				a = 255;
+			} else if (color.length() == 7) {
+				int c[3];
+				
+				for(int i = 0; i < 3; i++)
+					sscanf(color.substr(1 + i*2, 2).c_str(), "%x", &c[i]);
+				
+				r = c[0];
+				g = c[1];
+				b = c[2];
+				a = 255;
+			} else {
+				cerr << "WARNING: can't parse color" << endl;
+				return false;
+			}
+		} else if(color.substr(0, 3) == "rgb") {
+			double pR, pG, pB;
+			if(sscanf(color.c_str(), "rgb(%lf%%,%lf%%,%lf%%)", &pR, &pG, &pB) == 3) {
+				r = (unsigned char)(pR / 100.0 * 255.0);
+				g = (unsigned char)(pG / 100.0 * 255.0);
+				b = (unsigned char)(pB / 100.0 * 255.0);
+				a = 255;
+			} else if(sscanf(color.c_str(), "rgb(%hhu,%hhu,%hhu)", &r, &g, &b) == 3) {
+				a = 255;
+				return true;
+			} else {
+				cerr << "WARNING: can't parse rgb color" << endl;	
+				return false;
+			}
+		} else {
+			for(int i = 0; i < SVG_COLOR_COUNT; i++) {
+				if(svgColors[i].name == color) {
+					r = svgColors[i].r;
+					g = svgColors[i].g;
+					b = svgColors[i].b;
+					a = 255;
+					return true;
+				}
+			}
+			cerr << "WARNING: color name not found (" << color << ")" << endl;	
+			return false;
+		}
+	}
+	return true;
+}
+
+bool SVGColor::parse(const char *color) {
+	string tmp(color);
+	return parse(tmp);
+}
+
+void SVGColor::writeXML(xmlNodePtr parent) {
+	xmlNodePtr node;
+	char tmp[TMP_STRLEN];
+
+	node = xmlNewChild(parent, NULL, (const xmlChar *)"Color", NULL);
+	snprintf(tmp, TMP_STRLEN, "%i", r);
+	xmlSetProp(node, (const xmlChar *)"red", (const xmlChar *)&tmp);
+	snprintf(tmp, TMP_STRLEN, "%i", g);
+	xmlSetProp(node, (const xmlChar *)"green", (const xmlChar *)&tmp);
+	snprintf(tmp, TMP_STRLEN, "%i", b);
+	xmlSetProp(node, (const xmlChar *)"blue", (const xmlChar *)&tmp);
+	snprintf(tmp, TMP_STRLEN, "%i", a);
+	xmlSetProp(node, (const xmlChar *)"alpha", (const xmlChar *)&tmp);
+}
+
+}

data/ext/swfmill/src/swft/SVGColor.h

@@ -0,0 +1,37 @@
+#ifndef SVG_COLOR_H
+#define SVG_COLOR_H
+
+#include <string>
+#include <map>
+#include <iostream>
+#include <libxml/tree.h>
+
+
+
+namespace SWF {
+
+class SVGColor {
+	public:
+		SVGColor();
+		SVGColor(unsigned char _r, unsigned char _g, unsigned char _b, unsigned char _a = 255);
+
+		void initColors();
+
+		void setColor(unsigned char _r, unsigned char _g, unsigned char _b, unsigned char _a = 255);
+		void setAlpha(unsigned char _a);
+		void setAlpha(double _a);
+		bool parse(std::string &color);
+		bool parse(const char *color);
+
+		void writeXML(xmlNodePtr parent);
+
+	private:
+		unsigned char r;
+		unsigned char g;
+		unsigned char b;
+		unsigned char a;
+};
+
+}
+
+#endif

data/ext/swfmill/src/swft/SVGColors.h

@@ -0,0 +1,167 @@
+#ifndef SVG_COLORS_H
+#define SVG_COLORS_H
+
+#include <string>
+
+
+
+struct ColorStruct {
+	std::string name;
+	unsigned char r;
+	unsigned char g;
+	unsigned char b;
+};
+
+ColorStruct svgColors[] = {
+	{"aliceblue", 240, 248, 255},
+	{"antiquewhite", 250, 235, 215},
+	{"aqua", 0, 255, 255},
+	{"aquamarine", 127, 255, 212},
+	{"azure", 240, 255, 255},
+	{"beige", 245, 245, 220},
+	{"bisque", 255, 228, 196},
+	{"black", 0, 0, 0},
+	{"blanchedalmond", 255, 235, 205},
+	{"blue", 0, 0, 255},
+	{"blueviolet", 138, 43, 226},
+	{"brown", 165, 42, 42},
+	{"burlywood", 222, 184, 135},
+	{"cadetblue", 95, 158, 160},
+	{"chartreuse", 127, 255, 0},
+	{"chocolate", 210, 105, 30},
+	{"coral", 255, 127, 80},
+	{"cornflowerblue", 100, 149, 237},
+	{"cornsilk", 255, 248, 220},
+	{"crimson", 220, 20, 60},
+	{"cyan", 0, 255, 255},
+	{"darkblue", 0, 0, 139},
+	{"darkcyan", 0, 139, 139},
+	{"darkgoldenrod", 184, 134, 11},
+	{"darkgray", 169, 169, 169},
+	{"darkgreen", 0, 100, 0},
+	{"darkgrey", 169, 169, 169},
+	{"darkkhaki", 189, 183, 107},
+	{"darkmagenta", 139, 0, 139},
+	{"darkolivegreen", 85, 107, 47},
+	{"darkorange", 255, 140, 0},
+	{"darkorchid", 153, 50, 204},
+	{"darkred", 139, 0, 0},
+	{"darksalmon", 233, 150, 122},
+	{"darkseagreen", 143, 188, 143},
+	{"darkslateblue", 72, 61, 139},
+	{"darkslategray", 47, 79, 79},
+	{"darkslategrey", 47, 79, 79},
+	{"darkturquoise", 0, 206, 209},
+	{"darkviolet", 148, 0, 211},
+	{"deeppink", 255, 20, 147},
+	{"deepskyblue", 0, 191, 255},
+	{"dimgray", 105, 105, 105},
+	{"dimgrey", 105, 105, 105},
+	{"dodgerblue", 30, 144, 255},
+	{"firebrick", 178, 34, 34},
+	{"floralwhite", 255, 250, 240},
+	{"forestgreen", 34, 139, 34},
+	{"fuchsia", 255, 0, 255},
+	{"gainsboro", 220, 220, 220},
+	{"ghostwhite", 248, 248, 255},
+	{"gold", 255, 215, 0},
+	{"goldenrod", 218, 165, 32},
+	{"gray", 128, 128, 128},
+	{"green", 0, 128, 0},
+	{"greenyellow", 173, 255, 47},
+	{"grey", 128, 128, 128},
+	{"honeydew", 240, 255, 240},
+	{"hotpink", 255, 105, 180},
+	{"indianred", 205, 92, 92},
+	{"indigo", 75, 0, 130},
+	{"ivory", 255, 255, 240},
+	{"khaki", 240, 230, 140},
+	{"lavender", 230, 230, 250},
+	{"lavenderblush", 255, 240, 245},
+	{"lawngreen", 124, 252, 0},
+	{"lemonchiffon", 255, 250, 205},
+	{"lightblue", 173, 216, 230},
+	{"lightcoral", 240, 128, 128},
+	{"lightcyan", 224, 255, 255},
+	{"lightgoldenrodyellow", 250, 250, 210},
+	{"lightgray", 211, 211, 211},
+	{"lightgreen", 144, 238, 144},
+	{"lightgrey", 211, 211, 211},
+	{"lightpink", 255, 182, 193},
+	{"lightsalmon", 255, 160, 122},
+	{"lightseagreen", 32, 178, 170},
+	{"lightskyblue", 135, 206, 250},
+	{"lightslategray", 119, 136, 153},
+	{"lightslategrey", 119, 136, 153},
+	{"lightsteelblue", 176, 196, 222},
+	{"lightyellow", 255, 255, 224},
+	{"lime", 0, 255, 0},
+	{"limegreen", 50, 205, 50},
+	{"linen", 250, 240, 230},
+	{"magenta", 255, 0, 255},
+	{"maroon", 128, 0, 0},
+	{"mediumaquamarine", 102, 205, 170},
+	{"mediumblue", 0, 0, 205},
+	{"mediumorchid", 186, 85, 211},
+	{"mediumpurple", 147, 112, 219},
+	{"mediumseagreen", 60, 179, 113},
+	{"mediumslateblue", 123, 104, 238},
+	{"mediumspringgreen", 0, 250, 154},
+	{"mediumturquoise", 72, 209, 204},
+	{"mediumvioletred", 199, 21, 133},
+	{"midnightblue", 25, 25, 112},
+	{"mintcream", 245, 255, 250},
+	{"mistyrose", 255, 228, 225},
+	{"moccasin", 255, 228, 181},
+	{"navajowhite", 255, 222, 173},
+	{"navy", 0, 0, 128},
+	{"oldlace", 253, 245, 230},
+	{"olive", 128, 128, 0},
+	{"olivedrab", 107, 142, 35},
+	{"orange", 255, 165, 0},
+	{"orangered", 255, 69, 0},
+	{"orchid", 218, 112, 214},
+	{"palegoldenrod", 238, 232, 170},
+	{"palegreen", 152, 251, 152},
+	{"paleturquoise", 175, 238, 238},
+	{"palevioletred", 219, 112, 147},
+	{"papayawhip", 255, 239, 213},
+	{"peachpuff", 255, 218, 185},
+	{"peru", 205, 133, 63},
+	{"pink", 255, 192, 203},
+	{"plum", 221, 160, 221},
+	{"powderblue", 176, 224, 230},
+	{"purple", 128, 0, 128},
+	{"red", 255, 0, 0},
+	{"rosybrown", 188, 143, 143},
+	{"royalblue", 65, 105, 225},
+	{"saddlebrown", 139, 69, 19},
+	{"salmon", 250, 128, 114},
+	{"sandybrown", 244, 164, 96},
+	{"seagreen", 46, 139, 87},
+	{"seashell", 255, 245, 238},
+	{"sienna", 160, 82, 45},
+	{"silver", 192, 192, 192},
+	{"skyblue", 135, 206, 235},
+	{"slateblue", 106, 90, 205},
+	{"slategray", 112, 128, 144},
+	{"slategrey", 112, 128, 144},
+	{"snow", 255, 250, 250},
+	{"springgreen", 0, 255, 127},
+	{"steelblue", 70, 130, 180},
+	{"tan", 210, 180, 140},
+	{"teal", 0, 128, 128},
+	{"thistle", 216, 191, 216},
+	{"tomato", 255, 99, 71},
+	{"turquoise", 64, 224, 208},
+	{"violet", 238, 130, 238},
+	{"wheat", 245, 222, 179},
+	{"white", 255, 255, 255},
+	{"whitesmoke", 245, 245, 245},
+	{"yellow", 255, 255, 0},
+	{"yellowgreen", 154, 205, 50}
+};
+
+#define SVG_COLOR_COUNT (sizeof(svgColors) / sizeof(ColorStruct))
+
+#endif