swfmill 0.0.1

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

@@ -0,0 +1,126 @@
+#ifndef SVG_PATHPARSER_H
+#define SVG_PATHPARSER_H
+
+#include <string>
+#include <vector>
+#include <iostream>
+#include <libxml/tree.h>
+#include <cmath>
+#include <cstdlib>
+#include "SWFShapeMaker.h"
+#include "SWF.h"
+
+
+
+namespace SWF {
+
+class PathParser {
+	public:
+		PathParser(ShapeMaker *shapeMaker);
+		void parse(const char *path);
+	
+	private:
+		std::vector<double> params;
+		ShapeMaker *shaper;
+
+		enum CharType {
+			COMMAND_ABSOLUTE,
+			COMMAND_RELATIVE,
+			WHITESPACE,
+			OTHER
+		};
+
+		void executeCommand(char command, bool repeated);
+
+		CharType getCharType(char c) {
+			switch(c) {
+				case 'M':
+				case 'Z':
+				case 'L':
+				case 'H':
+				case 'V':
+				case 'C':
+				case 'S':
+				case 'Q':
+				case 'T':
+				case 'A':
+					return COMMAND_ABSOLUTE;
+					break;
+
+				case 'm':
+				case 'z':
+				case 'l':
+				case 'h':
+				case 'v':
+				case 'c':
+				case 's':
+				case 'q':
+				case 't':
+				case 'a':
+					return COMMAND_RELATIVE;
+					break;
+
+				case '\t':
+				case '\n':
+				case '\r':
+				case ',':
+				case ' ':
+				case 0:
+					return WHITESPACE;
+					break;
+					
+				default:
+					return OTHER;
+					break;
+
+			}
+		}
+
+		size_t getParameterCount(char command) {
+			switch(command) {
+				case 'z':
+				case 'Z':
+					return 0;
+					break;
+
+				case 'h':
+				case 'H':
+				case 'v':
+				case 'V':
+					return 1;
+					break;
+
+				case 'm':
+				case 'M':
+				case 'l':
+				case 'L':
+				case 't':
+				case 'T':
+					return 2;
+					break;
+
+				case 's':
+				case 'S':
+				case 'q':
+				case 'Q':
+					return 4;
+					break;
+
+				case 'c':
+				case 'C':
+					return 6;
+					break;
+
+				case 'a':
+				case 'A':
+					return 7;
+					break;
+			}
+			return 0;
+		}
+
+};
+
+}
+
+#endif

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

@@ -0,0 +1,51 @@
+#include "SVGPointsParser.h"
+
+#include <iostream>
+#include <cstring>
+
+using namespace std;
+
+namespace SWF {
+
+void PointsParser::parse(const char *points) {
+	string tmp;
+
+	coords.clear();
+	
+	for(int i = 0; i < strlen(points); i++) {
+		char currentChar = points[i];
+		
+		if(currentChar == ',' || currentChar == ' ') {
+			if(tmp.length() > 0) {
+				coords.push_back(atof(tmp.c_str()));
+				tmp.clear();
+			}			
+		} else {
+			tmp += currentChar;
+		}
+	}
+	
+	if(tmp.length() > 0) {
+		coords.push_back(atof(tmp.c_str()));
+	}
+	
+	if(coords.size() % 2) {
+		cerr << "WARNING: odd number of coordinates in points attribute" << endl;
+	}
+}
+
+int PointsParser::getPointCount() {
+	return coords.size() / 2;
+}
+
+Point PointsParser::getPoint() {
+	double x = coords.front();
+	coords.pop_front();
+		
+	double y = coords.front();
+	coords.pop_front();
+	
+	return Point(x, y);
+}
+	
+}

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

@@ -0,0 +1,25 @@
+#ifndef SVG_POINTSPARSER_H
+#define SVG_POINTSPARSER_H
+
+#include <string>
+#include <deque>
+#include "Geom.h"
+
+
+
+namespace SWF {
+
+class PointsParser {
+	public:
+		void parse(const char *path);
+		Point getPoint();
+		int getPointCount();
+	
+	private:
+		deque<double> coords;
+
+};
+
+}
+
+#endif

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

