0.7

raphael-svg.js

+/*
+ * Raphael 0.7 - JavaScript Vector Library
+ *
+ * Copyright (c) 2008 – 2009 Dmitry Baranovskiy (http://raphaeljs.com)
+ * Licensed under the MIT (http://www.opensource.org/licenses/mit-license.php) license.
+ */
+(function (R) {
+    if (R == null) {
+        throw new Error("raphael-svg.js should not be included into HTML. It has to be loaded with raphael.js");
+    }
+    R.type = "SVG";
+    R.vml = false;
+    R.svg = true;
+    R._.thePath = function (params, pathString, SVG) {
+        var el = document.createElementNS(SVG.svgns, "path");
+        el.setAttribute("fill", "none");
+        if (SVG.canvas) {
+            SVG.canvas.appendChild(el);
+        }
+        var p = new Element(el, SVG);
+        p.isAbsolute = true;
+        p.type = "path";
+        p.last = {x: 0, y: 0, bx: 0, by: 0};
+        p.absolutely = function () {
+            this.isAbsolute = true;
+            return this;
+        };
+        p.relatively = function () {
+            this.isAbsolute = false;
+            return this;
+        };
+        p.moveTo = function (x, y) {
+            var d = this.isAbsolute?"M":"m";
+            d += parseFloat(x, 10).toFixed(3) + " " + parseFloat(y, 10).toFixed(3) + " ";
+            var oldD = this[0].getAttribute("d") || "";
+            (oldD == "M0,0") && (oldD = "");
+            this[0].setAttribute("d", oldD + d);
+            this.last.x = (this.isAbsolute ? 0 : this.last.x) + parseFloat(x, 10);
+            this.last.y = (this.isAbsolute ? 0 : this.last.y) + parseFloat(y, 10);
+            this.attrs.path = oldD + d;
+            return this;
+        };
+        p.lineTo = function (x, y) {
+            this.last.x = (this.isAbsolute ? 0 : this.last.x) + parseFloat(x, 10);
+            this.last.y = (this.isAbsolute ? 0 : this.last.y) + parseFloat(y, 10);
+            var d = this.isAbsolute?"L":"l";
+            d += parseFloat(x, 10).toFixed(3) + " " + parseFloat(y, 10).toFixed(3) + " ";
+            var oldD = this[0].getAttribute("d") || "";
+            this[0].setAttribute("d", oldD + d);
+            this.attrs.path = oldD + d;
+            return this;
+        };
+        p.arcTo = function (rx, ry, large_arc_flag, sweep_flag, x, y) {
+            var d = this.isAbsolute ? "A" : "a";
+            d += [parseFloat(rx, 10).toFixed(3), parseFloat(ry, 10).toFixed(3), 0, large_arc_flag, sweep_flag, parseFloat(x, 10).toFixed(3), parseFloat(y, 10).toFixed(3)].join(" ");
+            var oldD = this[0].getAttribute("d") || "";
+            this[0].setAttribute("d", oldD + d);
+            this.last.x = parseFloat(x, 10);
+            this.last.y = parseFloat(y, 10);
+            this.attrs.path = oldD + d;
+            return this;
+        };
+        p.cplineTo = function (x1, y1, w1) {
+            if (!w1) {
+                return this.lineTo(x1, y1);
+            } else {
+                var p = {};
+                var x = parseFloat(x1, 10);
+                var y = parseFloat(y1, 10);
+                var w = parseFloat(w1, 10);
+                var d = this.isAbsolute?"C":"c";
+                var attr = [+this.last.x + w, +this.last.y, x - w, y, x, y];
+                for (var i = 0, ii = attr.length; i < ii; i++) {
+                    d += attr[i].toFixed(3) + " ";
+                }
+                this.last.x = (this.isAbsolute ? 0 : this.last.x) + attr[4];
+                this.last.y = (this.isAbsolute ? 0 : this.last.y) + attr[5];
+                this.last.bx = attr[2];
+                this.last.by = attr[3];
+                var oldD = this[0].getAttribute("d") || "";
+                this[0].setAttribute("d", oldD + d);
+                this.attrs.path = oldD + d;
+                return this;
+            }
+        };
+        p.curveTo = function () {
+            var p = {},
+                command = [0, 1, 2, 3, "s", 5, "c"];
+
+            var d = command[arguments.length];
+            if (this.isAbsolute) {
+                d = d.toUpperCase();
+            }
+            for (var i = 0, ii = arguments.length; i < ii; i++) {
+                d += parseFloat(arguments[i], 10).toFixed(3) + " ";
+            }
+            this.last.x = (this.isAbsolute ? 0 : this.last.x) + parseFloat(arguments[arguments.length - 2], 10);
+            this.last.y = (this.isAbsolute ? 0 : this.last.y) + parseFloat(arguments[arguments.length - 1], 10);
+            this.last.bx = parseFloat(arguments[arguments.length - 4], 10);
+            this.last.by = parseFloat(arguments[arguments.length - 3], 10);
+            var oldD = this.node.getAttribute("d") || "";
+            this.node.setAttribute("d", oldD + d);
+            this.attrs.path = oldD + d;
+            return this;
+        };
+        p.qcurveTo = function () {
+            var p = {},
+                command = [0, 1, "t", 3, "q"];
+
+            var d = command[arguments.length];
+            if (this.isAbsolute) {
+                d = d.toUpperCase();
+            }
+            for (var i = 0, ii = arguments.length; i < ii; i++) {
+                d += parseFloat(arguments[i], 10).toFixed(3) + " ";
+            }
+            this.last.x = (this.isAbsolute ? 0 : this.last.x) + parseFloat(arguments[arguments.length - 2], 10);
+            this.last.y = (this.isAbsolute ? 0 : this.last.y) + parseFloat(arguments[arguments.length - 1], 10);
+            if (arguments.length != 2) {
+                this.last.qx = parseFloat(arguments[arguments.length - 4], 10);
+                this.last.qy = parseFloat(arguments[arguments.length - 3], 10);
+            }
+            var oldD = this.node.getAttribute("d") || "";
+            this.node.setAttribute("d", oldD + d);
+            this.attrs.path = oldD + d;
+            return this;
+        };
+        p.addRoundedCorner = function (r, dir) {
+            var R = .5522 * r, rollback = this.isAbsolute, o = this;
+            if (rollback) {
+                this.relatively();
+                rollback = function () {
+                    o.absolutely();
+                };
+            } else {
+                rollback = function () {};
+            }
+            var actions = {
+                l: function () {
+                    return {
+                        u: function () {
+                            o.curveTo(-R, 0, -r, -(r - R), -r, -r);
+                        },
+                        d: function () {
+                            o.curveTo(-R, 0, -r, r - R, -r, r);
+                        }
+                    };
+                },
+                r: function () {
+                    return {
+                        u: function () {
+                            o.curveTo(R, 0, r, -(r - R), r, -r);
+                        },
+                        d: function () {
+                            o.curveTo(R, 0, r, r - R, r, r);
+                        }
+                    };
+                },
+                u: function () {
+                    return {
+                        r: function () {
+                            o.curveTo(0, -R, -(R - r), -r, r, -r);
+                        },
+                        l: function () {
+                            o.curveTo(0, -R, R - r, -r, -r, -r);
+                        }
+                    };
+                },
+                d: function () {
+                    return {
+                        r: function () {
+                            o.curveTo(0, R, -(R - r), r, r, r);
+                        },
+                        l: function () {
+                            o.curveTo(0, R, R - r, r, -r, r);
+                        }
+                    };
+                }
+            };
+            actions[dir[0]]()[dir[1]]();
+            rollback();
+            return o;
+        };
+        p.andClose = function () {
+            var oldD = this[0].getAttribute("d") || "";
+            this[0].setAttribute("d", oldD + "Z ");
+            this.attrs.path = oldD + "Z ";
+            return this;
+        };
+        if (pathString) {
+            p.attrs.path = "" + pathString;
+            p.absolutely();
+            R._.paper.pathfinder(p, p.attrs.path);
+        }
+        if (params) {
+            R._.setFillAndStroke(p, params);
+        }
+        return p;
+    };
+    R._.addGrdientFill = function (o, gradient, SVG) {
+        var el = document.createElementNS(SVG.svgns, gradient.type + "Gradient");
+        el.id = "raphael-gradient-" + Raphael.idGenerator++;
+        if (gradient.vector && gradient.vector.length) {
+            el.setAttribute("x1", gradient.vector[0]);
+            el.setAttribute("y1", gradient.vector[1]);
+            el.setAttribute("x2", gradient.vector[2]);
+            el.setAttribute("y2", gradient.vector[3]);
+        }
+        SVG.defs.appendChild(el);
+        for (var i = 0, ii = gradient.dots.length; i < ii; i++) {
+            var stop = document.createElementNS(SVG.svgns, "stop");
+            stop.setAttribute("offset", gradient.dots[i].offset ? gradient.dots[i].offset : (i == 0) ? "0%" : "100%");
+            stop.setAttribute("stop-color", gradient.dots[i].color || "#fff");
+            if (typeof gradient.dots[i].opacity != "undefined") {
+                stop.setAttribute("stop-opacity", gradient.dots[i].opacity);
+            }
+            el.appendChild(stop);
+        };
+        o.setAttribute("fill", "url(#" + el.id + ")");
+    };
+    R._.updatePosition = function (o) {
+        if (o.pattern) {
+            var bbox = o.node.getBBox();
+            o.pattern.setAttribute("patternTransform", "translate(" + [bbox.x, bbox.y].join(",") + ")");
+        }
+    };
+    R._.setFillAndStroke = function (o, params) {
+        var dasharray = {
+            "-": [3, 1],
+            ".": [1, 1],
+            "-.": [3, 1, 1, 1],
+            "-..": [3, 1, 1, 1, 1, 1],
+            ". ": [1, 3],
+            "- ": [4, 3],
+            "--": [8, 3],
+            "- .": [4, 3, 1, 3],
+            "--.": [8, 3, 1, 3],
+            "--..": [8, 3, 1, 3, 1, 3]
+        },
+        addDashes = function (o, value) {
+            value = dasharray[value.toString().toLowerCase()];
+            if (value) {
+                var width = o.attrs["stroke-width"] || "1",
+                    butt = {round: width, square: width, butt: 0}[o.attrs["stroke-linecap"] || params["stroke-linecap"]] || 0,
+                    dashes = [];
+                for (var i = 0, ii = value.length; i < ii; i++) {
+                    dashes.push(value[i] * width + ((i % 2) ? 1 : -1) * butt);
+                }
+                value = dashes.join(",");
+                o.node.setAttribute("stroke-dasharray", value);
+            }
+        };
+        for (var att in params) {
+            var value = params[att];
+            o.attrs[att] = value;
+            switch (att) {
+                case "path":
+                    if (o.type == "path") {
+                        o.node.setAttribute("d", "M0,0");
+                        R._.paper.pathfinder(o, value);
+                    }
+                case "rx":
+                case "cx":
+                case "x":
+                    o.node.setAttribute(att, value);
+                    R._.updatePosition(o);
+                    break;
+                case "ry":
+                case "cy":
+                case "y":
+                    o.node.setAttribute(att, value);
+                    R._.updatePosition(o);
+                    break;
+                case "width":
+                    o.node.setAttribute(att, value);
+                    break;
+                case "height":
+                    o.node.setAttribute(att, value);
+                    break;
+                case "gradient":
+                    R._.addGrdientFill(o.node, value, o.svg);
+                    break;
+                case "stroke-width":
+                    o.node.style.strokeWidth = value;
+                    // Need following line for Firefox
+                    o.node.setAttribute(att, value);
+                    if (o.attrs["stroke-dasharray"]) {
+                        addDashes(o, o.attrs["stroke-dasharray"]);
+                    }
+                    break;
+                case "stroke-dasharray":
+                    addDashes(o, value);
+                    break;
+                case "text":
+                    if (o.type == "text") {
+                        o.node.childNodes.length && o.node.removeChild(o.node.firstChild);
+                        o.node.appendChild(document.createTextNode(value));
+                    }
+                    break;
+                case "rotation":
+                    o.rotate(value, true);
+                    break;
+                case "translation":
+                    var xy = value.split(/[, ]+/);
+                    o.translate(xy[0], xy[1]);
+                    break;
+                case "scale":
+                    var xy = value.split(/[, ]+/);
+                    o.scale(xy[0], xy[1]);
+                    break;
+                case "fill":
+                    var isURL = value.match(/^url\(([^\)]+)\)$/i);
+                    if (isURL) {
+                        var el = document.createElementNS(o.svg.svgns, "pattern");
+                        var ig = document.createElementNS(o.svg.svgns, "image");
+                        el.id = "raphael-pattern-" + Raphael.idGenerator++;
+                        el.setAttribute("x", 0);
+                        el.setAttribute("y", 0);
+                        el.setAttribute("patternUnits", "userSpaceOnUse");
+                        ig.setAttribute("x", 0);
+                        ig.setAttribute("y", 0);
+                        ig.setAttributeNS(o.svg.xlink, "href", isURL[1]);
+                        el.appendChild(ig);
+
+                        var img = document.createElement("img");
+                        img.style.position = "absolute";
+                        img.style.top = "-9999em";
+                        img.style.left = "-9999em";
+                        img.onload = function () {
+                            el.setAttribute("width", this.offsetWidth);
+                            el.setAttribute("height", this.offsetHeight);
+                            ig.setAttribute("width", this.offsetWidth);
+                            ig.setAttribute("height", this.offsetHeight);
+                            document.body.removeChild(this);
+                            R._.paper.safari();
+                        };
+                        document.body.appendChild(img);
+                        img.src = isURL[1];
+                        o.svg.defs.appendChild(el);
+                        o.node.style.fill = "url(#" + el.id + ")";
+                        o.node.setAttribute("fill", "url(#" + el.id + ")");
+                        o.pattern = el;
+                        R._.updatePosition(o);
+                        break;
+                    }
+                default :
+                    var cssrule = att.replace(/(\-.)/g, function (w) {
+                        return w.substring(1).toUpperCase();
+                    });
+                    o.node.style[cssrule] = value;
+                    // Need following line for Firefox
+                    o.node.setAttribute(att, value);
+                    break;
+            }
+        }
+    };
+    var Element = function (node, svg) {
+        var X = 0,
+            Y = 0;
+        this[0] = node;
+        this.node = node;
+        this.svg = svg;
+        this.attrs = this.attrs || {};
+        this.transformations = []; // rotate, translate, scale
+        this._ = {
+            tx: 0,
+            ty: 0,
+            rt: {deg: 0, x: 0, y: 0},
+            sx: 1,
+            sy: 1
+        };
+    };
+    Element.prototype.translate = function (x, y) {
+        if (x == undefined && y == undefined) {
+            return {x: this._.tx, y: this._.ty};
+        }
+        this._.tx += +x;
+        this._.ty += +y;
+        switch (this.type) {
+            case "circle":
+            case "ellipse":
+                this.attr({cx: this.attrs.cx + x, cy: this.attrs.cy + y});
+                break;
+            case "rect":
+            case "image":
+            case "text":
+                this.attr({x: this.attrs.x + x, y: this.attrs.y + y});
+                break;
+            case "path":
+                var path = Raphael.pathToRelative(this.attrs.path);
+                path[0][1] += +x;
+                path[0][2] += +y;
+                this.attr({path: path.join(" ")});
+            break;
+        }
+        return this;
+    };
+    Element.prototype.rotate = function (deg, isAbsolute) {
+        if (deg == undefined) {
+            return this._.rt.deg;
+        }
+        var bbox = this.getBBox();
+        if (isAbsolute) {
+            this._.rt.deg = deg;
+        } else {
+            this._.rt.deg += deg;
+        }
+
+        if (this._.rt.deg) {
+            this.transformations[0] = ("rotate(" + this._.rt.deg + " " + (bbox.x + bbox.width / 2) + " " + (bbox.y + bbox.height / 2) + ")");
+        } else {
+            this.transformations[0] = "";
+        }
+        this.node.setAttribute("transform", this.transformations.join(" "));
+        return this;
+    };
+    Element.prototype.hide = function () {
+        this.node.style.display = "none";
+        return this;
+    };
+    Element.prototype.show = function () {
+        this.node.style.display = "block";
+        return this;
+    };
+    Element.prototype.remove = function () {
+        this.node.parentNode.removeChild(this.node);
+    };
+    Element.prototype.getBBox = function () {
+        return this.node.getBBox();
+    };
+    Element.prototype.attr = function () {
+        if (arguments.length == 1 && typeof arguments[0] == "string") {
+            if (arguments[0] == "translation") {
+                return this.translate();
+            }
+            return this.attrs[arguments[0]];
+        }
+        if (arguments.length == 1 && arguments[0] instanceof Array) {
+            var values = {};
+            for (var j in arguments[0]) {
+                values[arguments[0][j]] = this.attrs[arguments[0][j]];
+            }
+            return values;
+        }
+        if (arguments.length == 2) {
+            var params = {};
+            params[arguments[0]] = arguments[1];
+            R._.setFillAndStroke(this, params);
+        } else if (arguments.length == 1 && typeof arguments[0] == "object") {
+            R._.setFillAndStroke(this, arguments[0]);
+        }
+        return this;
+    };
+    Element.prototype.toFront = function () {
+        this.node.parentNode.appendChild(this.node);
+        return this;
+    };
+    Element.prototype.toBack = function () {
+        if (this.node.parentNode.firstChild != this.node) {
+            this.node.parentNode.insertBefore(this.node, this.node.parentNode.firstChild);
+        }
+        return this;
+    };
+    Element.prototype.insertAfter = function (element) {
+        if (element.node.nextSibling) {
+            element.node.parentNode.insertBefore(this.node, element.node.nextSibling);
+        } else {
+            element.node.parentNode.appendChild(this.node);
+        }
+        return this;
+    };
+    Element.prototype.insertBefore = function (element) {
+        element.node.parentNode.insertBefore(this.node, element.node);
+        return this;
+    };
+    for (var method in R._.element) {
+        Element.prototype[method] = R._.element[method];
+    }
+    R._.theCircle = function (svg, x, y, r) {
+        var el = document.createElementNS(svg.svgns, "circle");
+        el.setAttribute("cx", x);
+        el.setAttribute("cy", y);
+        el.setAttribute("r", r);
+        el.setAttribute("fill", "none");
+        el.setAttribute("stroke", "#000");
+        if (svg.canvas) {
+            svg.canvas.appendChild(el);
+        }
+        var res = new Element(el, svg);
+        res.attrs = res.attrs || {};
+        res.attrs.cx = x;
+        res.attrs.cy = y;
+        res.attrs.r = r;
+        res.attrs.stroke = "#000";
+        res.type = "circle";
+        return res;
+    };
+    R._.theRect = function (svg, x, y, w, h, r) {
+        var el = document.createElementNS(svg.svgns, "rect");
+        el.setAttribute("x", x);
+        el.setAttribute("y", y);
+        el.setAttribute("width", w);
+        el.setAttribute("height", h);
+        if (r) {
+            el.setAttribute("rx", r);
+            el.setAttribute("ry", r);
+        }
+        el.setAttribute("fill", "none");
+        el.setAttribute("stroke", "#000");
+        if (svg.canvas) {
+            svg.canvas.appendChild(el);
+        }
+        var res = new Element(el, svg);
+        res.attrs = res.attrs || {};
+        res.attrs.x = x;
+        res.attrs.y = y;
+        res.attrs.width = w;
+        res.attrs.height = h;
+        res.attrs.stroke = "#000";
+        if (r) {
+            res.attrs.rx = res.attrs.ry = r;
+        }
+        res.type = "rect";
+        return res;
+    };
+    R._.theEllipse = function (svg, x, y, rx, ry) {
+        var el = document.createElementNS(svg.svgns, "ellipse");
+        el.setAttribute("cx", x);
+        el.setAttribute("cy", y);
+        el.setAttribute("rx", rx);
+        el.setAttribute("ry", ry);
+        el.setAttribute("fill", "none");
+        el.setAttribute("stroke", "#000");
+        if (svg.canvas) {
+            svg.canvas.appendChild(el);
+        }
+        var res = new Element(el, svg);
+        res.attrs = res.attrs || {};
+        res.attrs.cx = x;
+        res.attrs.cy = y;
+        res.attrs.rx = rx;
+        res.attrs.ry = ry;
+        res.attrs.stroke = "#000";
+        res.type = "ellipse";
+        return res;
+    };
+    R._.theImage = function (svg, src, x, y, w, h) {
+        var el = document.createElementNS(svg.svgns, "image");
+        el.setAttribute("x", x);
+        el.setAttribute("y", y);
+        el.setAttribute("width", w);
+        el.setAttribute("height", h);
+        el.setAttribute("preserveAspectRatio", "none");
+        el.setAttributeNS(svg.xlink, "href", src);
+        if (svg.canvas) {
+            svg.canvas.appendChild(el);
+        }
+        var res = new Element(el, svg);
+        res.attrs = res.attrs || {};
+        res.attrs.x = x;
+        res.attrs.y = y;
+        res.attrs.width = w;
+        res.attrs.height = h;
+        res.type = "image";
+        return res;
+    };
+    R._.theText = function (svg, x, y, text) {
+        var el = document.createElementNS(svg.svgns, "text");
+        el.setAttribute("x", x);
+        el.setAttribute("y", y);
+        el.setAttribute("text-anchor", "middle");
+        el.setAttribute("fill", "#000");
+        if (text) {
+            el.appendChild(document.createTextNode(text));
+        }
+        if (svg.canvas) {
+            svg.canvas.appendChild(el);
+        }
+        var res = new Element(el, svg);
+        res.attrs = res.attrs || {};
+        res.attrs.x = x;
+        res.attrs.y = y;
+        res.attrs.fill = "#000";
+        res.type = "text";
+        return res;
+    };
+    R._.theGroup = function (svg) {
+        var el = document.createElementNS(svg.svgns, "g");
+        if (svg.canvas) {
+            svg.canvas.appendChild(el);
+        }
+        var i = new Element(el, svg);
+        for (var f in svg) {
+            if (f[0] != "_" && typeof svg[f] == "function") {
+                i[f] = (function (f) {
+                    return function () {
+                        var e = svg[f].apply(svg, arguments);
+                        el.appendChild(e[0]);
+                        return e;
+                    };
+                })(f);
+            }
+        }
+        i.type = "group";
+        return i;
+    };
+    R._create = function () {
+        // container, width, height
+        // x, y, width, height
+        if (typeof arguments[0] == "string") {
+            var container = document.getElementById(arguments[0]);
+            var width = arguments[1];
+            var height = arguments[2];
+        }
+        if (typeof arguments[0] == "object") {
+            var container = arguments[0];
+            var width = arguments[1];
+            var height = arguments[2];
+        }
+        if (typeof arguments[0] == "number") {
+            var container = 1,
+                x = arguments[0],
+                y = arguments[1],
+                width = arguments[2],
+                height = arguments[3];
+        }
+        if (!container) {
+            throw new Error("SVG container not found.");
+        }
+        R._.paper.canvas = document.createElementNS(R._.paper.svgns, "svg");
+        R._.paper.canvas.setAttribute("width", width || 320);
+        R._.paper.width = width || 320;
+        R._.paper.canvas.setAttribute("height", height || 200);
+        R._.paper.height = height || 200;
+        if (container == 1) {
+            document.body.appendChild(R._.paper.canvas);
+            R._.paper.canvas.style.position = "absolute";
+            R._.paper.canvas.style.left = x + "px";
+            R._.paper.canvas.style.top = y + "px";
+        } else {
+            if (container.firstChild) {
+                container.insertBefore(R._.paper.canvas, container.firstChild);
+            } else {
+                container.appendChild(R._.paper.canvas);
+            }
+        }
+        container = {
+            canvas: R._.paper.canvas,
+            clear: function () {
+                while (this.canvas.firstChild) {
+                    this.canvas.removeChild(this.canvas.firstChild);
+                }
+                this.defs = document.createElementNS(R._.paper.svgns, "defs");
+                this.canvas.appendChild(this.defs);
+            }
+        };
+        for (var prop in R._.paper) {
+            if (prop != "create") {
+                container[prop] = R._.paper[prop];
+            }
+        }
+        container.clear();
+        return container;
+    };
+    R._.paper.remove = function () {
+        this.canvas.parentNode.removeChild(this.canvas);
+    };
+    R._.paper.svgns = "http://www.w3.org/2000/svg";
+    R._.paper.xlink = "http://www.w3.org/1999/xlink";
+    R._.paper.safari = function () {
+        if (navigator.vendor == "Apple Computer, Inc.") {
+            var rect = this.rect(-this.width, -this.height, this.width * 3, this.height * 3).attr({stroke: "none"});
+            setTimeout(function () {rect.remove();}, 0);
+        }
+    };
+})(window.Raphael);

