root/src/swft/SVGGradient.cpp

#include "SVGGradient.h"
#include "SVGTransformParser.h"
#include <cstring>

#define TMP_STRLEN 0xFF

using namespace std;

namespace SWF {

/* SVGGradient */

SVGGradient::SVGGradient() {
        spreadMethod = PAD;
}

void SVGGradient::parse(xmlNodePtr node) {
        attribs.parseNode(node);

        const char *tmp = attribs["gradientUnits"];
        if(tmp) {
                if(!strcmp(tmp, "userSpaceOnUse")) {
                        userSpace = true;
                } else {
                        userSpace = false;
                }
        } else {
                userSpace = false;
        }

        parseGradient();
        parseSpreadMethod();
        parseTransform();
        parseStops(node);
}

void SVGGradient::parseStops(xmlNodePtr parent) {
        for(xmlNodePtr node = parent->children; node; node = node->next) {
                if(!xmlStrcmp(node->name, (const xmlChar *)"stop"))
                        parseStop(node);
        }
}

void SVGGradient::parseStop(xmlNodePtr node) {
        SVGGradientStop stop;
        AttributeParser stopAttribs;
        
        stopAttribs.parseNode(node);

        double offset = stopAttribs.getDouble("offset");
        
        const char *tmp = stopAttribs["stop-color"];
        if(tmp) {
                stop.setColor(tmp);
        }

        stop.setAlpha(stopAttribs.getDouble("stop-opacity", 1));

        stops[offset] = stop;
}

void SVGGradient::parseTransform() {
        const char *tmp = attribs["gradientTransform"];
        if(tmp) {
                TransformParser parser;
                parser.parse(tmp);
                transform = parser.getMatrix();
        }
        
}

void SVGGradient::parseSpreadMethod() {
        const char *tmp = attribs["spreadMethod"];
        if(tmp) {
                if(!strcmp(tmp, "pad")) {
                        spreadMethod = PAD;
                } else if(!strcmp(tmp, "reflect")) {
                        spreadMethod = REFLECT;
                } else if(!strcmp(tmp, "repeat")) {
                        spreadMethod = REPEAT;
                } else {
                        spreadMethod = PAD;
                }
        }
}

void SVGGradient::writeCommonXML(xmlNodePtr parentNode, Matrix& m, bool hasModes) {
        char tmp[TMP_STRLEN];
        xmlNodePtr node;
        
        if(hasModes) {
                xmlSetProp(parentNode, (const xmlChar *)"interpolationMode", (const xmlChar *)"0");
                
                snprintf(tmp, TMP_STRLEN, "%i", spreadMethod);
                xmlSetProp(parentNode, (const xmlChar *)"spreadMode", (const xmlChar *)&tmp);
        } else {
                xmlSetProp(parentNode, (const xmlChar *)"reserved", (const xmlChar *)"0");
        }
        
        node = xmlNewChild(parentNode, NULL, (const xmlChar *)"matrix", NULL);
        node = xmlNewChild(node, NULL, (const xmlChar *)"Transform", NULL);
        m.setXMLProps(node);

        node = xmlNewChild(parentNode, NULL, (const xmlChar *)"gradientColors", NULL);

        for(map<double, SVGGradientStop>::iterator i = stops.begin(); i != stops.end(); i++) {
                (*i).second.writeXML(node, (*i).first);
        }
}

/* SVGLinearGradient */

void SVGLinearGradient::parseGradient() {
        x1 = attribs.getDouble("x1", 0);
        y1 = attribs.getDouble("y1", 0);
        x2 = attribs.getDouble("x2", 1);
        y2 = attribs.getDouble("y2", 0);
}

void SVGLinearGradient::writeXML(xmlNodePtr node, Rect& bounds, bool hadModes) {
        double w = bounds.right - bounds.left;
        double h = bounds.bottom - bounds.top;

        Matrix m;

        if(userSpace) {
                double lx = x2 - x1;
                double ly = y2 - y1;

                double dx = x2 - x1;
                double dy = y2 - y1;
                double d = sqrt(dx * dx + dy * dy);
                double a = atan2(dy, dx);

                m *= transform;
                m.translate((x1 + x2) / 2 * 20, (y1 + y2) / 2 * 20);
                m.rotate(a);
                m.scale(d * 20 / 32768);
        } else {
                double sx, sy;
                
                double _x1 = bounds.left + x1 * w;
                double _y1 = bounds.top + y1 * h;
                double _x2 = bounds.left + x2 * w;
                double _y2 = bounds.top + y2 * h;

                if(x1 != x2) {
                        sx = (_x2 - _x1) / 32768.0;
                } else {
                        sx = 1;
                }

                if(y1 != y2) {
                        sy = (_y2 - _y1) / 32768.0;
                } else {
                        sy = 1;
                }

                double dx = x2 - x1;
                double dy = y2 - y1;
                double d = sqrt(dx * dx + dy * dy);
                double a = atan2(dy, dx);

                m.translate((_x1 + _x2) / 2, (_y1 + _y2) / 2);
                m.scale(sx, sy);
                m.rotate(a);
                m.scale(d);
        }

        xmlNodePtr topNode = xmlNewChild(node, NULL, (const xmlChar *)"LinearGradient", NULL);
        writeCommonXML(topNode, m, hadModes);
}

/* SVGRadialGradient */

void SVGRadialGradient::parseGradient() {
        cx = attribs.getDouble("cx", .5);
        cy = attribs.getDouble("cy", .5);
        r = attribs.getDouble("r", .5);
        
        if(attribs["fx"] || attribs["fy"]) {
                hasFocalPoint = true;
                fx = attribs.getDouble("fx", cx);
                fy = attribs.getDouble("fy", cy);
                
                if(fx == cx && fy == cy) {
                        hasFocalPoint = false;
                }
        } else {
                hasFocalPoint = false;
        }
}

void SVGRadialGradient::writeXML(xmlNodePtr node, Rect& bounds, bool hasModes) {
        Matrix m;
        
        double w = bounds.right - bounds.left;
        double h = bounds.bottom - bounds.top;
        double shift = 0;
        
        if(userSpace) {
                m *= transform;
                m.translate(cx * 20, cy * 20);
                
                if(hasFocalPoint) {
                        double dx = fx - cx;
                        double dy = fy - cy;
                        m.rotate(atan2(dy, dx));
                        shift = sqrt(pow(dx, 2) + pow(dy, 2)) / r;
                }
                                
                m.scale(r * 20 / 16348.0, r * 20 / 16384.0);
        } else {
                double _cx = bounds.left + cx * w;
                double _cy = bounds.top + cy * h;
                
                m.translate(_cx, _cy);
                
                m.scale(r * w / 16348.0, r * h / 16384.0);
                
                if(hasFocalPoint) {
                        double _fx = bounds.left + fx * w;
                        double _fy = bounds.top + fy * h;
                        
                        double dx = _fx - _cx;
                        double dy = _fy - _cy;
                        
                        m.rotate(atan2(dy, dx));
                        shift = sqrt(pow(dx, 2) + pow(dy, 2)) / (r * sqrt(pow(w, 2) + pow(h, 2)) / sqrt(2));
                }               
        }
        
        xmlNodePtr topNode;
        if(hasFocalPoint) {
                topNode = xmlNewChild(node, NULL, (const xmlChar *)"ShiftedRadialGradient", NULL);
                
                char tmp[TMP_STRLEN];   
                snprintf(tmp, TMP_STRLEN, "%f", shift);
                xmlSetProp(topNode, (const xmlChar *)"shift", (const xmlChar *)tmp);
        } else {
                topNode = xmlNewChild(node, NULL, (const xmlChar *)"RadialGradient", NULL);
        }
        writeCommonXML(topNode, m, hasModes);
}

/* SVGGradientStop */

void SVGGradientStop::writeXML(xmlNodePtr node, double offset) {
        char tmp[TMP_STRLEN];

        node = xmlNewChild(node, NULL, (const xmlChar *)"GradientItem", NULL);
        snprintf(tmp, TMP_STRLEN, "%i", (int)(offset * 255));
        xmlSetProp(node, (const xmlChar *)"position", (const xmlChar *)&tmp);
        node = xmlNewChild(node, NULL, (const xmlChar *)"color", NULL);
        color.writeXML(node);
}

}