@@ -0,0 +1,181 @@
+#include "SVGStyle.h"
+#include "SVGAttributeParser.h"
+#include <cstring>
+
+#define TMP_STRLEN 0xFF
+
+using namespace std;
+
+namespace SWF {
+
+SVGStyle::SVGStyle() {
+	_hasFill = false;
+	_hasFillGradient = false;
+	_hasStroke = false;
+	_hasStrokeGradient = false;
+	_hasStyle = false;
+
+	_hasLineCap = false;
+	lineCap = CAP_BUTT;
+
+	_hasLineJoin = false;
+	lineJoin = JOIN_MITER;
+	miterLimit = 4;
+
+	strokeWidth = 1;
+}
+
+void SVGStyle::parseNode(xmlNodePtr node, map<string, SVGGradient*> &gradients) {
+	AttributeParser parser;
+	parser.parseNode(node);
+
+	map<string, string> &attributes = parser.getAttributes();
+	for(map<string, string>::iterator iter = attributes.begin(); iter != attributes.end(); iter++) {
+		const string &attribute = (*iter).first;
+		const string &valueStr = (*iter).second;
+		const char *value = valueStr.c_str();
+		
+		if(attribute == "stroke") {
+			SVGGradient *gradient = getGradient(valueStr, gradients);
+			if(gradient) {
+					strokeGradient = gradient;
+					_hasStrokeGradient = true;
+					_hasStroke = true;
+			} else {
+				setStrokeColor(value);
+			}
+		} else if(attribute == "stroke-width") {
+			setStrokeWidth(atof(value));
+		} else if(attribute == "stroke-opacity") {
+			setStrokeAlpha(atof(value));
+		} else if(attribute == "stroke-linecap") {
+			setLineCap(value);
+		} else if(attribute == "stroke-linejoin") {
+			setLineJoin(value);
+		} else if(attribute == "stroke-miterlimit") {
+			setMiterLimit(atof(value));
+		} else if(attribute == "fill") {
+			SVGGradient *gradient = getGradient(valueStr, gradients);
+			if(gradient) {
+					fillGradient = gradient;
+					_hasFillGradient = true;
+					_hasFill = true;
+			} else {
+				setFillColor(value);
+			}
+		} else if(attribute == "fill-opacity") {
+			setFillAlpha(atof(value));
+		}
+	}
+}
+
+SVGGradient *SVGStyle::getGradient(const string &str, map<string, SVGGradient*> &gradients) {
+	if(str.substr(0, 4) == "url(" && str.substr(str.length() - 1) == ")") {
+		map<string, SVGGradient*>::iterator i;
+		i = gradients.find(str.substr(5, str.length() - 6));
+		if(i != gradients.end()) {
+			return (*i).second;
+		} else {
+			return NULL;
+		}
+	} else {
+		return NULL;
+	}
+}
+
+void SVGStyle::setLineCap(const char *cap) {
+	if(!strcmp(cap, "butt")) {
+		lineCap = CAP_BUTT;
+		_hasLineCap = true;
+		_hasStyle = true;
+	} else if(!strcmp(cap, "round")) {
+		lineCap = CAP_ROUND;
+		_hasLineCap = true;
+		_hasStyle = true;
+	} else if(!strcmp(cap, "square")) {
+		lineCap = CAP_SQUARE;
+		_hasLineCap = true;
+		_hasStyle = true;
+	}
+}
+
+void SVGStyle::setLineJoin(const char *join) {
+	if(!strcmp(join, "miter")) {
+		lineJoin = JOIN_MITER;
+		_hasLineJoin = true;
+		_hasStyle = true;
+	} else if(!strcmp(join, "round")) {
+		lineJoin = JOIN_ROUND;
+		_hasLineJoin = true;
+		_hasStyle = true;
+	} else if(!strcmp(join, "bevel")) {
+		lineJoin = JOIN_BEVEL;
+		_hasLineJoin = true;
+		_hasStyle = true;
+	}
+}
+
+void SVGStyle::writeXML(xmlNodePtr parent, double movieVersion) {
+	xmlNodePtr node, styleNode;
+	char tmp[TMP_STRLEN];
+
+	styleNode = xmlNewChild(parent, NULL, (const xmlChar *)"StyleList", NULL);
+
+	if(_hasFill) {
+		node = xmlNewChild(styleNode, NULL, (const xmlChar *)"fillStyles", NULL);
+		if(_hasFillGradient) {
+			fillGradient->writeXML(node, bounds, (movieVersion >= 8));
+		} else {
+			node = xmlNewChild(node, NULL, (const xmlChar *)"Solid", NULL);
+			node = xmlNewChild(node, NULL, (const xmlChar *)"color", NULL);
+			fill.writeXML(node);
+		}
+	}
+
+	if(_hasStroke) {
+		node = xmlNewChild(styleNode, NULL, (const xmlChar *)"lineStyles", NULL);
+
+		if(movieVersion >= 8) {
+			node = xmlNewChild(node, NULL, (const xmlChar *)"LineStyle", NULL);
+			snprintf(tmp,TMP_STRLEN,"%f", strokeWidth * 20);
+			xmlSetProp(node, (const xmlChar *)"width", (const xmlChar *)&tmp);
+			snprintf(tmp, TMP_STRLEN, "%i", lineCap);
+			xmlSetProp(node, (const xmlChar *)"startCapStyle", (const xmlChar *)&tmp);
+			snprintf(tmp, TMP_STRLEN, "%i", lineJoin);
+			xmlSetProp(node, (const xmlChar *)"jointStyle", (const xmlChar *)&tmp);
+			xmlSetProp(node, (const xmlChar *)"hasFill", (const xmlChar *)(_hasStrokeGradient ? "1" : "0"));
+			xmlSetProp(node, (const xmlChar *)"noHScale", (const xmlChar *)"0");
+			xmlSetProp(node, (const xmlChar *)"noVScale", (const xmlChar *)"0");
+			xmlSetProp(node, (const xmlChar *)"pixelHinting", (const xmlChar *)"0");
+			xmlSetProp(node, (const xmlChar *)"reserved", (const xmlChar *)"0");
+			xmlSetProp(node, (const xmlChar *)"noClose", (const xmlChar *)"0");
+			snprintf(tmp, TMP_STRLEN, "%i", lineCap);
+			xmlSetProp(node, (const xmlChar *)"endCapStyle", (const xmlChar *)&tmp);
+
+			if(lineJoin == JOIN_MITER) {
+				snprintf(tmp, TMP_STRLEN, "%f", miterLimit);
+				xmlSetProp(node, (const xmlChar *)"miterLimitFactor", (const xmlChar *)&tmp);
+			}
+			
+			if(_hasStrokeGradient) {
+				node = xmlNewChild(node, NULL, (const xmlChar *)"fillStyles", NULL);
+				strokeGradient->writeXML(node, bounds, (movieVersion >= 8));
+			} else {
+				node = xmlNewChild(node, NULL, (const xmlChar *)"fillColor", NULL);
+				stroke.writeXML(node);
+			}
+		} else {
+			node = xmlNewChild(node, NULL, (const xmlChar *)"LineStyle", NULL);
+			snprintf(tmp,TMP_STRLEN,"%f", strokeWidth * 20);
+			xmlSetProp(node, (const xmlChar *)"width", (const xmlChar *)&tmp);
+			node = xmlNewChild(node, NULL, (const xmlChar *)"color", NULL);
+			stroke.writeXML(node);
+
+			if(_hasLineCap || _hasLineJoin) {
+				cerr << "WARNING: some svg features aren't supported before swf version 8" << endl;
+			}
+		}
+	}
+}
+
+}

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