raphael-vml.js

+/*
+ * Raphael 0.7 - JavaScript Vector Library
+ *
+ * Copyright (c) 2008 – 2009 Dmitry Baranovskiy (http://raphaeljs.com)
+ * Licensed under the MIT (http://www.opensource.org/licenses/mit-license.php) license.
+ */
+(function (R) {
+    if (R == null) {
+        throw new Error("raphael-vml.js should not be included into HTML. It has to be loaded with raphael.js");
+    }
+    R.type = "VML";
+    R.vml = !(R.svg = false);
+    R._.thePath = function (params, pathString, VML) {
+        var g = document.createElement("rvml:group"), gl = g.style;
+        gl.position = "absolute";
+        gl.left = 0;
+        gl.top = 0;
+        gl.width = VML.width + "px";
+        gl.height = VML.height + "px";
+        var el = document.createElement("rvml:shape"), ol = el.style;
+        ol.width = VML.width + "px";
+        ol.height = VML.height + "px";
+        el.path = "";
+        if (params["class"]) {
+            el.className = params["class"];
+        }
+        el.coordsize = this.coordsize;
+        el.coordorigin = this.coordorigin;
+        g.appendChild(el);
+        VML.canvas.appendChild(g);
+        var p = new Element(el, g, VML);
+        p.isAbsolute = true;
+        p.type = "path";
+        p.path = [];
+        p.last = {x: 0, y: 0, bx: 0, by: 0, isAbsolute: true};
+        p.Path = "";
+        p.absolutely = function () {
+            this.isAbsolute = true;
+            return this;
+        };
+        p.relatively = function () {
+            this.isAbsolute = false;
+            return this;
+        };
+        p.moveTo = function (x, y) {
+            var d = this.isAbsolute?"m":"t";
+            d += Math.round(parseFloat(x, 10)) + " " + Math.round(parseFloat(y, 10));
+            this.node.path = this.Path += d;
+            this.last.x = (this.isAbsolute ? 0 : this.last.x) + parseFloat(x, 10);
+            this.last.y = (this.isAbsolute ? 0 : this.last.y) + parseFloat(y, 10);
+            this.last.isAbsolute = this.isAbsolute;
+            this.attrs.path += (this.isAbsolute ? "M" : "m") + [x, y];
+            return this;
+        };
+        p.lineTo = function (x, y) {
+            var d = this.isAbsolute?"l":"r";
+            d += Math.round(parseFloat(x, 10)) + " " + Math.round(parseFloat(y, 10));
+            this[0].path = this.Path += d;
+            this.last.x = (this.isAbsolute ? 0 : this.last.x) + parseFloat(x, 10);
+            this.last.y = (this.isAbsolute ? 0 : this.last.y) + parseFloat(y, 10);
+            this.last.isAbsolute = this.isAbsolute;
+            this.attrs.path += (this.isAbsolute ? "L" : "l") + [x, y];
+            return this;
+        };
+        p.arcTo = function (rx, ry, large_arc_flag, sweep_flag, x2, y2) {
+            // for more information of where this math came from visit:
+            // http://www.w3.org/TR/SVG11/implnote.html#ArcImplementationNotes
+            x2 = (this.isAbsolute ? 0 : this.last.x) + x2;
+            y2 = (this.isAbsolute ? 0 : this.last.y) + y2;
+            var x1 = this.last.x,
+                y1 = this.last.y,
+                x = (x1 - x2) / 2,
+                y = (y1 - y2) / 2,
+                k = (large_arc_flag == sweep_flag ? -1 : 1) *
+                    Math.sqrt(Math.abs(rx * rx * ry * ry - rx * rx * y * y - ry * ry * x * x) / (rx * rx * y * y + ry * ry * x * x)),
+                cx = k * rx * y / ry + (x1 + x2) / 2,
+                cy = k * -ry * x / rx + (y1 + y2) / 2,
+                d = sweep_flag ? (this.isAbsolute ? "wa" : "wr") : (this.isAbsolute ? "at" : "ar"),
+                left = Math.round(cx - rx),
+                top = Math.round(cy - ry);
+            d += [left, top, Math.round(left + rx * 2), Math.round(top + ry * 2), Math.round(x1), Math.round(y1), Math.round(parseFloat(x2, 10)), Math.round(parseFloat(y2, 10))].join(", ");
+            this.node.path = this.Path += d;
+            this.last.x = (this.isAbsolute ? 0 : this.last.x) + parseFloat(x2, 10);
+            this.last.y = (this.isAbsolute ? 0 : this.last.y) + parseFloat(y2, 10);
+            this.last.isAbsolute = this.isAbsolute;
+            this.attrs.path += (this.isAbsolute ? "A" : "a") + [rx, ry, 0, large_arc_flag, sweep_flag, x2, y2];
+            return this;
+        };
+        p.cplineTo = function (x1, y1, w1) {
+            if (!w1) {
+                return this.lineTo(x1, y1);
+            } else {
+                var x = Math.round(Math.round(parseFloat(x1, 10) * 100) / 100),
+                    y = Math.round(Math.round(parseFloat(y1, 10) * 100) / 100),
+                    w = Math.round(Math.round(parseFloat(w1, 10) * 100) / 100),
+                    d = this.isAbsolute ? "c" : "v",
+                    attr = [Math.round(this.last.x) + w, Math.round(this.last.y), x - w, y, x, y],
+                    svgattr = [this.last.x + w1, this.last.y, x1 - w1, y1, x1, y1];
+                d += attr.join(" ") + " ";
+                this.last.x = (this.isAbsolute ? 0 : this.last.x) + attr[4];
+                this.last.y = (this.isAbsolute ? 0 : this.last.y) + attr[5];
+                this.last.bx = attr[2];
+                this.last.by = attr[3];
+                this.node.path = this.Path += d;
+                this.attrs.path += (this.isAbsolute ? "C" : "c") + svgattr;
+                return this;
+            }
+        };
+        p.curveTo = function () {
+            var d = this.isAbsolute ? "c" : "v";
+            if (arguments.length == 6) {
+                this.last.bx = (this.isAbsolute ? 0 : this.last.x) + parseFloat(arguments[2], 10);
+                this.last.by = (this.isAbsolute ? 0 : this.last.y) + parseFloat(arguments[3], 10);
+                this.last.x = (this.isAbsolute ? 0 : this.last.x) + parseFloat(arguments[4], 10);
+                this.last.y = (this.isAbsolute ? 0 : this.last.y) + parseFloat(arguments[5], 10);
+                d += [Math.round(parseFloat(arguments[0], 10)),
+                     Math.round(parseFloat(arguments[1], 10)),
+                     Math.round(parseFloat(arguments[2], 10)),
+                     Math.round(parseFloat(arguments[3], 10)),
+                     Math.round(parseFloat(arguments[4], 10)),
+                     Math.round(parseFloat(arguments[5], 10))].join(" ") + " ";
+                this.last.isAbsolute = this.isAbsolute;
+                this.attrs.path += (this.isAbsolute ? "C" : "c") + Array.prototype.splice.call(arguments, 0, arguments.length);
+            }
+            if (arguments.length == 4) {
+                var bx = this.last.x * 2 - this.last.bx;
+                var by = this.last.y * 2 - this.last.by;
+                this.last.bx = (this.isAbsolute ? 0 : this.last.x) + parseFloat(arguments[0], 10);
+                this.last.by = (this.isAbsolute ? 0 : this.last.y) + parseFloat(arguments[1], 10);
+                this.last.x = (this.isAbsolute ? 0 : this.last.x) + parseFloat(arguments[2], 10);
+                this.last.y = (this.isAbsolute ? 0 : this.last.y) + parseFloat(arguments[3], 10);
+                d += [Math.round(bx), Math.round(by),
+                     Math.round(parseFloat(arguments[0], 10)),
+                     Math.round(parseFloat(arguments[1], 10)),
+                     Math.round(parseFloat(arguments[2], 10)),
+                     Math.round(parseFloat(arguments[3], 10))].join(" ") + " ";
+                 this.attrs.path += (this.isAbsolute ? "S" : "s") + Array.prototype.splice.call(arguments, 0, arguments.length);
+            }
+            this.node.path = this.Path += d;
+            return this;
+        };
+        p.qcurveTo = function () {
+            var d = "qb";
+            if (arguments.length == 4) {
+                this.last.qx = (this.isAbsolute ? 0 : this.last.x) + parseFloat(arguments[0], 10);
+                this.last.qy = (this.isAbsolute ? 0 : this.last.y) + parseFloat(arguments[1], 10);
+                this.last.x = (this.isAbsolute ? 0 : this.last.x) + parseFloat(arguments[2], 10);
+                this.last.y = (this.isAbsolute ? 0 : this.last.y) + parseFloat(arguments[3], 10);
+                d += [Math.round(this.last.qx),
+                     Math.round(this.last.qy),
+                     Math.round(this.last.x),
+                     Math.round(this.last.y)].join(" ") + " ";
+                this.last.isAbsolute = this.isAbsolute;
+                this.attrs.path += (this.isAbsolute ? "Q" : "q") + Array.prototype.splice.call(arguments, 0, arguments.length);
+            }
+            if (arguments.length == 2) {
+                this.last.qx = this.last.x * 2 - this.last.qx;
+                this.last.qy = this.last.y * 2 - this.last.qy;
+                this.last.x = (this.isAbsolute ? 0 : this.last.x) + parseFloat(arguments[2], 10);
+                this.last.y = (this.isAbsolute ? 0 : this.last.y) + parseFloat(arguments[3], 10);
+                d += [Math.round(this.last.qx),
+                     Math.round(this.last.qy),
+                     Math.round(this.last.x),
+                     Math.round(this.last.y)].join(" ") + " ";
+                 this.attrs.path += (this.isAbsolute ? "T" : "t") + Array.prototype.splice.call(arguments, 0, arguments.length);
+            }
+            this.node.path = this.Path += d;
+            this.path.push({type: "qcurve", arg: [].slice.call(arguments, 0), pos: this.isAbsolute});
+            return this;
+        };
+        p.addRoundedCorner = function (r, dir) {
+            var R = .5522 * r, rollback = this.isAbsolute, o = this;
+            if (rollback) {
+                this.relatively();
+                rollback = function () {
+                    o.absolutely();
+                };
+            } else {
+                rollback = function () {};
+            }
+            var actions = {
+                l: function () {
+                    return {
+                        u: function () {
+                            o.curveTo(-R, 0, -r, -(r - R), -r, -r);
+                        },
+                        d: function () {
+                            o.curveTo(-R, 0, -r, r - R, -r, r);
+                        }
+                    };
+                },
+                r: function () {
+                    return {
+                        u: function () {
+                            o.curveTo(R, 0, r, -(r - R), r, -r);
+                        },
+                        d: function () {
+                            o.curveTo(R, 0, r, r - R, r, r);
+                        }
+                    };
+                },
+                u: function () {
+                    return {
+                        r: function () {
+                            o.curveTo(0, -R, -(R - r), -r, r, -r);
+                        },
+                        l: function () {
+                            o.curveTo(0, -R, R - r, -r, -r, -r);
+                        }
+                    };
+                },
+                d: function () {
+                    return {
+                        r: function () {
+                            o.curveTo(0, R, -(R - r), r, r, r);
+                        },
+                        l: function () {
+                            o.curveTo(0, R, R - r, r, -r, r);
+                        }
+                    };
+                }
+            };
+            actions[dir.charAt(0)]()[dir.charAt(1)]();
+            rollback();
+            return o;
+        };
+        p.andClose = function () {
+            this.node.path = (this.Path += "x e");
+            this.attrs.path += "z";
+            return this;
+        };
+        if (pathString) {
+            p.absolutely();
+            p.attrs.path = "";
+            R._.paper.pathfinder(p, "" + pathString);
+        }
+        p.setBox();
+        R._.setFillAndStroke(p, params);
+        if (params.gradient) {
+            R._.addGrdientFill(p, params.gradient);
+        }
+        return p;
+    };
+    R._.setFillAndStroke = function (o, params) {
+        var s = o[0].style;
+        o.attrs = o.attrs || {};
+        for (var par in params) {
+            o.attrs[par] = params[par];
+        }
+        if (params.path && o.type == "path") {
+            o.Path = "";
+            o.path = [];
+            R._.paper.pathfinder(o, params.path);
+        }
+        if (params.rotation != null) {
+            o.Group.style.rotation = params.rotation;
+        }
+        if (params.translation) {
+            var xy = params.translation.split(/[, ]+/);
+            o.translate(xy[0], xy[1]);
+        }
+        if (params.scale) {
+            var xy = params.scale.split(/[, ]+/);
+            o.scale(xy[0], xy[1]);
+        }
+        if (o.type == "image" && params.opacity) {
+            o.node.filterOpacity = " progid:DXImageTransform.Microsoft.Alpha(opacity=" + (params.opacity * 100) + ")";
+            o.node.style.filter = (o.node.filterMatrix || "") + (o.node.filterOpacity || "");
+        }
+        params["font-family"] && (s.fontFamily = params["font-family"]);
+        params["font-size"] && (s.fontSize = params["font-size"]);
+        params["font"] && (s.font = params["font"]);
+        params["font-weight"] && (s.fontWeight = params["font-weight"]);
+        if (typeof params.opacity != "undefined" || typeof params["stroke-width"] != "undefined" || typeof params.fill != "undefined" || typeof params.stroke != "undefined") {
+            o = o.shape || o.node;
+            var fill = (o.getElementsByTagName("fill") && o.getElementsByTagName("fill")[0]) || document.createElement("rvml:fill");
+            if ("fill-opacity" in params || "opacity" in params) {
+                fill.opacity = ((params["fill-opacity"] + 1 || 2) - 1) * ((params.opacity + 1 || 2) - 1);
+            }
+            if (params.fill) {
+                fill.on = true;
+            }
+            if (fill.on == undefined || params.fill == "none") {
+                fill.on = false;
+            }
+            if (fill.on && params.fill) {
+                var isURL = params.fill.match(/^url\(([^\)]+)\)$/i);
+                if (isURL) {
+                    fill.src = isURL[1];
+                    fill.type = "tile";
+                } else {
+                    fill.color = params.fill;
+                    fill.src = "";
+                    fill.type = "solid";
+                }
+            }
+            o.appendChild(fill);
+            var stroke = (o.getElementsByTagName("stroke") && o.getElementsByTagName("stroke")[0]) || document.createElement("rvml:stroke");
+            if ((params.stroke && params.stroke != "none") || params["stroke-width"] || params["stroke-opacity"] || params["stroke-dasharray"]) {
+                stroke.on = true;
+            }
+            if (params.stroke == "none" || typeof stroke.on == "undefined") {
+                stroke.on = false;
+            }
+            if (stroke.on && params.stroke) {
+                stroke.color = params.stroke;
+            }
+            stroke.opacity = ((params["stroke-opacity"] + 1 || 2) - 1) * ((params.opacity + 1 || 2) - 1);
+            params["stroke-linejoin"] && (stroke.joinstyle = params["stroke-linejoin"] || "miter");
+            stroke.miterlimit = params["stroke-miterlimit"] || 8;
+            params["stroke-linecap"] && (stroke.endcap = {butt: "flat", square: "square", round: "round"}[params["stroke-linecap"]] || "miter");
+            params["stroke-width"] && (stroke.weight = (parseFloat(params["stroke-width"], 10) || 1) * 12 / 16);
+            if (params["stroke-dasharray"]) {
+                var dasharray = {
+                    "-": "shortdash",
+                    ".": "shortdot",
+                    "-.": "shortdashdot",
+                    "-..": "shortdashdotdot",
+                    ". ": "dot",
+                    "- ": "dash",
+                    "--": "longdash",
+                    "- .": "dashdot",
+                    "--.": "longdashdot",
+                    "--..": "longdashdotdot"
+                };
+                stroke.dashstyle = dasharray[params["stroke-dasharray"]] || "";
+            }
+            o.appendChild(stroke);
+        }
+    };
+    R._.addGrdientFill = function (o, gradient) {
+        o.attrs = o.attrs || {};
+        o.attrs.gradient = gradient;
+        o = o.shape || o[0];
+        var fill = o.getElementsByTagName("fill");
+        if (fill.length) {
+            fill = fill[0];
+        } else {
+            fill = document.createElement("rvml:fill");
+        }
+        if (gradient.dots.length) {
+            fill.on = true;
+            fill.method = "none";
+            fill.type = (gradient.type.toLowerCase() == "linear") ? "gradient" : "gradientTitle";
+            if (typeof gradient.dots[0].color != "undefined") {
+                fill.color = gradient.dots[0].color || "#000";
+            }
+            if (typeof gradient.dots[gradient.dots.length - 1].color != "undefined") {
+                fill.color2 = gradient.dots[gradient.dots.length - 1].color || "#000";
+            }
+            var colors = [];
+            for (var i = 0, ii = gradient.dots.length; i < ii; i++) {
+                if (gradient.dots[i].offset) {
+                    colors.push(gradient.dots[i].offset + " " + gradient.dots[i].color);
+                }
+            };
+            var fillOpacity = gradient.dots[0].opacity || 1;
+            var fillOpacity2 = gradient.dots[gradient.dots.length - 1].opacity || 1;
+            if (colors) {
+                fill.colors.value = colors.join(",");
+                fillOpacity2 += fillOpacity;
+                fillOpacity = fillOpacity2 - fillOpacity;
+                fillOpacity2 -= fillOpacity;
+            }
+            fill.setAttribute("opacity", fillOpacity);
+            fill.setAttribute("opacity2", fillOpacity2);
+            if (gradient.vector) {
+                var angle = Math.round(Math.atan((parseFloat(gradient.vector[3], 10) - parseFloat(gradient.vector[1], 10)) / (parseFloat(gradient.vector[2], 10) - parseFloat(gradient.vector[0], 10))) * 57.29) || 0;
+                fill.angle = 270 - angle;
+            }
+            if (gradient.type.toLowerCase() == "radial") {
+                fill.focus = "100%";
+                fill.focusposition = "0.5 0.5";
+            }
+        }
+    };
+    var Element = function (node, group, vml) {
+        var Rotation = 0,
+            RotX = 0,
+            RotY = 0,
+            Scale = 1;
+        this[0] = node;
+        this.node = node;
+        this.X = 0;
+        this.Y = 0;
+        this.attrs = {};
+        this.Group = group;
+        this.vml = vml;
+        this._ = {
+            tx: 0,
+            ty: 0,
+            rt: 0,
+            sx: 1,
+            sy: 1
+        };
+    };
+    Element.prototype.rotate = function (deg, isAbsolute) {
+        if (deg == undefined) {
+            return this._.rt;
+        }
+        if (isAbsolute) {
+            this._.rt = deg;
+        } else {
+            this._.rt += deg;
+        }
+        this.Group.style.rotation = this._.rt;
+        return this;
+    };
+    Element.prototype.setBox = function (params) {
+        var gs = this.Group.style,
+            os = this[0].style;
+        for (var i in params) {
+            this.attrs[i] = params[i];
+        }
+        var attr = this.attrs, x, y, w, h;
+        switch (this.type) {
+            case "circle": 
+                x = attr.cx - attr.r;
+                y = attr.cy - attr.r;
+                w = h = attr.r * 2;
+                break;
+            case "ellipse":
+                x = attr.cx - attr.rx;
+                y = attr.cy - attr.ry;
+                w = attr.rx * 2;
+                h = attr.ry * 2;
+                break;
+            case "rect":
+            case "image":
+                x = attr.x;
+                y = attr.y;
+                w = attr.width || 0;
+                h = attr.height || 0;
+                break;
+            case "text":
+                this.textpath.v = ["m", Math.round(attr.x), ", ", Math.round(attr.y - 2), "l", Math.round(attr.x) + 1, ", ", Math.round(attr.y - 2)].join("");
+                return;
+            case "path":
+                if (!this.attrs.path) {
+                    x = 0;
+                    y = 0;
+                    w = this.vml.width;
+                    h = this.vml.height;
+                } else {
+                    var dim = Raphael.pathDimensions(this.attrs.path),
+                    x = dim.x;
+                    y = dim.y;
+                    w = dim.width;
+                    h = dim.height;
+                }
+                break;
+            default:
+                x = 0;
+                y = 0;
+                w = this.vml.width;
+                h = this.vml.height;
+                break;
+        }
+        if (this.type == "path") {
+            var left = Math.round(this.vml.width / 2 - w / 2 - x),
+                top = Math.round(this.vml.height / 2 - h / 2 - y);
+            gs.left = - left + "px";
+            gs.top = - top + "px";
+            this.X = left;
+            this.Y = top;
+            this.W = w;
+            this.H = h;
+            os.top = top + "px";
+            os.left = left + "px";
+        } else {
+            var left = this.vml.width / 2 - w / 2,
+                top = this.vml.height / 2 - h / 2;
+            gs.position = "absolute";
+            gs.left = x - left + "px";
+            gs.top = y - top + "px";
+            this.X = x - left;
+            this.Y = y - top;
+            this.W = w;
+            this.H = h;
+            gs.width = this.vml.width + "px";
+            gs.height = this.vml.height + "px";
+            os.position = "absolute";
+            os.top = top + "px";
+            os.left = left + "px";
+            os.width = w + "px";
+            os.height = h + "px";
+        }
+    };
+    Element.prototype.hide = function () {
+        this.Group.style.display = "none";
+        return this;
+    };
+    Element.prototype.show = function () {
+        this.Group.style.display = "block";
+        return this;
+    };
+    Element.prototype.translate = function (x, y) {
+        if (x == undefined && y == undefined) {
+            return {x: this._.tx, y: this._.ty};
+        }
+        this._.tx += +x;
+        this._.ty += +y;
+        if (this.type == "path") {
+            var path = this.attrs.path;
+            path = Raphael.pathToRelative(path);
+            path[0][1] += +x;
+            path[0][2] += +y;
+            this.attr({path: path.join(" ")});
+        }
+        this.setBox({x: this._.tx, y: this._.ty});
+        return this;
+    };
+    Element.prototype.getBBox = function () {
+        return {
+            x: this.X,
+            y: this.Y,
+            width: this.W,
+            height: this.H
+        };
+    };
+    Element.prototype.remove = function () {
+        this[0].parentNode.removeChild(this[0]);
+        this.Group.parentNode.removeChild(this.Group);
+        this.shape && this.shape.parentNode.removeChild(this.shape);
+    };
+    Element.prototype.attr = function () {
+        if (arguments.length == 1 && typeof arguments[0] == "string") {
+            if (arguments[0] == "translation") {
+                return this.translate();
+            }
+            return this.attrs[arguments[0]];
+        }
+        if (this.attrs && arguments.length == 1 && arguments[0] instanceof Array) {
+            var values = {};
+            for (var i = 0, ii = arguments[0].length; i < ii; i++) {
+                values[arguments[0][i]] = this.attrs[arguments[0][i]];
+            };
+            return values;
+        }
+        if (this[0].tagName.toLowerCase() == "group") {
+            var children = this[0].childNodes;
+            this.attrs = this.attrs || {};
+            if (arguments.length == 2) {
+                this.attrs[arguments[0]] = arguments[1];
+            } else if (arguments.length == 1 || typeof arguments[0] == "object") {
+                for (var j in arguments[0]) {
+                    this.attrs[j] = arguments[0][j];
+                }
+            }
+            for (var i = 0, ii = children.length; i < ii; i++) {
+                this.attr.apply(new item(children[i], this[0], this.vml), arguments);
+            }
+        } else {
+            var params;
+            if (arguments.length == 2) {
+                params = {};
+                params[arguments[0]] = arguments[1];
+            }
+            if (arguments.length == 1 && typeof arguments[0] == "object") {
+                params = arguments[0];
+            }
+            if (params) {
+                R._.setFillAndStroke(this, params);
+                this.setBox(params);
+                if (params.gradient) {
+                    R._.addGrdientFill(this, params.gradient);
+                }
+                if (params.text && this.type == "text") {
+                    this[0].string = params.text;
+                }
+                if (params.id) {
+                    this[0].id = params.id;
+                }
+            }
+        }
+        return this;
+    };
+    Element.prototype.toFront = function () {
+        this.Group.parentNode.appendChild(this.Group);
+        return this;
+    };
+    Element.prototype.toBack = function () {
+        if (this.Group.parentNode.firstChild != this.Group) {
+            this.Group.parentNode.insertBefore(this.Group, this.Group.parentNode.firstChild);
+        }
+        return this;
+    };
+    Element.prototype.insertAfter = function (element) {
+        if (element.Group.nextSibling) {
+            element.Group.parentNode.insertBefore(this.Group, element.Group.nextSibling);
+        } else {
+            element.Group.parentNode.appendChild(this.Group);
+        }
+        return this;
+    };
+    Element.prototype.insertBefore = function (element) {
+        element.Group.parentNode.insertBefore(this.Group, element.Group);
+        return this;
+    };
+    for (var method in R._.element) {
+        Element.prototype[method] = R._.element[method];
+    }
+    R._.theCircle = function (vml, x, y, r) {
+        var g = document.createElement("rvml:group");
+        var o = document.createElement("rvml:oval");
+        g.appendChild(o);
+        vml.canvas.appendChild(g);
+        var res = new Element(o, g, vml);
+        R._.setFillAndStroke(res, {stroke: "#000", fill: "none"});
+        res.setBox({x: x - r, y: y - r, width: r * 2, height: r * 2});
+        res.attrs.cx = x;
+        res.attrs.cy = y;
+        res.attrs.r = r;
+        res.type = "circle";
+        return res;
+    };
+    R._.theRect = function (vml, x, y, w, h, r) {
+        var g = document.createElement("rvml:group");
+        var o = document.createElement(r ? "rvml:roundrect" : "rvml:rect");
+        if (r) {
+            o.arcsize = r / (Math.min(w, h));
+        }
+        g.appendChild(o);
+        vml.canvas.appendChild(g);
+        var res = new Element(o, g, vml);
+        R._.setFillAndStroke(res, {stroke: "#000"});
+        res.setBox({x: x, y: y, width: w, height: h});
+        res.attrs.x = x;
+        res.attrs.y = y;
+        res.attrs.w = w;
+        res.attrs.h = h;
+        res.attrs.r = r;
+        res.type = "rect";
+        return res;
+    };
+    R._.theEllipse = function (vml, x, y, rx, ry) {
+        var g = document.createElement("rvml:group");
+        var o = document.createElement("rvml:oval");
+        g.appendChild(o);
+        vml.canvas.appendChild(g);
+        var res = new Element(o, g, vml);
+        R._.setFillAndStroke(res, {stroke: "#000"});
+        res.setBox({x: x - rx, y: y - ry, width: rx * 2, height: ry * 2});
+        res.attrs.cx = x;
+        res.attrs.cy = y;
+        res.attrs.rx = rx;
+        res.attrs.ry = ry;
+        res.type = "ellipse";
+        return res;
+    };
+    R._.theImage = function (vml, src, x, y, w, h) {
+        var g = document.createElement("rvml:group");
+        var o = document.createElement("rvml:image");
+        o.src = src;
+        g.appendChild(o);
+        vml.canvas.appendChild(g);
+        var res = new Element(o, g, vml);
+        res.type = "image";
+        res.setBox({x: x, y: y, width: w, height: h});
+        res.attrs.x = x;
+        res.attrs.y = y;
+        res.attrs.w = w;
+        res.attrs.h = h;
+        return res;
+    };
+    R._.theText = function (vml, x, y, text) {
+        // @TODO: setTheBox
+        var g = document.createElement("rvml:group"), gs = g.style;
+        var el = document.createElement("rvml:shape"), ol = el.style;
+        var path = document.createElement("rvml:path"), ps = path.style;
+        path.v = ["m", Math.round(x), ", ", Math.round(y - 2), "l", Math.round(x) + 1, ", ", Math.round(y - 2)].join("");
+        path.textpathok = true;
+        ol.width = vml.width;
+        ol.height = vml.height;
+        gs.position = "absolute";
+        gs.left = 0;
+        gs.top = 0;
+        gs.width = vml.width;
+        gs.height = vml.height;
+        var o = document.createElement("rvml:textpath");
+        o.string = text;
+        o.on = true;
+        o.coordsize = vml.coordsize;
+        o.coordorigin = vml.coordorigin;
+        el.appendChild(o);
+        el.appendChild(path);
+        g.appendChild(el);
+        vml.canvas.appendChild(g);
+        var res = new Element(o, g, vml);
+        res.shape = el;
+        res.textpath = path;
+        res.type = "text";
+        res.attrs.x = x;
+        res.attrs.y = y;
+        res.attrs.w = 1;
+        res.attrs.h = 1;
+        R._.setFillAndStroke(res, {stroke: "none", fill: "#000"});
+        return res;
+    };
+    R._.theGroup = function (vml) {
+        var el = document.createElement("rvml:group"), els = el.style;
+        els.position = "absolute";
+        els.left = 0;
+        els.top = 0;
+        els.width = vml.width;
+        els.height = vml.height;
+        if (vml.canvas) {
+            vml.canvas.appendChild(el);
+        }
+        var res = new Element(el, el, vml);
+        for (var f in vml) {
+            if (f.charAt(0) != "_" && typeof vml[f] == "function") {
+                res[f] = (function (f) {
+                    return function () {
+                        var e = vml[f].apply(vml, arguments);
+                        el.appendChild(e[0].parentNode);
+                        return e;
+                    };
+                })(f);
+            }
+        }
+        res.type = "group";
+        return res;
+    };
+    R._create = function () {
+        // container, width, height
+        // x, y, width, height
+        var container, width, height;
+        if (typeof arguments[0] == "string") {
+            container = document.getElementById(arguments[0]);
+            width = arguments[1];
+            height = arguments[2];
+        }
+        if (typeof arguments[0] == "object") {
+            container = arguments[0];
+            width = arguments[1];
+            height = arguments[2];
+        }
+        if (typeof arguments[0] == "number") {
+            container = 1;
+            x = arguments[0];
+            y = arguments[1];
+            width = arguments[2];
+            height = arguments[3];
+        }
+        if (!container) {
+            throw new Error("VML container not found.");
+        }
+        if (!document.namespaces["rvml"]) {
+            document.namespaces.add("rvml","urn:schemas-microsoft-com:vml");
+            document.createStyleSheet().addRule("rvml\\:*", "behavior:url(#default#VML)");
+        }
+        var c = document.createElement("div"),
+            d = document.createElement("div"),
+            r = R._.paper.canvas = document.createElement("rvml:group"),
+            cs = c.style, rs = r.style;
+        R._.paper.width = width;
+        R._.paper.height = height;
+        width = width || "320px";
+        height = height || "200px";
+        cs.clip = "rect(0 " + width + " " + height + " 0)";
+        cs.top = "-2px";
+        cs.left = "-2px";
+        cs.position = "absolute";
+        rs.position = "absolute";
+        d.style.position = "relative";
+        rs.width  = width;
+        rs.height = height;
+        r.coordsize = (width == "100%" ? width : parseFloat(width)) + " " + (height == "100%" ? height : parseFloat(height));
+        r.coordorigin = "0 0";
+
+        var b = document.createElement("rvml:rect"), bs = b.style;
+        bs.left = bs.top = 0;
+        bs.width  = rs.width;
+        bs.height = rs.height;
+        b.filled = b.stroked = "f";
+
+        r.appendChild(b);
+        c.appendChild(r);
+        d.appendChild(c);
+        if (container == 1) {
+            document.body.appendChild(d);
+            cs.position = "absolute";
+            cs.left = x + "px";
+            cs.top = y + "px";
+            cs.width = width;
+            cs.height = height;
+            container = {
+                style: {
+                    width: width,
+                    height: height
+                }
+            };
+        } else {
+            cs.width = container.style.width = width;
+            cs.height = container.style.height = height;
+            if (container.firstChild) {
+                container.insertBefore(d, container.firstChild);
+            } else {
+                container.appendChild(d);
+            }
+        }
+        for (var prop in R._.paper) {
+            container[prop] = R._.paper[prop];
+        }
+        container.clear = function () {
+            var todel = [];
+            for (var i = 0, ii = r.childNodes.length; i < ii; i++) {
+                if (r.childNodes[i] != b) {
+                    todel.push(r.childNodes[i]);
+                }
+            }
+            for (i = 0, ii = todel.length; i < ii; i++) {
+                r.removeChild(todel[i]);
+            }
+        };
+        return container;
+    };
+    R._.paper.remove = function () {
+        this.canvas.parentNode.parentNode.parentNode.removeChild(this.canvas.parentNode.parentNode);
+    };
+    R._.paper.safari = function () {};
+})(window.Raphael);