@@ -0,0 +1,80 @@
+#ifndef SVG_STYLE_H
+#define SVG_STYLE_H
+
+#include <iostream>
+#include <map>
+#include <libxml/tree.h>
+#include "SVGColor.h"
+#include "SVGGradient.h"
+#include "SWFShapeMaker.h"
+
+
+
+namespace SWF {
+
+enum SVGLineCap {
+	CAP_ROUND,
+	CAP_BUTT,
+	CAP_SQUARE
+};
+
+enum SVGLineJoin {
+	JOIN_ROUND,
+	JOIN_BEVEL,
+	JOIN_MITER
+};
+
+class SVGStyle {
+	public:
+		SVGStyle();
+		
+		void setStrokeColor(const char *color) { _hasStroke = stroke.parse(color); _hasStyle = true; }
+		void setStrokeWidth(const double width) { strokeWidth = width; _hasStyle = true; }
+		void setStrokeAlpha(const double alpha) { stroke.setAlpha(alpha); _hasStyle = true; }		
+		void setFillColor(const char *color) { _hasFill = fill.parse(color); _hasStyle = true; }
+		void setFillAlpha(const double alpha) { fill.setAlpha(alpha); _hasStyle = true; }
+		void setLineCap(const char *cap);
+		void setLineJoin(const char *join);
+		void setMiterLimit(const double miter) { miterLimit = miter; _hasStyle = true; }
+
+		double getStrokeWidth() { return strokeWidth; }
+
+		void setBounds(Rect b) { bounds = b; }
+
+		bool hasFill() { return _hasFill; }
+		bool hasStroke() { return _hasStroke; }
+		bool hasStyle() { return _hasStyle; }
+
+		void parseNode(xmlNodePtr node, std::map<std::string, SVGGradient*> &gradients);
+		void writeXML(xmlNodePtr parent, double movieVersion);
+
+	private:
+		SVGGradient *getGradient(const std::string &str, std::map<std::string, SVGGradient*> &gradients);
+	
+		bool _hasFill;
+		bool _hasFillGradient;
+		SVGColor fill;
+		SVGGradient *fillGradient;
+		
+		bool _hasStroke;
+		bool _hasStrokeGradient;
+		SVGColor stroke;
+		SVGGradient *strokeGradient;
+
+		bool _hasLineCap;
+		SVGLineCap lineCap;
+
+		bool _hasLineJoin;
+		SVGLineJoin lineJoin;
+		double miterLimit;
+
+		bool _hasStyle;
+
+		double strokeWidth;
+
+		Rect bounds;
+};
+
+}
+
+#endif