raphael.js

 /*
- * Raphael 0.6.4 - JavaScript Vector Library
+ * Raphael 0.7 - JavaScript Vector Library
  *
  * Copyright (c) 2008 – 2009 Dmitry Baranovskiy (http://raphaeljs.com)
  * Licensed under the MIT (http://www.opensource.org/licenses/mit-license.php) license.
  */
-var Raphael = (function (type) {
-        var r = function () {
-            return r._create.apply(r, arguments);
-        };
-        r.version = "0.6.4";
-        r.type = type;
-        var availableAttrs = {cx: 0, cy: 0, fill: "#fff", "fill-opacity": 1, font: '16px "Arial"', "font-family": '"Arial"', "font-size": "16", gradient: 0, height: 0, opacity: 1, path: "M0,0", r: 0, rotation: 0, rx: 0, ry: 0, scale: "1 1", stroke: "#000", "stroke-dasharray": "", "stroke-linecap": "butt", "stroke-linejoin": "butt", "stroke-miterlimit": 0, "stroke-opacity": 1, "stroke-width": 1, translation: "0 0", width: 0, x: 0, y: 0},
-            availableAnimAttrs = {cx: "number", cy: "number", fill: "colour", "fill-opacity": "number", "font-size": "number", height: "number", opacity: "number", path: "path", r: "number", rotation: "number", rx: "number", ry: "number", scale: "csv", stroke: "colour", "stroke-opacity": "number", "stroke-width": "number", translation: "csv", width: "number", x: "number", y: "number"},
-            C = {};
-
-        if (type == "VML") {
-            var thePath = function (params, pathString, VML) {
-                var g = document.createElement("rvml:group"), gl = g.style;
-                gl.position = "absolute";
-                gl.left = 0;
-                gl.top = 0;
-                gl.width = VML.width + "px";
-                gl.height = VML.height + "px";
-                var el = document.createElement("rvml:shape"), ol = el.style;
-                ol.width = VML.width + "px";
-                ol.height = VML.height + "px";
-                el.path = "";
-                if (params["class"]) {
-                    el.className = params["class"];
-                }
-                el.coordsize = this.coordsize;
-                el.coordorigin = this.coordorigin;
-                g.appendChild(el);
-                VML.canvas.appendChild(g);
-                var p = new Element(el, g, VML);
-                p.isAbsolute = true;
-                p.type = "path";
-                p.path = [];
-                p.last = {x: 0, y: 0, bx: 0, by: 0, isAbsolute: true};
-                p.Path = "";
-                p.absolutely = function () {
-                    this.isAbsolute = true;
-                    return this;
-                };
-                p.relatively = function () {
-                    this.isAbsolute = false;
-                    return this;
-                };
-                p.moveTo = function (x, y) {
-                    var d = this.isAbsolute?"m":"t";
-                    d += Math.round(parseFloat(x, 10)) + " " + Math.round(parseFloat(y, 10));
-                    this.node.path = this.Path += d;
-                    this.last.x = (this.isAbsolute ? 0 : this.last.x) + parseFloat(x, 10);
-                    this.last.y = (this.isAbsolute ? 0 : this.last.y) + parseFloat(y, 10);
-                    this.last.isAbsolute = this.isAbsolute;
-                    this.attrs.path += (this.isAbsolute ? "M" : "m") + [x, y];
-                    return this;
-                };
-                p.lineTo = function (x, y) {
-                    var d = this.isAbsolute?"l":"r";
-                    d += Math.round(parseFloat(x, 10)) + " " + Math.round(parseFloat(y, 10));
-                    this[0].path = this.Path += d;
-                    this.last.x = (this.isAbsolute ? 0 : this.last.x) + parseFloat(x, 10);
-                    this.last.y = (this.isAbsolute ? 0 : this.last.y) + parseFloat(y, 10);
-                    this.last.isAbsolute = this.isAbsolute;
-                    this.attrs.path += (this.isAbsolute ? "L" : "l") + [x, y];
-                    return this;
-                };
-                p.arcTo = function (rx, ry, large_arc_flag, sweep_flag, x2, y2) {
-                    // for more information of where this math came from visit:
-                    // http://www.w3.org/TR/SVG11/implnote.html#ArcImplementationNotes
-                    x2 = (this.isAbsolute ? 0 : this.last.x) + x2;
-                    y2 = (this.isAbsolute ? 0 : this.last.y) + y2;
-                    var x1 = this.last.x,
-                        y1 = this.last.y,
-                        x = (x1 - x2) / 2,
-                        y = (y1 - y2) / 2,
-                        k = (large_arc_flag == sweep_flag ? -1 : 1) *
-                            Math.sqrt(Math.abs(rx * rx * ry * ry - rx * rx * y * y - ry * ry * x * x) / (rx * rx * y * y + ry * ry * x * x)),
-                        cx = k * rx * y / ry + (x1 + x2) / 2,
-                        cy = k * -ry * x / rx + (y1 + y2) / 2,
-                        d = sweep_flag ? (this.isAbsolute ? "wa" : "wr") : (this.isAbsolute ? "at" : "ar"),
-                        left = Math.round(cx - rx),
-                        top = Math.round(cy - ry);
-                    d += [left, top, Math.round(left + rx * 2), Math.round(top + ry * 2), Math.round(x1), Math.round(y1), Math.round(parseFloat(x2, 10)), Math.round(parseFloat(y2, 10))].join(", ");
-                    this.node.path = this.Path += d;
-                    this.last.x = (this.isAbsolute ? 0 : this.last.x) + parseFloat(x2, 10);
-                    this.last.y = (this.isAbsolute ? 0 : this.last.y) + parseFloat(y2, 10);
-                    this.last.isAbsolute = this.isAbsolute;
-                    this.attrs.path += (this.isAbsolute ? "A" : "a") + [rx, ry, 0, large_arc_flag, sweep_flag, x2, y2];
-                    return this;
-                };
-                p.cplineTo = function (x1, y1, w1) {
-                    if (!w1) {
-                        return this.lineTo(x1, y1);
-                    } else {
-                        var x = Math.round(Math.round(parseFloat(x1, 10) * 100) / 100),
-                            y = Math.round(Math.round(parseFloat(y1, 10) * 100) / 100),
-                            w = Math.round(Math.round(parseFloat(w1, 10) * 100) / 100),
-                            d = this.isAbsolute ? "c" : "v",
-                            attr = [Math.round(this.last.x) + w, Math.round(this.last.y), x - w, y, x, y],
-                            svgattr = [this.last.x + w1, this.last.y, x1 - w1, y1, x1, y1];
-                        d += attr.join(" ") + " ";
-                        this.last.x = (this.isAbsolute ? 0 : this.last.x) + attr[4];
-                        this.last.y = (this.isAbsolute ? 0 : this.last.y) + attr[5];
-                        this.last.bx = attr[2];
-                        this.last.by = attr[3];
-                        this.node.path = this.Path += d;
-                        this.attrs.path += (this.isAbsolute ? "C" : "c") + svgattr;
-                        return this;
-                    }
-                };
-                p.curveTo = function () {
-                    var d = this.isAbsolute ? "c" : "v";
-                    if (arguments.length == 6) {
-                        this.last.bx = (this.isAbsolute ? 0 : this.last.x) + parseFloat(arguments[2], 10);
-                        this.last.by = (this.isAbsolute ? 0 : this.last.y) + parseFloat(arguments[3], 10);
-                        this.last.x = (this.isAbsolute ? 0 : this.last.x) + parseFloat(arguments[4], 10);
-                        this.last.y = (this.isAbsolute ? 0 : this.last.y) + parseFloat(arguments[5], 10);
-                        d += [Math.round(parseFloat(arguments[0], 10)),
-                             Math.round(parseFloat(arguments[1], 10)),
-                             Math.round(parseFloat(arguments[2], 10)),
-                             Math.round(parseFloat(arguments[3], 10)),
-                             Math.round(parseFloat(arguments[4], 10)),
-                             Math.round(parseFloat(arguments[5], 10))].join(" ") + " ";
-                        this.last.isAbsolute = this.isAbsolute;
-                        this.attrs.path += (this.isAbsolute ? "C" : "c") + Array.prototype.splice.call(arguments, 0, arguments.length);
-                    }
-                    if (arguments.length == 4) {
-                        var bx = this.last.x * 2 - this.last.bx;
-                        var by = this.last.y * 2 - this.last.by;
-                        this.last.bx = (this.isAbsolute ? 0 : this.last.x) + parseFloat(arguments[0], 10);
-                        this.last.by = (this.isAbsolute ? 0 : this.last.y) + parseFloat(arguments[1], 10);
-                        this.last.x = (this.isAbsolute ? 0 : this.last.x) + parseFloat(arguments[2], 10);
-                        this.last.y = (this.isAbsolute ? 0 : this.last.y) + parseFloat(arguments[3], 10);
-                        d += [Math.round(bx), Math.round(by),
-                             Math.round(parseFloat(arguments[0], 10)),
-                             Math.round(parseFloat(arguments[1], 10)),
-                             Math.round(parseFloat(arguments[2], 10)),
-                             Math.round(parseFloat(arguments[3], 10))].join(" ") + " ";
-                         this.attrs.path += (this.isAbsolute ? "S" : "s") + Array.prototype.splice.call(arguments, 0, arguments.length);
-                    }
-                    this.node.path = this.Path += d;
-                    return this;
-                };
-                p.qcurveTo = function () {
-                    var d = "qb";
-                    if (arguments.length == 4) {
-                        this.last.qx = (this.isAbsolute ? 0 : this.last.x) + parseFloat(arguments[0], 10);
-                        this.last.qy = (this.isAbsolute ? 0 : this.last.y) + parseFloat(arguments[1], 10);
-                        this.last.x = (this.isAbsolute ? 0 : this.last.x) + parseFloat(arguments[2], 10);
-                        this.last.y = (this.isAbsolute ? 0 : this.last.y) + parseFloat(arguments[3], 10);
-                        d += [Math.round(this.last.qx),
-                             Math.round(this.last.qy),
-                             Math.round(this.last.x),
-                             Math.round(this.last.y)].join(" ") + " ";
-                        this.last.isAbsolute = this.isAbsolute;
-                        this.attrs.path += (this.isAbsolute ? "Q" : "q") + Array.prototype.splice.call(arguments, 0, arguments.length);
-                    }
-                    if (arguments.length == 2) {
-                        this.last.qx = this.last.x * 2 - this.last.qx;
-                        this.last.qy = this.last.y * 2 - this.last.qy;
-                        this.last.x = (this.isAbsolute ? 0 : this.last.x) + parseFloat(arguments[2], 10);
-                        this.last.y = (this.isAbsolute ? 0 : this.last.y) + parseFloat(arguments[3], 10);
-                        d += [Math.round(this.last.qx),
-                             Math.round(this.last.qy),
-                             Math.round(this.last.x),
-                             Math.round(this.last.y)].join(" ") + " ";
-                         this.attrs.path += (this.isAbsolute ? "T" : "t") + Array.prototype.splice.call(arguments, 0, arguments.length);
-                    }
-                    this.node.path = this.Path += d;
-                    this.path.push({type: "qcurve", arg: [].slice.call(arguments, 0), pos: this.isAbsolute});
-                    return this;
-                };
-                p.addRoundedCorner = function (r, dir) {
-                    var R = .5522 * r, rollback = this.isAbsolute, o = this;
-                    if (rollback) {
-                        this.relatively();
-                        rollback = function () {
-                            o.absolutely();
-                        };
-                    } else {
-                        rollback = function () {};
-                    }
-                    var actions = {
-                        l: function () {
-                            return {
-                                u: function () {
-                                    o.curveTo(-R, 0, -r, -(r - R), -r, -r);
-                                },
-                                d: function () {
-                                    o.curveTo(-R, 0, -r, r - R, -r, r);
-                                }
-                            };
-                        },
-                        r: function () {
-                            return {
-                                u: function () {
-                                    o.curveTo(R, 0, r, -(r - R), r, -r);
-                                },
-                                d: function () {
-                                    o.curveTo(R, 0, r, r - R, r, r);
-                                }
-                            };
-                        },
-                        u: function () {
-                            return {
-                                r: function () {
-                                    o.curveTo(0, -R, -(R - r), -r, r, -r);
-                                },
-                                l: function () {
-                                    o.curveTo(0, -R, R - r, -r, -r, -r);
-                                }
-                            };
-                        },
-                        d: function () {
-                            return {
-                                r: function () {
-                                    o.curveTo(0, R, -(R - r), r, r, r);
-                                },
-                                l: function () {
-                                    o.curveTo(0, R, R - r, r, -r, r);
-                                }
-                            };
-                        }
-                    };
-                    actions[dir.charAt(0)]()[dir.charAt(1)]();
-                    rollback();
-                    return o;
-                };
-                p.andClose = function () {
-                    this.node.path = (this.Path += "x e");
-                    this.attrs.path += "z";
-                    return this;
-                };
-                if (pathString) {
-                    p.absolutely();
-                    p.attrs.path = "";
-                    C.pathfinder(p, "" + pathString);
-                }
-                p.setBox();
-                setFillAndStroke(p, params);
-                if (params.gradient) {
-                    addGrdientFill(p, params.gradient);
-                }
-                return p;
-            };
-            var setFillAndStroke = function (o, params) {
-                var s = o[0].style;
-                o.attrs = o.attrs || {};
-                for (var par in params) {
-                    o.attrs[par] = params[par];
-                }
-                if (params.path && o.type == "path") {
-                    o.Path = "";
-                    o.path = [];
-                    C.pathfinder(o, params.path);
-                }
-                if (params.rotation != null) {
-                    o.Group.style.rotation = params.rotation;
-                }
-                if (params.translation) {
-                    var xy = params.translation.split(/[, ]+/);
-                    o.translate(xy[0], xy[1]);
-                }
-                if (params.scale) {
-                    var xy = params.scale.split(/[, ]+/);
-                    o.scale(xy[0], xy[1]);
-                }
-                if (o.type == "image" && params.opacity) {
-                    o.node.filterOpacity = " progid:DXImageTransform.Microsoft.Alpha(opacity=" + (params.opacity * 100) + ")";
-                    o.node.style.filter = (o.node.filterMatrix || "") + (o.node.filterOpacity || "");
-                }
-                params["font-family"] && (s.fontFamily = params["font-family"]);
-                params["font-size"] && (s.fontSize = params["font-size"]);
-                params["font"] && (s.font = params["font"]);
-                params["font-weight"] && (s.fontWeight = params["font-weight"]);
-                if (typeof params.opacity != "undefined" || typeof params["stroke-width"] != "undefined" || typeof params.fill != "undefined" || typeof params.stroke != "undefined") {
-                    o = o.shape || o.node;
-                    var fill = (o.getElementsByTagName("fill") && o.getElementsByTagName("fill")[0]) || document.createElement("rvml:fill");
-                    if ("fill-opacity" in params || "opacity" in params) {
-                        fill.opacity = ((params["fill-opacity"] + 1 || 2) - 1) * ((params.opacity + 1 || 2) - 1);
-                    }
-                    if (params.fill) {
-                        fill.on = true;
-                    }
-                    if (fill.on == undefined || params.fill == "none") {
-                        fill.on = false;
-                    }
-                    if (fill.on && params.fill) {
-                        var isURL = params.fill.match(/^url\(([^\)]+)\)$/i);
-                        if (isURL) {
-                            fill.src = isURL[1];
-                            fill.type = "tile";
-                        } else {
-                            fill.color = params.fill;
-                            fill.src = "";
-                            fill.type = "solid";
-                        }
-                    }
-                    o.appendChild(fill);
-                    var stroke = (o.getElementsByTagName("stroke") && o.getElementsByTagName("stroke")[0]) || document.createElement("rvml:stroke");
-                    if ((params.stroke && params.stroke != "none") || params["stroke-width"] || params["stroke-opacity"] || params["stroke-dasharray"]) {
-                        stroke.on = true;
-                    }
-                    if (params.stroke == "none" || typeof stroke.on == "undefined") {
-                        stroke.on = false;
-                    }
-                    if (stroke.on && params.stroke) {
-                        stroke.color = params.stroke;
-                    }
-                    stroke.opacity = ((params["stroke-opacity"] + 1 || 2) - 1) * ((params.opacity + 1 || 2) - 1);
-                    params["stroke-linejoin"] && (stroke.joinstyle = params["stroke-linejoin"] || "miter");
-                    stroke.miterlimit = params["stroke-miterlimit"] || 8;
-                    params["stroke-linecap"] && (stroke.endcap = {butt: "flat", square: "square", round: "round"}[params["stroke-linecap"]] || "miter");
-                    params["stroke-width"] && (stroke.weight = (parseFloat(params["stroke-width"], 10) || 1) * 12 / 16);
-                    if (params["stroke-dasharray"]) {
-                        var dasharray = {
-                            "-": "shortdash",
-                            ".": "shortdot",
-                            "-.": "shortdashdot",
-                            "-..": "shortdashdotdot",
-                            ". ": "dot",
-                            "- ": "dash",
-                            "--": "longdash",
-                            "- .": "dashdot",
-                            "--.": "longdashdot",
-                            "--..": "longdashdotdot"
-                        };
-                        stroke.dashstyle = dasharray[params["stroke-dasharray"]] || "";
-                    }
-                    o.appendChild(stroke);
-                }
-            };
-            var addGrdientFill = function (o, gradient) {
-                o.attrs = o.attrs || {};
-                o.attrs.gradient = gradient;
-                o = o.shape || o[0];
-                var fill = o.getElementsByTagName("fill");
-                if (fill.length) {
-                    fill = fill[0];
-                } else {
-                    fill = document.createElement("rvml:fill");
-                }
-                if (gradient.dots.length) {
-                    fill.on = true;
-                    fill.method = "none";
-                    fill.type = (gradient.type.toLowerCase() == "linear") ? "gradient" : "gradientTitle";
-                    if (typeof gradient.dots[0].color != "undefined") {
-                        fill.color = gradient.dots[0].color || "#000";
-                    }
-                    if (typeof gradient.dots[gradient.dots.length - 1].color != "undefined") {
-                        fill.color2 = gradient.dots[gradient.dots.length - 1].color || "#000";
-                    }
-                    var colors = [];
-                    for (var i = 0, ii = gradient.dots.length; i < ii; i++) {
-                        if (gradient.dots[i].offset) {
-                            colors.push(gradient.dots[i].offset + " " + gradient.dots[i].color);
-                        }
-                    };
-                    var fillOpacity = gradient.dots[0].opacity || 1;
-                    var fillOpacity2 = gradient.dots[gradient.dots.length - 1].opacity || 1;
-                    if (colors) {
-                        fill.colors.value = colors.join(",");
-                        fillOpacity2 += fillOpacity;
-                        fillOpacity = fillOpacity2 - fillOpacity;
-                        fillOpacity2 -= fillOpacity;
-                    }
-                    fill.setAttribute("opacity", fillOpacity);
-                    fill.setAttribute("opacity2", fillOpacity2);
-                    if (gradient.vector) {
-                        var angle = Math.round(Math.atan((parseFloat(gradient.vector[3], 10) - parseFloat(gradient.vector[1], 10)) / (parseFloat(gradient.vector[2], 10) - parseFloat(gradient.vector[0], 10))) * 57.29) || 0;
-                        fill.angle = 270 - angle;
-                    }
-                    if (gradient.type.toLowerCase() == "radial") {
-                        fill.focus = "100%";
-                        fill.focusposition = "0.5 0.5";
-                    }
-                }
-            };
-            var Element = function (node, group, vml) {
-                var Rotation = 0,
-                    RotX = 0,
-                    RotY = 0,
-                    Scale = 1;
-                this[0] = node;
-                this.node = node;
-                this.X = 0;
-                this.Y = 0;
-                this.attrs = {};
-                this.Group = group;
-                this.vml = vml;
-                this._ = {
-                    tx: 0,
-                    ty: 0,
-                    rt: 0,
-                    sx: 1,
-                    sy: 1
-                };
-            };
-            Element.prototype.rotate = function (deg, isAbsolute) {
-                if (deg == undefined) {
-                    return this._.rt;
-                }
-                if (isAbsolute) {
-                    this._.rt = deg;
-                } else {
-                    this._.rt += deg;
-                }
-                this.Group.style.rotation = this._.rt;
-                return this;
-            };
-            Element.prototype.setBox = function (params) {
-                var gs = this.Group.style,
-                    os = this[0].style;
-                for (var i in params) {
-                    this.attrs[i] = params[i];
-                }
-                var attr = this.attrs, x, y, w, h;
-                switch (this.type) {
-                    case "circle": 
-                        x = attr.cx - attr.r;
-                        y = attr.cy - attr.r;
-                        w = h = attr.r * 2;
-                        break;
-                    case "ellipse":
-                        x = attr.cx - attr.rx;
-                        y = attr.cy - attr.ry;
-                        w = attr.rx * 2;
-                        h = attr.ry * 2;
-                        break;
-                    case "rect":
-                    case "image":
-                        x = attr.x;
-                        y = attr.y;
-                        w = attr.width || 0;
-                        h = attr.height || 0;
-                        break;
-                    case "text":
-                        this.textpath.v = ["m", Math.round(attr.x), ", ", Math.round(attr.y - 2), "l", Math.round(attr.x) + 1, ", ", Math.round(attr.y - 2)].join("");
-                        return;
-                    case "path":
-                        if (!this.attrs.path) {
-                            x = 0;
-                            y = 0;
-                            w = this.vml.width;
-                            h = this.vml.height;
-                        } else {
-                            var dim = Raphael.pathDimensions(this.attrs.path),
-                            x = dim.x;
-                            y = dim.y;
-                            w = dim.width;
-                            h = dim.height;
-                        }
-                        break;
-                    default:
-                        x = 0;
-                        y = 0;
-                        w = this.vml.width;
-                        h = this.vml.height;
-                        break;
-                }
-                if (this.type == "path") {
-                    var left = Math.round(this.vml.width / 2 - w / 2 - x),
-                        top = Math.round(this.vml.height / 2 - h / 2 - y);
-                    gs.left = - left + "px";
-                    gs.top = - top + "px";
-                    this.X = left;
-                    this.Y = top;
-                    this.W = w;
-                    this.H = h;
-                    os.top = top + "px";
-                    os.left = left + "px";
-                } else {
-                    var left = this.vml.width / 2 - w / 2,
-                        top = this.vml.height / 2 - h / 2;
-                    gs.position = "absolute";
-                    gs.left = x - left + "px";
-                    gs.top = y - top + "px";
-                    this.X = x - left;
-                    this.Y = y - top;
-                    this.W = w;
-                    this.H = h;
-                    gs.width = this.vml.width + "px";
-                    gs.height = this.vml.height + "px";
-                    os.position = "absolute";
-                    os.top = top + "px";
-                    os.left = left + "px";
-                    os.width = w + "px";
-                    os.height = h + "px";
-                }
-            };
-            Element.prototype.hide = function () {
-                this.Group.style.display = "none";
-                return this;
-            };
-            Element.prototype.show = function () {
-                this.Group.style.display = "block";
-                return this;
-            };
-            Element.prototype.translate = function (x, y) {
-                if (x == undefined && y == undefined) {
-                    return {x: this._.tx, y: this._.ty};
-                }
-                this._.tx += +x;
-                this._.ty += +y;
-                if (this.type == "path") {
-                    var path = this.attrs.path;
-                    path = Raphael.pathToRelative(path);
-                    path[0][1] += +x;
-                    path[0][2] += +y;
-                    this.attr({path: path.join(" ")});
-                }
-                this.setBox({x: this._.tx, y: this._.ty});
-                return this;
-            };
-            Element.prototype.getBBox = function () {
-                return {
-                    x: this.X,
-                    y: this.Y,
-                    width: this.W,
-                    height: this.H
-                };
-            };
-            Element.prototype.remove = function () {
-                this[0].parentNode.removeChild(this[0]);
-                this.Group.parentNode.removeChild(this.Group);
-                this.shape && this.shape.parentNode.removeChild(this.shape);
-            };
-            Element.prototype.attr = function () {
-                if (arguments.length == 1 && typeof arguments[0] == "string") {
-                    if (arguments[0] == "translation") {
-                        return this.translate();
-                    }
-                    return this.attrs[arguments[0]];
-                }
-                if (this.attrs && arguments.length == 1 && arguments[0] instanceof Array) {
-                    var values = {};
-                    for (var i = 0, ii = arguments[0].length; i < ii; i++) {
-                        values[arguments[0][i]] = this.attrs[arguments[0][i]];
-                    };
-                    return values;
-                }
-                if (this[0].tagName.toLowerCase() == "group") {
-                    var children = this[0].childNodes;
-                    this.attrs = this.attrs || {};
-                    if (arguments.length == 2) {
-                        this.attrs[arguments[0]] = arguments[1];
-                    } else if (arguments.length == 1 || typeof arguments[0] == "object") {
-                        for (var j in arguments[0]) {
-                            this.attrs[j] = arguments[0][j];
-                        }
-                    }
-                    for (var i = 0, ii = children.length; i < ii; i++) {
-                        this.attr.apply(new item(children[i], this[0], this.vml), arguments);
-                    }
-                } else {
-                    var params;
-                    if (arguments.length == 2) {
-                        params = {};
-                        params[arguments[0]] = arguments[1];
-                    }
-                    if (arguments.length == 1 && typeof arguments[0] == "object") {
-                        params = arguments[0];
-                    }
-                    if (params) {
-                        setFillAndStroke(this, params);
-                        this.setBox(params);
-                        if (params.gradient) {
-                            addGrdientFill(this, params.gradient);
-                        }
-                        if (params.text && this.type == "text") {
-                            this[0].string = params.text;
-                        }
-                        if (params.id) {
-                            this[0].id = params.id;
-                        }
-                    }
-                }
-                return this;
-            };
-            Element.prototype.toFront = function () {
-                this.Group.parentNode.appendChild(this.Group);
-                return this;
-            };
-            Element.prototype.toBack = function () {
-                if (this.Group.parentNode.firstChild != this.Group) {
-                    this.Group.parentNode.insertBefore(this.Group, this.Group.parentNode.firstChild);
-                }
-                return this;
-            };
-            Element.prototype.insertAfter = function (element) {
-                if (element.Group.nextSibling) {
-                    element.Group.parentNode.insertBefore(this.Group, element.Group.nextSibling);
-                } else {
-                    element.Group.parentNode.appendChild(this.Group);
-                }
-                return this;
-            };
-            Element.prototype.insertBefore = function (element) {
-                element.Group.parentNode.insertBefore(this.Group, element.Group);
-                return this;
-            };
-            var theCircle = function (vml, x, y, r) {
-                var g = document.createElement("rvml:group");
-                var o = document.createElement("rvml:oval");
-                g.appendChild(o);
-                vml.canvas.appendChild(g);
-                var res = new Element(o, g, vml);
-                setFillAndStroke(res, {stroke: "#000", fill: "none"});
-                res.setBox({x: x - r, y: y - r, width: r * 2, height: r * 2});
-                res.attrs.cx = x;
-                res.attrs.cy = y;
-                res.attrs.r = r;
-                res.type = "circle";
-                return res;
-            };
-            var theRect = function (vml, x, y, w, h, r) {
-                var g = document.createElement("rvml:group");
-                var o = document.createElement(r ? "rvml:roundrect" : "rvml:rect");
-                if (r) {
-                    o.arcsize = r / (Math.min(w, h));
-                }
-                g.appendChild(o);
-                vml.canvas.appendChild(g);
-                var res = new Element(o, g, vml);
-                setFillAndStroke(res, {stroke: "#000"});
-                res.setBox({x: x, y: y, width: w, height: h});
-                res.attrs.x = x;
-                res.attrs.y = y;
-                res.attrs.w = w;
-                res.attrs.h = h;
-                res.attrs.r = r;
-                res.type = "rect";
-                return res;
-            };
-            var theEllipse = function (vml, x, y, rx, ry) {
-                var g = document.createElement("rvml:group");
-                var o = document.createElement("rvml:oval");
-                g.appendChild(o);
-                vml.canvas.appendChild(g);
-                var res = new Element(o, g, vml);
-                setFillAndStroke(res, {stroke: "#000"});
-                res.setBox({x: x - rx, y: y - ry, width: rx * 2, height: ry * 2});
-                res.attrs.cx = x;
-                res.attrs.cy = y;
-                res.attrs.rx = rx;
-                res.attrs.ry = ry;
-                res.type = "ellipse";
-                return res;
-            };
-            var theImage = function (vml, src, x, y, w, h) {
-                var g = document.createElement("rvml:group");
-                var o = document.createElement("rvml:image");
-                o.src = src;
-                g.appendChild(o);
-                vml.canvas.appendChild(g);
-                var res = new Element(o, g, vml);
-                res.type = "image";
-                res.setBox({x: x, y: y, width: w, height: h});
-                res.attrs.x = x;
-                res.attrs.y = y;
-                res.attrs.w = w;
-                res.attrs.h = h;
-                return res;
-            };
-            var theText = function (vml, x, y, text) {
-                // @TODO: setTheBox
-                var g = document.createElement("rvml:group"), gs = g.style;
-                var el = document.createElement("rvml:shape"), ol = el.style;
-                var path = document.createElement("rvml:path"), ps = path.style;
-                path.v = ["m", Math.round(x), ", ", Math.round(y - 2), "l", Math.round(x) + 1, ", ", Math.round(y - 2)].join("");
-                path.textpathok = true;
-                ol.width = vml.width;
-                ol.height = vml.height;
-                gs.position = "absolute";
-                gs.left = 0;
-                gs.top = 0;
-                gs.width = vml.width;
-                gs.height = vml.height;
-                var o = document.createElement("rvml:textpath");
-                o.string = text;
-                o.on = true;
-                o.coordsize = vml.coordsize;
-                o.coordorigin = vml.coordorigin;
-                el.appendChild(o);
-                el.appendChild(path);
-                g.appendChild(el);
-                vml.canvas.appendChild(g);
-                var res = new Element(o, g, vml);
-                res.shape = el;
-                res.textpath = path;
-                res.type = "text";
-                res.attrs.x = x;
-                res.attrs.y = y;
-                res.attrs.w = 1;
-                res.attrs.h = 1;
-                setFillAndStroke(res, {stroke: "none", fill: "#000"});
-                return res;
-            };
-            var theGroup = function (vml) {
-                var el = document.createElement("rvml:group"), els = el.style;
-                els.position = "absolute";
-                els.left = 0;
-                els.top = 0;
-                els.width = vml.width;
-                els.height = vml.height;
-                if (vml.canvas) {
-                    vml.canvas.appendChild(el);
-                }
-                var res = new Element(el, el, vml);
-                for (var f in vml) {
-                    if (f.charAt(0) != "_" && typeof vml[f] == "function") {
-                        res[f] = (function (f) {
-                            return function () {
-                                var e = vml[f].apply(vml, arguments);
-                                el.appendChild(e[0].parentNode);
-                                return e;
-                            };
-                        })(f);
-                    }
-                }
-                res.type = "group";
-                return res;
-            };
-            r._create = function () {
-                // container, width, height
-                // x, y, width, height
-                var container, width, height;
-                if (typeof arguments[0] == "string") {
-                    container = document.getElementById(arguments[0]);
-                    width = arguments[1];
-                    height = arguments[2];
-                }
-                if (typeof arguments[0] == "object") {
-                    container = arguments[0];
-                    width = arguments[1];
-                    height = arguments[2];
-                }
-                if (typeof arguments[0] == "number") {
-                    container = 1;
-                    x = arguments[0];
-                    y = arguments[1];
-                    width = arguments[2];
-                    height = arguments[3];
-                }
-                if (!container) {
-                    throw new Error("VML container not found.");
-                }
-                if (!document.namespaces["rvml"]) {
-                    document.namespaces.add("rvml","urn:schemas-microsoft-com:vml");
-                    document.createStyleSheet().addRule("rvml\\:*", "behavior:url(#default#VML)");
-                }
-                var c = document.createElement("div"),
-                    d = document.createElement("div"),
-                    r = C.canvas = document.createElement("rvml:group"),
-                    cs = c.style, rs = r.style;
-                C.width = width;
-                C.height = height;
-                width = width || "320px";
-                height = height || "200px";
-                cs.clip = "rect(0 " + width + " " + height + " 0)";
-                cs.top = "-2px";
-                cs.left = "-2px";
-                cs.position = "absolute";
-                rs.position = "absolute";
-                d.style.position = "relative";
-                rs.width  = width;
-                rs.height = height;
-                r.coordsize = (width == "100%" ? width : parseFloat(width)) + " " + (height == "100%" ? height : parseFloat(height));
-                r.coordorigin = "0 0";
-
-                var b = document.createElement("rvml:rect"), bs = b.style;
-                bs.left = bs.top = 0;
-                bs.width  = rs.width;
-                bs.height = rs.height;
-                b.filled = b.stroked = "f";
-
-                r.appendChild(b);
-                c.appendChild(r);
-                d.appendChild(c);
-                if (container == 1) {
-                    document.body.appendChild(d);
-                    cs.position = "absolute";
-                    cs.left = x + "px";
-                    cs.top = y + "px";
-                    cs.width = width;
-                    cs.height = height;
-                    container = {
-                        style: {
-                            width: width,
-                            height: height
-                        }
-                    };
-                } else {
-                    cs.width = container.style.width = width;
-                    cs.height = container.style.height = height;
-                    if (container.firstChild) {
-                        container.insertBefore(d, container.firstChild);
-                    } else {
-                        container.appendChild(d);
-                    }
-                }
-                for (var prop in C) {
-                    container[prop] = C[prop];
-                }
-                container.clear = function () {
-                    var todel = [];
-                    for (var i = 0, ii = r.childNodes.length; i < ii; i++) {
-                        if (r.childNodes[i] != b) {
-                            todel.push(r.childNodes[i]);
-                        }
-                    }
-                    for (i = 0, ii = todel.length; i < ii; i++) {
-                        r.removeChild(todel[i]);
-                    }
-                };
-                return container;
-            };
-            C.remove = function () {
-                C.canvas.parentNode.parentNode.parentNode.removeChild(C.canvas.parentNode.parentNode);
-            };
-        }
-        if (type == "SVG") {
-            var thePath = function (params, pathString, SVG) {
-                var el = document.createElementNS(SVG.svgns, "path");
-                el.setAttribute("fill", "none");
-                if (SVG.canvas) {
-                    SVG.canvas.appendChild(el);
-                }
-                var p = new Element(el, SVG);
-                p.isAbsolute = true;
-                p.type = "path";
-                p.last = {x: 0, y: 0, bx: 0, by: 0};
-                p.absolutely = function () {
-                    this.isAbsolute = true;
-                    return this;
-                };
-                p.relatively = function () {
-                    this.isAbsolute = false;
-                    return this;
-                };
-                p.moveTo = function (x, y) {
-                    var d = this.isAbsolute?"M":"m";
-                    d += parseFloat(x, 10).toFixed(3) + " " + parseFloat(y, 10).toFixed(3) + " ";
-                    var oldD = this[0].getAttribute("d") || "";
-                    (oldD == "M0,0") && (oldD = "");
-                    this[0].setAttribute("d", oldD + d);
-                    this.last.x = (this.isAbsolute ? 0 : this.last.x) + parseFloat(x, 10);
-                    this.last.y = (this.isAbsolute ? 0 : this.last.y) + parseFloat(y, 10);
-                    this.attrs.path = oldD + d;
-                    return this;
-                };
-                p.lineTo = function (x, y) {
-                    this.last.x = (this.isAbsolute ? 0 : this.last.x) + parseFloat(x, 10);
-                    this.last.y = (this.isAbsolute ? 0 : this.last.y) + parseFloat(y, 10);
-                    var d = this.isAbsolute?"L":"l";
-                    d += parseFloat(x, 10).toFixed(3) + " " + parseFloat(y, 10).toFixed(3) + " ";
-                    var oldD = this[0].getAttribute("d") || "";
-                    this[0].setAttribute("d", oldD + d);
-                    this.attrs.path = oldD + d;
-                    return this;
-                };
-                p.arcTo = function (rx, ry, large_arc_flag, sweep_flag, x, y) {
-                    var d = this.isAbsolute ? "A" : "a";
-                    d += [parseFloat(rx, 10).toFixed(3), parseFloat(ry, 10).toFixed(3), 0, large_arc_flag, sweep_flag, parseFloat(x, 10).toFixed(3), parseFloat(y, 10).toFixed(3)].join(" ");
-                    var oldD = this[0].getAttribute("d") || "";
-                    this[0].setAttribute("d", oldD + d);
-                    this.last.x = parseFloat(x, 10);
-                    this.last.y = parseFloat(y, 10);
-                    this.attrs.path = oldD + d;
-                    return this;
-                };
-                p.cplineTo = function (x1, y1, w1) {
-                    if (!w1) {
-                        return this.lineTo(x1, y1);
-                    } else {
-                        var p = {};
-                        var x = parseFloat(x1, 10);
-                        var y = parseFloat(y1, 10);
-                        var w = parseFloat(w1, 10);
-                        var d = this.isAbsolute?"C":"c";
-                        var attr = [+this.last.x + w, +this.last.y, x - w, y, x, y];
-                        for (var i = 0, ii = attr.length; i < ii; i++) {
-                            d += attr[i].toFixed(3) + " ";
-                        }
-                        this.last.x = (this.isAbsolute ? 0 : this.last.x) + attr[4];
-                        this.last.y = (this.isAbsolute ? 0 : this.last.y) + attr[5];
-                        this.last.bx = attr[2];
-                        this.last.by = attr[3];
-                        var oldD = this[0].getAttribute("d") || "";
-                        this[0].setAttribute("d", oldD + d);
-                        this.attrs.path = oldD + d;
-                        return this;
-                    }
-                };
-                p.curveTo = function () {
-                    var p = {},
-                        command = [0, 1, 2, 3, "s", 5, "c"];
-                    
-                    var d = command[arguments.length];
-                    if (this.isAbsolute) {
-                        d = d.toUpperCase();
-                    }
-                    for (var i = 0, ii = arguments.length; i < ii; i++) {
-                        d += parseFloat(arguments[i], 10).toFixed(3) + " ";
-                    }
-                    this.last.x = (this.isAbsolute ? 0 : this.last.x) + parseFloat(arguments[arguments.length - 2], 10);
-                    this.last.y = (this.isAbsolute ? 0 : this.last.y) + parseFloat(arguments[arguments.length - 1], 10);
-                    this.last.bx = parseFloat(arguments[arguments.length - 4], 10);
-                    this.last.by = parseFloat(arguments[arguments.length - 3], 10);
-                    var oldD = this.node.getAttribute("d") || "";
-                    this.node.setAttribute("d", oldD + d);
-                    this.attrs.path = oldD + d;
-                    return this;
-                };
-                p.qcurveTo = function () {
-                    var p = {},
-                        command = [0, 1, "t", 3, "q"];
-                    
-                    var d = command[arguments.length];
-                    if (this.isAbsolute) {
-                        d = d.toUpperCase();
-                    }
-                    for (var i = 0, ii = arguments.length; i < ii; i++) {
-                        d += parseFloat(arguments[i], 10).toFixed(3) + " ";
-                    }
-                    this.last.x = (this.isAbsolute ? 0 : this.last.x) + parseFloat(arguments[arguments.length - 2], 10);
-                    this.last.y = (this.isAbsolute ? 0 : this.last.y) + parseFloat(arguments[arguments.length - 1], 10);
-                    if (arguments.length != 2) {
-                        this.last.qx = parseFloat(arguments[arguments.length - 4], 10);
-                        this.last.qy = parseFloat(arguments[arguments.length - 3], 10);
-                    }
-                    var oldD = this.node.getAttribute("d") || "";
-                    this.node.setAttribute("d", oldD + d);
-                    this.attrs.path = oldD + d;
-                    return this;
-                };
-                p.addRoundedCorner = function (r, dir) {
-                    var R = .5522 * r, rollback = this.isAbsolute, o = this;
-                    if (rollback) {
-                        this.relatively();
-                        rollback = function () {
-                            o.absolutely();
-                        };
-                    } else {
-                        rollback = function () {};
-                    }
-                    var actions = {
-                        l: function () {
-                            return {
-                                u: function () {
-                                    o.curveTo(-R, 0, -r, -(r - R), -r, -r);
-                                },
-                                d: function () {
-                                    o.curveTo(-R, 0, -r, r - R, -r, r);
-                                }
-                            };
-                        },
-                        r: function () {
-                            return {
-                                u: function () {
-                                    o.curveTo(R, 0, r, -(r - R), r, -r);
-                                },
-                                d: function () {
-                                    o.curveTo(R, 0, r, r - R, r, r);
-                                }
-                            };
-                        },
-                        u: function () {
-                            return {
-                                r: function () {
-                                    o.curveTo(0, -R, -(R - r), -r, r, -r);
-                                },
-                                l: function () {
-                                    o.curveTo(0, -R, R - r, -r, -r, -r);
-                                }
-                            };
-                        },
-                        d: function () {
-                            return {
-                                r: function () {
-                                    o.curveTo(0, R, -(R - r), r, r, r);
-                                },
-                                l: function () {
-                                    o.curveTo(0, R, R - r, r, -r, r);
-                                }
-                            };
-                        }
-                    };
-                    actions[dir[0]]()[dir[1]]();
-                    rollback();
-                    return o;
-                };
-                p.andClose = function () {
-                    var oldD = this[0].getAttribute("d") || "";
-                    this[0].setAttribute("d", oldD + "Z ");
-                    this.attrs.path = oldD + "Z ";
-                    return this;
-                };
-                if (pathString) {
-                    p.attrs.path = "" + pathString;
-                    p.absolutely();
-                    C.pathfinder(p, p.attrs.path);
-                }
-                if (params) {
-                    setFillAndStroke(p, params);
-                }
-                return p;
-            };
-            var addGrdientFill = function (o, gradient, SVG) {
-                var el = document.createElementNS(SVG.svgns, gradient.type + "Gradient");
-                el.id = "raphael-gradient-" + SVG.gradients++;
-                if (gradient.vector && gradient.vector.length) {
-                    el.setAttribute("x1", gradient.vector[0]);
-                    el.setAttribute("y1", gradient.vector[1]);
-                    el.setAttribute("x2", gradient.vector[2]);
-                    el.setAttribute("y2", gradient.vector[3]);
-                }
-                SVG.defs.appendChild(el);
-                for (var i = 0, ii = gradient.dots.length; i < ii; i++) {
-                    var stop = document.createElementNS(SVG.svgns, "stop");
-                    stop.setAttribute("offset", gradient.dots[i].offset ? gradient.dots[i].offset : (i == 0) ? "0%" : "100%");
-                    stop.setAttribute("stop-color", gradient.dots[i].color || "#fff");
-                    if (typeof gradient.dots[i].opacity != "undefined") {
-                        stop.setAttribute("stop-opacity", gradient.dots[i].opacity);
-                    }
-                    el.appendChild(stop);
-                };
-                o.setAttribute("fill", "url(#" + el.id + ")");
-            };
-            var updatePosition = function (o) {
-                if (o.pattern) {
-                    var bbox = o.node.getBBox();
-                    o.pattern.setAttribute("patternTransform", "translate(" + [bbox.x, bbox.y].join(",") + ")");
-                }
-            };
-            var setFillAndStroke = function (o, params) {
-                var dasharray = {
-                    "-": [3, 1],
-                    ".": [1, 1],
-                    "-.": [3, 1, 1, 1],
-                    "-..": [3, 1, 1, 1, 1, 1],
-                    ". ": [1, 3],
-                    "- ": [4, 3],
-                    "--": [8, 3],
-                    "- .": [4, 3, 1, 3],
-                    "--.": [8, 3, 1, 3],
-                    "--..": [8, 3, 1, 3, 1, 3]
-                },
-                addDashes = function (o, value) {
-                    value = dasharray[value.toString().toLowerCase()];
-                    if (value) {
-                        var width = o.attrs["stroke-width"] || "1",
-                            butt = {round: width, square: width, butt: 0}[o.attrs["stroke-linecap"] || params["stroke-linecap"]] || 0,
-                            dashes = [];
-                        for (var i = 0, ii = value.length; i < ii; i++) {
-                            dashes.push(value[i] * width + ((i % 2) ? 1 : -1) * butt);
-                        }
-                        value = dashes.join(",");
-                        o.node.setAttribute("stroke-dasharray", value);
-                    }
-                };
-                for (var att in params) {
-                    var value = params[att];
-                    o.attrs[att] = value;
-                    switch (att) {
-                        case "path":
-                            if (o.type == "path") {
-                                o.node.setAttribute("d", "M0,0");
-                                C.pathfinder(o, value);
-                            }
-                        case "rx":
-                        case "cx":
-                        case "x":
-                            o.node.setAttribute(att, value);
-                            updatePosition(o);
-                            break;
-                        case "ry":
-                        case "cy":
-                        case "y":
-                            o.node.setAttribute(att, value);
-                            updatePosition(o);
-                            break;
-                        case "width":
-                            o.node.setAttribute(att, value);
-                            break;
-                        case "height":
-                            o.node.setAttribute(att, value);
-                            break;
-                        case "gradient":
-                            addGrdientFill(o.node, value, o.svg);
-                            break;
-                        case "stroke-width":
-                            o.node.style.strokeWidth = value;
-                            // Need following line for Firefox
-                            o.node.setAttribute(att, value);
-                            if (o.attrs["stroke-dasharray"]) {
-                                addDashes(o, o.attrs["stroke-dasharray"]);
-                            }
-                            break;
-                        case "stroke-dasharray":
-                            addDashes(o, value);
-                            break;
-                        case "text":
-                            if (o.type == "text") {
-                                o.node.childNodes.length && o.node.removeChild(o.node.firstChild);
-                                o.node.appendChild(document.createTextNode(value));
-                            }
-                            break;
-                        case "rotation":
-                            o.rotate(value, true);
-                            break;
-                        case "translation":
-                            var xy = value.split(/[, ]+/);
-                            o.translate(xy[0], xy[1]);
-                            break;
-                        case "scale":
-                            var xy = value.split(/[, ]+/);
-                            o.scale(xy[0], xy[1]);
-                            break;
-                        case "fill":
-                            var isURL = value.match(/^url\(([^\)]+)\)$/i);
-                            if (isURL) {
-                                var el = document.createElementNS(o.svg.svgns, "pattern");
-                                var ig = document.createElementNS(o.svg.svgns, "image");
-                                el.id = "raphael-pattern-" + o.svg.gradients++;
-                                el.setAttribute("x", 0);
-                                el.setAttribute("y", 0);
-                                el.setAttribute("patternUnits", "userSpaceOnUse");
-                                ig.setAttribute("x", 0);
-                                ig.setAttribute("y", 0);
-                                ig.setAttributeNS(o.svg.xlink, "href", isURL[1]);
-                                el.appendChild(ig);
+function Raphael() {
+    return Raphael._create.apply(Raphael, arguments);
+};
 
-                                var img = document.createElement("img");
-                                img.style.position = "absolute";
-                                img.style.top = "-9999em";
-                                img.style.left = "-9999em";
-                                img.onload = function () {
-                                    el.setAttribute("width", this.offsetWidth);
-                                    el.setAttribute("height", this.offsetHeight);
-                                    ig.setAttribute("width", this.offsetWidth);
-                                    ig.setAttribute("height", this.offsetHeight);
-                                    document.body.removeChild(this);
-                                    C.safari();
-                                };
-                                document.body.appendChild(img);
-                                img.src = isURL[1];
-                                o.svg.defs.appendChild(el);
-                                o.node.style.fill = "url(#" + el.id + ")";
-                                o.node.setAttribute("fill", "url(#" + el.id + ")");
-                                o.pattern = el;
-                                updatePosition(o);
-                                break;
-                            }
-                        default :
-                            var cssrule = att.replace(/(\-.)/g, function (w) {
-                                return w.substring(1).toUpperCase();
-                            });
-                            o.node.style[cssrule] = value;
-                            // Need following line for Firefox
-                            o.node.setAttribute(att, value);
-                            break;
-                    }
-                }
-            };
-            var Element = function (node, svg) {
-                var X = 0,
-                    Y = 0;
-                this[0] = node;
-                this.node = node;
-                this.svg = svg;
-                this.attrs = this.attrs || {};
-                this.transformations = []; // rotate, translate, scale
-                this._ = {
-                    tx: 0,
-                    ty: 0,
-                    rt: {deg: 0, x: 0, y: 0},
-                    sx: 1,
-                    sy: 1
-                };
-            };
-            Element.prototype.translate = function (x, y) {
-                if (x == undefined && y == undefined) {
-                    return {x: this._.tx, y: this._.ty};
-                }
-                this._.tx += +x;
-                this._.ty += +y;
-                switch (this.type) {
-                    case "circle":
-                    case "ellipse":
-                        this.attr({cx: this.attrs.cx + x, cy: this.attrs.cy + y});
-                        break;
-                    case "rect":
-                    case "image":
-                    case "text":
-                        this.attr({x: this.attrs.x + x, y: this.attrs.y + y});
-                        break;
-                    case "path":
-                        var path = Raphael.pathToRelative(this.attrs.path);
-                        path[0][1] += +x;
-                        path[0][2] += +y;
-                        this.attr({path: path.join(" ")});
-                    break;
-                }
-                return this;
-            };
-            Element.prototype.rotate = function (deg, isAbsolute) {
-                if (deg == undefined) {
-                    return this._.rt.deg;
-                }
-                var bbox = this.getBBox();
-                if (isAbsolute) {
-                    this._.rt.deg = deg;
-                } else {
-                    this._.rt.deg += deg;
-                }
 
-                if (this._.rt.deg) {
-                    this.transformations[0] = ("rotate(" + this._.rt.deg + " " + (bbox.x + bbox.width / 2) + " " + (bbox.y + bbox.height / 2) + ")");
-                } else {
-                    this.transformations[0] = "";
-                }
-                this.node.setAttribute("transform", this.transformations.join(" "));
-                return this;
-            };
-            Element.prototype.hide = function () {
-                this.node.style.display = "none";
-                return this;
+(function (R) {
+    R.version = "0.7";
+    R.idGenerator = 0;
+    R._ = {
+        paper: {},
+        element: {}
     };
-            Element.prototype.show = function () {
-                this.node.style.display = "block";
-                return this;
+    var availableAttrs = {cx: 0, cy: 0, fill: "#fff", "fill-opacity": 1, font: '16px "Arial"', "font-family": '"Arial"', "font-size": "16", gradient: 0, height: 0, opacity: 1, path: "M0,0", r: 0, rotation: 0, rx: 0, ry: 0, scale: "1 1", stroke: "#000", "stroke-dasharray": "", "stroke-linecap": "butt", "stroke-linejoin": "butt", "stroke-miterlimit": 0, "stroke-opacity": 1, "stroke-width": 1, translation: "0 0", width: 0, x: 0, y: 0},
+        availableAnimAttrs = {cx: "number", cy: "number", fill: "colour", "fill-opacity": "number", "font-size": "number", height: "number", opacity: "number", path: "path", r: "number", rotation: "number", rx: "number", ry: "number", scale: "csv", stroke: "colour", "stroke-opacity": "number", "stroke-width": "number", translation: "csv", width: "number", x: "number", y: "number"};
+    R._.paper.circle = function (x, y, r) {
+        return R._.theCircle(this, x, y, r);
     };
-            Element.prototype.remove = function () {
-                this.node.parentNode.removeChild(this.node);
+    R._.paper.rect = function (x, y, w, h, r) {
+        return R._.theRect(this, x, y, w, h, r);
     };
-            Element.prototype.getBBox = function () {
-                return this.node.getBBox();
+    R._.paper.ellipse = function (x, y, rx, ry) {
+        return R._.theEllipse(this, x, y, rx, ry);
     };
-            Element.prototype.attr = function () {
-                if (arguments.length == 1 && typeof arguments[0] == "string") {
-                    if (arguments[0] == "translation") {
-                        return this.translate();
-                    }
-                    return this.attrs[arguments[0]];
-                }
-                if (arguments.length == 1 && arguments[0] instanceof Array) {
-                    var values = {};
-                    for (var j in arguments[0]) {
-                        values[arguments[0][j]] = this.attrs[arguments[0][j]];
-                    }
-                    return values;
-                }
-                if (arguments.length == 2) {
-                    var params = {};
-                    params[arguments[0]] = arguments[1];
-                    setFillAndStroke(this, params);
-                } else if (arguments.length == 1 && typeof arguments[0] == "object") {
-                    setFillAndStroke(this, arguments[0]);
-                }
-                return this;
+    R._.paper.path = function (params, pathString) {
+        return R._.thePath(params, pathString, this);
     };
-            Element.prototype.toFront = function () {
-                this.node.parentNode.appendChild(this.node);
-                return this;
-            };
-            Element.prototype.toBack = function () {
-                if (this.node.parentNode.firstChild != this.node) {
-                    this.node.parentNode.insertBefore(this.node, this.node.parentNode.firstChild);
-                }
-                return this;
+    R._.paper.image = function (src, x, y, w, h) {
+        return R._.theImage(this, src, x, y, w, h);
     };
-            Element.prototype.insertAfter = function (element) {
-                if (element.node.nextSibling) {
-                    element.node.parentNode.insertBefore(this.node, element.node.nextSibling);
-                } else {
-                    element.node.parentNode.appendChild(this.node);
-                }
-                return this;
+    R._.paper.text = function (x, y, text) {
+        return R._.theText(this, x, y, text);
     };
-            Element.prototype.insertBefore = function (element) {
-                element.node.parentNode.insertBefore(this.node, element.node);
+    R._.paper.group = function () {
         return this;
     };
-            var theCircle = function (svg, x, y, r) {
-                var el = document.createElementNS(svg.svgns, "circle");
-                el.setAttribute("cx", x);
-                el.setAttribute("cy", y);
-                el.setAttribute("r", r);
-                el.setAttribute("fill", "none");
-                el.setAttribute("stroke", "#000");
-                if (svg.canvas) {
-                    svg.canvas.appendChild(el);
-                }
-                var res = new Element(el, svg);
-                res.attrs = res.attrs || {};
-                res.attrs.cx = x;
-                res.attrs.cy = y;
-                res.attrs.r = r;
-                res.attrs.stroke = "#000";
-                res.type = "circle";
-                return res;
-            };
-            var theRect = function (svg, x, y, w, h, r) {
-                var el = document.createElementNS(svg.svgns, "rect");
-                el.setAttribute("x", x);
-                el.setAttribute("y", y);
-                el.setAttribute("width", w);
-                el.setAttribute("height", h);
-                if (r) {
-                    el.setAttribute("rx", r);
-                    el.setAttribute("ry", r);
-                }
-                el.setAttribute("fill", "none");
-                el.setAttribute("stroke", "#000");
-                if (svg.canvas) {
-                    svg.canvas.appendChild(el);
-                }
-                var res = new Element(el, svg);
-                res.attrs = res.attrs || {};
-                res.attrs.x = x;
-                res.attrs.y = y;
-                res.attrs.width = w;
-                res.attrs.height = h;
-                res.attrs.stroke = "#000";
-                if (r) {
-                    res.attrs.rx = res.attrs.ry = r;
-                }
-                res.type = "rect";
-                return res;
-            };
-            var theEllipse = function (svg, x, y, rx, ry) {
-                var el = document.createElementNS(svg.svgns, "ellipse");
-                el.setAttribute("cx", x);
-                el.setAttribute("cy", y);
-                el.setAttribute("rx", rx);
-                el.setAttribute("ry", ry);
-                el.setAttribute("fill", "none");
-                el.setAttribute("stroke", "#000");
-                if (svg.canvas) {
-                    svg.canvas.appendChild(el);
-                }
-                var res = new Element(el, svg);
-                res.attrs = res.attrs || {};
-                res.attrs.cx = x;
-                res.attrs.cy = y;
-                res.attrs.rx = rx;
-                res.attrs.ry = ry;
-                res.attrs.stroke = "#000";
-                res.type = "ellipse";
-                return res;
-            };
-            var theImage = function (svg, src, x, y, w, h) {
-                var el = document.createElementNS(svg.svgns, "image");
-                el.setAttribute("x", x);
-                el.setAttribute("y", y);
-                el.setAttribute("width", w);
-                el.setAttribute("height", h);
-                el.setAttribute("preserveAspectRatio", "none");
-                el.setAttributeNS(svg.xlink, "href", src);
-                if (svg.canvas) {
-                    svg.canvas.appendChild(el);
-                }
-                var res = new Element(el, svg);
-                res.attrs = res.attrs || {};
-                res.attrs.x = x;
-                res.attrs.y = y;
-                res.attrs.width = w;
-                res.attrs.height = h;
-                res.type = "image";
-                return res;
-            };
-            var theText = function (svg, x, y, text) {
-                var el = document.createElementNS(svg.svgns, "text");
-                el.setAttribute("x", x);
-                el.setAttribute("y", y);
-                el.setAttribute("text-anchor", "middle");
-                el.setAttribute("fill", "#000");
-                if (text) {
-                    el.appendChild(document.createTextNode(text));
-                }
-                if (svg.canvas) {
-                    svg.canvas.appendChild(el);
-                }
-                var res = new Element(el, svg);
-                res.attrs = res.attrs || {};
-                res.attrs.x = x;
-                res.attrs.y = y;
-                res.attrs.fill = "#000";
-                res.type = "text";
-                return res;
-            };
-            var theGroup = function (svg) {
-                var el = document.createElementNS(svg.svgns, "g");
-                if (svg.canvas) {
-                    svg.canvas.appendChild(el);
-                }
-                var i = new Element(el, svg);
-                for (var f in svg) {
-                    if (f[0] != "_" && typeof svg[f] == "function") {
-                        i[f] = (function (f) {
-                            return function () {
-                                var e = svg[f].apply(svg, arguments);
-                                el.appendChild(e[0]);
-                                return e;
-                            };
-                        })(f);
-                    }
-                }
-                i.type = "group";
-                return i;
-            };
-            r._create = function () {
-                // container, width, height
-                // x, y, width, height
-                if (typeof arguments[0] == "string") {
-                    var container = document.getElementById(arguments[0]);
-                    var width = arguments[1];
-                    var height = arguments[2];
-                }
-                if (typeof arguments[0] == "object") {
-                    var container = arguments[0];
-                    var width = arguments[1];
-                    var height = arguments[2];
-                }
-                if (typeof arguments[0] == "number") {
-                    var container = 1,
-                        x = arguments[0],
-                        y = arguments[1],
-                        width = arguments[2],
-                        height = arguments[3];
-                }
-                if (!container) {
-                    throw new Error("SVG container not found.");
-                }
-                C.canvas = document.createElementNS(C.svgns, "svg");
-                C.canvas.setAttribute("width", width || 320);
-                C.width = width || 320;
-                C.canvas.setAttribute("height", height || 200);
-                C.height = height || 200;
-                if (container == 1) {
-                    document.body.appendChild(C.canvas);
-                    C.canvas.style.position = "absolute";
-                    C.canvas.style.left = x + "px";
-                    C.canvas.style.top = y + "px";
-                } else {
-                    if (container.firstChild) {
-                        container.insertBefore(C.canvas, container.firstChild);
-                    } else {
-                        container.appendChild(C.canvas);
-                    }
-                }
-                container = {
-                    canvas: C.canvas,
-                    clear: function () {
-                        while (this.canvas.firstChild) {
-                            this.canvas.removeChild(this.canvas.firstChild);
-                        }
-                        this.defs = document.createElementNS(C.svgns, "defs");
-                        this.gradients = 0;
-                        this.canvas.appendChild(this.defs);
-                    }
-                };
-                for (var prop in C) {
-                    if (prop != "create") {
-                        container[prop] = C[prop];
-                    }
-                }
-                container.clear();
-                return container;
-            };
-            C.remove = function () {
-                C.canvas.parentNode.removeChild(C.canvas);
-            };
-            C.svgns = "http://www.w3.org/2000/svg";
-            C.xlink = "http://www.w3.org/1999/xlink";
-        }
-        if (type == "VML" || type == "SVG") {
-            C.circle = function (x, y, r) {
-                return theCircle(this, x, y, r);
-            };
-            C.rect = function (x, y, w, h, r) {
-                return theRect(this, x, y, w, h, r);
-            };
-            C.ellipse = function (x, y, rx, ry) {
-                return theEllipse(this, x, y, rx, ry);
-            };
-            C.path = function (params, pathString) {
-                return thePath(params, pathString, this);
-            };
-            C.image = function (src, x, y, w, h) {
-                return theImage(this, src, x, y, w, h);
-            };
-            C.text = function (x, y, text) {
-                return theText(this, x, y, text);
-            };
-            C.group = function () {
-                return theGroup(this);
-            };
-            C.drawGrid = function (x, y, w, h, wv, hv, color) {
+    R._.paper.drawGrid = function (x, y, w, h, wv, hv, color) {
         color = color || "#000";
         var p = this.path({stroke: color, "stroke-width": 1})
                 .moveTo(x, y).lineTo(x + w, y).lineTo(x + w, y + h).lineTo(x, y + h).lineTo(x, y),
@@ -1514,16 +53,10 @@ var Raphael = (function (type) {
         }
         return p;
     };
-            C.safari = function () {
-                if (navigator.vendor == "Apple Computer, Inc.") {
-                    var rect = C.rect(-C.width, -C.height, C.width * 3, C.height * 3).attr({stroke: "none"});
-                    setTimeout(function () {rect.remove();}, 0);
-                }
-            };
-            Element.prototype.stop = function () {
+    R._.element.stop = function () {
         clearTimeout(this.animation_in_progress);
     };
-            Element.prototype.scale = function (x, y) {
+    R._.element.scale = function (x, y) {
         if (x == undefined && y == undefined) {
             return {x: this._.sx, y: this._.sy};
         }
@@ -1615,7 +148,7 @@ var Raphael = (function (type) {
         this._.sy = y;
         return this;
     };
-            Element.prototype.animate = function (params, ms, callback) {
+    R._.element.animate = function (params, ms, callback) {
         clearTimeout(this.animation_in_progress);
         var from = {}, to = {}, diff = {}, t = {x: 0, y: 0};
         for (var attr in params) {
@@ -1714,22 +247,21 @@ var Raphael = (function (type) {
                 }
                 that.attr(set);
                 that.animation_in_progress = setTimeout(arguments.callee, 0);
-                        C.safari();
+                R._.paper.safari();
             } else {
                 if (t.x || t.y) {
                     that.translate(-t.x, -t.y);
                 }
                 that.attr(params);
                 clearTimeout(that.animation_in_progress);
-                        C.safari();
+                R._.paper.safari();
                 (typeof callback == "function") && callback.call(that);
             }
             prev = time;
         })();
         return this;
     };
-            
-            C.pathfinder = function (p, path) {
+    R._.paper.pathfinder = function (p, path) {
         var commands = {
             M: function (x, y) {
                 this.moveTo(x, y);
@@ -1769,24 +301,13 @@ var Raphael = (function (type) {
             commands[b].apply(p, path[i]);
         }
     };
-            return r;
-        } else {
-            return function () {};
-        }
-    })((!window.SVGAngle) ? "VML" : "SVG");
 
-
-Raphael.vml = !(Raphael.svg = (Raphael.type == "SVG"));
-if (Raphael.vml && window.CanvasRenderingContext2D) {
-    Raphael.type = "Canvas only";
-    Raphael.vml = Raphael.svg = false;
-}
-Raphael.toString = function () {
+    R.toString = function () {
         return  "Your browser " + (this.vml ? "doesn't ": "") + "support" + (this.svg ? "s": "") +
                 " SVG.\nYou are running " + unescape("Rapha%EBl%20") + this.version;
-};
-// generic utilities
-Raphael.hsb2rgb = function (hue, saturation, brightness) {
+    };
+    // generic utilities
+    R.hsb2rgb = function (hue, saturation, brightness) {
         if (typeof hue == "object" && "h" in hue && "s" in hue && "b" in hue) {
             brightness = hue.b;
             saturation = hue.s;
@@ -1831,8 +352,8 @@ Raphael.hsb2rgb = function (hue, saturation, brightness) {
         }
         rgb.hex = "#" + r + g + b;
         return rgb;
-};
-Raphael.rgb2hsb = function (red, green, blue) {
+    };
+    R.rgb2hsb = function (red, green, blue) {
         if (typeof red == "object" && "r" in red && "g" in red && "b" in red) {
             blue = red.b;
             green = red.g;
@@ -1880,8 +401,8 @@ Raphael.rgb2hsb = function (red, green, blue) {
             }
         }
         return {h: hue, s: saturation, b: brightness};
-};
-Raphael.getRGB = function (colour) {
+    };
+    R.getRGB = function (colour) {
         var red, green, blue,
             rgb = colour.match(/^\s*((#[a-f\d]{6})|(#[a-f\d]{3})|rgb\(\s*(\d+,\s*\d+,\s*\d+)\s*\)|rgb\(\s*(\d+%,\s*\d+%,\s*\d+%)\s*\)|hsb\(\s*(\d+,\s*\d+,\s*\d+)\s*\)|hsb\(\s*(\d+%,\s*\d+%,\s*\d+%)\s*\))\s*$/i);
         if (rgb) {
@@ -1931,8 +452,8 @@ Raphael.getRGB = function (colour) {
             rgb.hex = "#" + r + g + b;
             return rgb;
         }
-};
-Raphael.getColor = function (value) {
+    };
+    R.getColor = function (value) {
         var start = arguments.callee.start = arguments.callee.start || {h: 0, s: 1, b: value || .75};
         var rgb = this.hsb2rgb(start.h, start.s, start.b);
         start.h += .075;
@@ -1944,11 +465,11 @@ Raphael.getColor = function (value) {
             }
         }
         return rgb.hex;
-};
-Raphael.getColor.reset = function () {
+    };
+    R.getColor.reset = function () {
         this.start = undefined;
-};
-Raphael.parsePathString = function (pathString) {
+    };
+    R.parsePathString = function (pathString) {
         var paramCounts = {a: 7, c: 6, h: 1, l: 2, m: 2, q: 4, s: 4, t: 2, v: 1, z: 0},
             data = [],
             toString = function () {
@@ -1975,8 +496,8 @@ Raphael.parsePathString = function (pathString) {
         });
         data.toString = toString;
         return data;
-};
-Raphael.pathDimensions = function (path) {
+    };
+    R.pathDimensions = function (path) {
         var pathArray = path;
         if (typeof path == "string") {
             pathArray = this.parsePathString(path);
@@ -2011,8 +532,8 @@ Raphael.pathDimensions = function (path) {
             X: x,
             Y: y
         };
-};
-Raphael.pathToRelative = function (pathArray) {
+    };
+    R.pathToRelative = function (pathArray) {
         var res = [];
         if (typeof pathArray == "string") {
             pathArray = this.parsePathString(pathArray);
@@ -2065,8 +586,8 @@ Raphael.pathToRelative = function (pathArray) {
         }
         res.toString = pathArray.toString;
         return res;
-};
-Raphael.pathToAbsolute = function (pathArray) {
+    };
+    R.pathToAbsolute = function (pathArray) {
         var res = [];
         if (typeof pathArray == "string") {
             pathArray = this.parsePathString(pathArray);
@@ -2119,8 +640,8 @@ Raphael.pathToAbsolute = function (pathArray) {
         }
         res.toString = pathArray.toString;
         return res;
-};
-Raphael.pathEqualiser = function (path1, path2) {
+    };
+    R.pathEqualiser = function (path1, path2) {
         var data = [this.pathToAbsolute(this.parsePathString(path1)), this.pathToAbsolute(this.parsePathString(path2))],
             attrs = [{x: 0, y: 0, bx: 0, by: 0, X: 0, Y: 0}, {x: 0, y: 0, bx: 0, by: 0, X: 0, Y: 0}],
             processPath = function (path, d) {
@@ -2212,4 +733,12 @@ Raphael.pathEqualiser = function (path1, path2) {
             attrs[1].y = data[1][i][data[1][i].length - 1];
         }
         return data;
-};
+    };
+
+    var script = document.getElementsByTagName("script"),
+        newscript = document.createElement("script");
+    script = script[script.length - 1];
+    newscript.type = "text/javascript";
+    newscript.src = window.SVGAngle ? "raphael-svg.js" : "raphael-vml.js";
+    script.parentNode.appendChild(newscript);
+})(Raphael);