projects / raphael / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Fixed rotation bug
[raphael] / raphael.js
1 /*
2  * Raphael 1.0 - JavaScript Vector Library
3  *
4  * Copyright (c) 2008 - 2009 Dmitry Baranovskiy (http://raphaeljs.com)
5  * Licensed under the MIT (http://www.opensource.org/licenses/mit-license.php) license.
6  */
7
8
9 window.Raphael = (function () {
10     var separator = /[, ]+/,
11         doc = document,
12         win = window,
13         oldRaphael = {
14             was: "Raphael" in window,
15             is: window.Raphael
16         },
17         R = function () {
18             return create.apply(R, arguments);
19         },
20         paper = {},
21         availableAttrs = {cx: 0, cy: 0, fill: "#fff", "fill-opacity": 1, font: '10px "Arial"', "font-family": '"Arial"', "font-size": "10", "font-style": "normal", "font-weight": 400, gradient: 0, height: 0, href: "http://raphaeljs.com/", opacity: 1, path: "M0,0", r: 0, rotation: 0, rx: 0, ry: 0, scale: "1 1", src: "", stroke: "#000", "stroke-dasharray": "", "stroke-linecap": "butt", "stroke-linejoin": "butt", "stroke-miterlimit": 0, "stroke-opacity": 1, "stroke-width": 1, target: "_blank", "text-anchor": "middle", title: "Raphael", translation: "0 0", width: 0, x: 0, y: 0},
22         availableAnimAttrs = {cx: "number", cy: "number", fill: "colour", "fill-opacity": "number", "font-size": "number", height: "number", opacity: "number", path: "path", r: "number", rotation: "csv", rx: "number", ry: "number", scale: "csv", stroke: "colour", "stroke-opacity": "number", "stroke-width": "number", translation: "csv", width: "number", x: "number", y: "number"},
23         events = ["click", "dblclick", "mousedown", "mousemove", "mouseout", "mouseover", "mouseup"];
24     R.version = "1.0";
25     R.type = (window.SVGAngle || document.implementation.hasFeature("http://www.w3.org/TR/SVG11/feature#BasicStructure", "1.1") ? "SVG" : "VML");
26     R.svg = !(R.vml = R.type == "VML");
27     R.idGenerator = 0;
28     R.fn = {};
29     R.isArray = function (arr) {
30         return Object.prototype.toString.call(arr) == "[object Array]";
31     };
32     R.setWindow = function (newwin) {
33         win = newwin;
34         doc = win.document;
35     };
36     // colour utilities
37     R.hsb2rgb = function (hue, saturation, brightness) {
38         if (typeof hue == "object" && "h" in hue && "s" in hue && "b" in hue) {
39             brightness = hue.b;
40             saturation = hue.s;
41             hue = hue.h;
42         }
43         var red,
44             green,
45             blue;
46         if (brightness == 0) {
47             return {r: 0, g: 0, b: 0, hex: "#000"};
48         }
49         if (hue > 1 || saturation > 1 || brightness > 1) {
50             hue /= 255;
51             saturation /= 255;
52             brightness /= 255;
53         }
54         var i = Math.floor(hue * 6),
55             f = (hue * 6) - i,
56             p = brightness * (1 - saturation),
57             q = brightness * (1 - (saturation * f)),
58             t = brightness * (1 - (saturation * (1 - f)));
59         red = [brightness, q, p, p, t, brightness, brightness][i];
60         green = [t, brightness, brightness, q, p, p, t][i];
61         blue = [p, p, t, brightness, brightness, q, p][i];
62         red *= 255;
63         green *= 255;
64         blue *= 255;
65         var rgb = {r: red, g: green, b: blue},
66             r = Math.round(red).toString(16),
67             g = Math.round(green).toString(16),
68             b = Math.round(blue).toString(16);
69         if (r.length == 1) {
70             r = "0" + r;
71         }
72         if (g.length == 1) {
73             g = "0" + g;
74         }
75         if (b.length == 1) {
76             b = "0" + b;
77         }
78         rgb.hex = "#" + r + g + b;
79         return rgb;
80     };
81     R.rgb2hsb = function (red, green, blue) {
82         if (typeof red == "object" && "r" in red && "g" in red && "b" in red) {
83             blue = red.b;
84             green = red.g;
85             red = red.r;
86         }
87         if (typeof red == "string") {
88             var clr = R.getRGB(red);
89             red = clr.r;
90             green = clr.g;
91             blue = clr.b;
92         }
93         if (red > 1 || green > 1 || blue > 1) {
94             red /= 255;
95             green /= 255;
96             blue /= 255;
97         }
98         var max = Math.max(red, green, blue),
99             min = Math.min(red, green, blue),
100             hue,
101             saturation,
102             brightness = max;
103         if (min == max) {
104             return {h: 0, s: 0, b: max};
105         } else {
106             var delta = (max - min);
107             saturation = delta / max;
108             if (red == max) {
109                 hue = (green - blue) / delta;
110             } else if (green == max) {
111                 hue = 2 + ((blue - red) / delta);
112             } else {
113                 hue = 4 + ((red - green) / delta);
114             }
115             hue /= 6;
116             if (hue < 0) {
117                 hue += 1;
118             }
119             if (hue > 1) {
120                 hue -= 1;
121             }
122         }
123         return {h: hue, s: saturation, b: brightness};
124     };
125     var getRGBcache = {},
126         getRGBcount = [];
127     R.getRGB = function (colour) {
128         if (colour in getRGBcache) {
129             return getRGBcache[colour];
130         }
131         var htmlcolors = {aliceblue: "#f0f8ff", amethyst: "#96c", antiquewhite: "#faebd7", aqua: "#0ff", aquamarine: "#7fffd4", azure: "#f0ffff", beige: "#f5f5dc", bisque: "#ffe4c4", black: "#000", blanchedalmond: "#ffebcd", blue: "#00f", blueviolet: "#8a2be2", brown: "#a52a2a", burlywood: "#deb887", cadetblue: "#5f9ea0", chartreuse: "#7fff00", chocolate: "#d2691e", coral: "#ff7f50", cornflowerblue: "#6495ed", cornsilk: "#fff8dc", crimson: "#dc143c", cyan: "#0ff", darkblue: "#00008b", darkcyan: "#008b8b", darkgoldenrod: "#b8860b", darkgray: "#a9a9a9", darkgreen: "#006400", darkkhaki: "#bdb76b", darkmagenta: "#8b008b", darkolivegreen: "#556b2f", darkorange: "#ff8c00", darkorchid: "#9932cc", darkred: "#8b0000", darksalmon: "#e9967a", darkseagreen: "#8fbc8f", darkslateblue: "#483d8b", darkslategray: "#2f4f4f", darkturquoise: "#00ced1", darkviolet: "#9400d3", deeppink: "#ff1493", deepskyblue: "#00bfff", dimgray: "#696969", dodgerblue: "#1e90ff", firebrick: "#b22222", floralwhite: "#fffaf0", forestgreen: "#228b22", fuchsia: "#f0f", gainsboro: "#dcdcdc", ghostwhite: "#f8f8ff", gold: "#ffd700", goldenrod: "#daa520", gray: "#808080", green: "#008000", greenyellow: "#adff2f", honeydew: "#f0fff0", hotpink: "#ff69b4", indianred: "#cd5c5c", indigo: "#4b0082", ivory: "#fffff0", khaki: "#f0e68c", lavender: "#e6e6fa", lavenderblush: "#fff0f5", lawngreen: "#7cfc00", lemonchiffon: "#fffacd", lightblue: "#add8e6", lightcoral: "#f08080", lightcyan: "#e0ffff", lightgoldenrodyellow: "#fafad2", lightgreen: "#90ee90", lightgrey: "#d3d3d3", lightpink: "#ffb6c1", lightsalmon: "#ffa07a", lightsalmon: "#ffa07a", lightseagreen: "#20b2aa", lightskyblue: "#87cefa", lightslategray: "#789", lightsteelblue: "#b0c4de", lightyellow: "#ffffe0", lime: "#0f0", limegreen: "#32cd32", linen: "#faf0e6", magenta: "#f0f", maroon: "#800000", mediumaquamarine: "#66cdaa", mediumblue: "#0000cd", mediumorchid: "#ba55d3", mediumpurple: "#9370db", mediumseagreen: "#3cb371", mediumslateblue: "#7b68ee", mediumslateblue: "#7b68ee", mediumspringgreen: "#00fa9a", mediumturquoise: "#48d1cc", mediumvioletred: "#c71585", midnightblue: "#191970", mintcream: "#f5fffa", mistyrose: "#ffe4e1", moccasin: "#ffe4b5", navajowhite: "#ffdead", navy: "#000080", oldlace: "#fdf5e6", olive: "#808000", olivedrab: "#6b8e23", orange: "#ffa500", orangered: "#ff4500", orchid: "#da70d6", palegoldenrod: "#eee8aa", palegreen: "#98fb98", paleturquoise: "#afeeee", palevioletred: "#db7093", papayawhip: "#ffefd5", peachpuff: "#ffdab9", peru: "#cd853f", pink: "#ffc0cb", plum: "#dda0dd", powderblue: "#b0e0e6", purple: "#800080", red: "#f00", rosybrown: "#bc8f8f", royalblue: "#4169e1", saddlebrown: "#8b4513", salmon: "#fa8072", sandybrown: "#f4a460", seagreen: "#2e8b57", seashell: "#fff5ee", sienna: "#a0522d", silver: "#c0c0c0", skyblue: "#87ceeb", slateblue: "#6a5acd", slategray: "#708090", snow: "#fffafa", springgreen: "#00ff7f", steelblue: "#4682b4", tan: "#d2b48c", teal: "#008080", thistle: "#d8bfd8", tomato: "#ff6347", turquoise: "#40e0d0", violet: "#ee82ee", wheat: "#f5deb3", white: "#fff", whitesmoke: "#f5f5f5", yellow: "#ff0", yellowgreen: "#9acd32"},
132         res;
133         if ((colour + "").toLowerCase() in htmlcolors) {
134             colour = htmlcolors[colour.toString().toLowerCase()];
135         }
136         if (!colour) {
137             return {r: 0, g: 0, b: 0, hex: "#000"};
138         }
139         if (colour == "none") {
140             return {r: -1, g: -1, b: -1, hex: "none"};
141         }
142         var red,
143             green,
144             blue,
145             rgb = (colour + "").match(/^\s*((#[a-f\d]{6})|(#[a-f\d]{3})|rgb\(\s*([\d\.]+\s*,\s*[\d\.]+\s*,\s*[\d\.]+)\s*\)|rgb\(\s*([\d\.]+%\s*,\s*[\d\.]+%\s*,\s*[\d\.]+%)\s*\)|hsb\(\s*([\d\.]+\s*,\s*[\d\.]+\s*,\s*[\d\.]+)\s*\)|hsb\(\s*([\d\.]+%\s*,\s*[\d\.]+%\s*,\s*[\d\.]+%)\s*\))\s*$/i);
146         if (rgb) {
147             if (rgb[2]) {
148                 blue = parseInt(rgb[2].substring(5), 16);
149                 green = parseInt(rgb[2].substring(3, 5), 16);
150                 red = parseInt(rgb[2].substring(1, 3), 16);
151             }
152             if (rgb[3]) {
153                 blue = parseInt(rgb[3].substring(3) + rgb[3].substring(3), 16);
154                 green = parseInt(rgb[3].substring(2, 3) + rgb[3].substring(2, 3), 16);
155                 red = parseInt(rgb[3].substring(1, 2) + rgb[3].substring(1, 2), 16);
156             }
157             if (rgb[4]) {
158                 rgb = rgb[4].split(/\s*,\s*/);
159                 red = parseFloat(rgb[0]);
160                 green = parseFloat(rgb[1]);
161                 blue = parseFloat(rgb[2]);
162             }
163             if (rgb[5]) {
164                 rgb = rgb[5].split(/\s*,\s*/);
165                 red = parseFloat(rgb[0]) * 2.55;
166                 green = parseFloat(rgb[1]) * 2.55;
167                 blue = parseFloat(rgb[2]) * 2.55;
168             }
169             if (rgb[6]) {
170                 rgb = rgb[6].split(/\s*,\s*/);
171                 red = parseFloat(rgb[0]);
172                 green = parseFloat(rgb[1]);
173                 blue = parseFloat(rgb[2]);
174                 return R.hsb2rgb(red, green, blue);
175             }
176             if (rgb[7]) {
177                 rgb = rgb[7].split(/\s*,\s*/);
178                 red = parseFloat(rgb[0]) * 2.55;
179                 green = parseFloat(rgb[1]) * 2.55;
180                 blue = parseFloat(rgb[2]) * 2.55;
181                 return R.hsb2rgb(red, green, blue);
182             }
183             var rgb = {r: red, g: green, b: blue},
184                 r = Math.round(red).toString(16),
185                 g = Math.round(green).toString(16),
186                 b = Math.round(blue).toString(16);
187             (r.length == 1) && (r = "0" + r);
188             (g.length == 1) && (g = "0" + g);
189             (b.length == 1) && (b = "0" + b);
190             rgb.hex = "#" + r + g + b;
191             res = rgb;
192         } else {
193             res = {r: -1, g: -1, b: -1, hex: "none"};
194         }
195         if (getRGBcount.length > 20) {
196             delete getRGBcache[getRGBcount.unshift()];
197         }
198         getRGBcount.push(colour);
199         getRGBcache[colour] = res;
200         return res;
201     };
202     R.getColor = function (value) {
203         var start = this.getColor.start = this.getColor.start || {h: 0, s: 1, b: value || .75},
204             rgb = this.hsb2rgb(start.h, start.s, start.b);
205         start.h += .075;
206         if (start.h > 1) {
207             start.h = 0;
208             start.s -= .2;
209             if (start.s <= 0) {
210                 this.getColor.start = {h: 0, s: 1, b: start.b};
211             }
212         }
213         return rgb.hex;
214     };
215     R.getColor.reset = function () {
216         delete this.start;
217     };
218     // path utilities
219     var pathMethods = {
220         absolutely: function () {
221             this.isAbsolute = true;
222             return this;
223         },
224         relatively: function () {
225             this.isAbsolute = false;
226             return this;
227         },
228         moveTo: function (x, y) {
229             var d = this.isAbsolute ? "M" : "m";
230             d += +parseFloat(x).toFixed(3) + " " + (+parseFloat(y).toFixed(3)) + " ";
231             this.attr({path: this.attrs.path + d});
232             return this;
233         },
234         lineTo: function (x, y) {
235             var d = this.isAbsolute ? "L" : "l";
236             d += +parseFloat(x).toFixed(3) + " " + (+parseFloat(y).toFixed(3)) + " ";
237             this.attr({path: this.attrs.path + d});
238             return this;
239         },
240         arcTo: function (rx, ry, large_arc_flag, sweep_flag, x, y) {
241             var d = this.isAbsolute ? "A" : "a";
242             d += [+parseFloat(rx).toFixed(3), +parseFloat(ry).toFixed(3), 0, large_arc_flag, sweep_flag, +parseFloat(x).toFixed(3), +parseFloat(y).toFixed(3)].join(" ");
243             this.attr({path: this.attrs.path + d});
244             return this;
245         },
246         curveTo: function () {
247             var args = Array.prototype.splice.call(arguments, 0, arguments.length),
248                 d = [0, 0, 0, 0, "s", 0, "c"][args.length] || "";
249             if (this.isAbsolute) {
250                 d = d.toUpperCase();
251             }
252             this.attr({path: this.attrs.path + d + args});
253             return this;
254         },
255         qcurveTo: function () {
256             var d = [0, 1, "t", 3, "q"][arguments.length],
257                 args = Array.prototype.splice.call(arguments, 0, arguments.length);
258             if (this.isAbsolute) {
259                 d = d.toUpperCase();
260             }
261             this.attr({path: this.attrs.path + d + args});
262             return this;
263         },
264         addRoundedCorner: function (r, dir) {
265             var rollback = this.isAbsolute,
266                 o = this;
267             if (rollback) {
268                 this.relatively();
269                 rollback = function () {
270                     o.absolutely();
271                 };
272             } else {
273                 rollback = function () {};
274             }
275             this.arcTo(r, r, 0, {"lu": 1, "rd": 1, "ur": 1, "dl": 1}[dir] || 0, r * (!!(dir.indexOf("r") + 1) * 2 - 1), r * (!!(dir.indexOf("d") + 1) * 2 - 1));
276             rollback();
277             return this;
278         },
279         andClose: function () {
280             this.attr({path: this.attrs.path + "z"});
281             return this;
282         },
283         getPathArray: function () {
284             return R.parsePathString(this.attrs.path);
285         }
286     };
287     var pathcache = {},
288         path2string = function () {
289             var res = "";
290             for (var i = 0, ii = this.length; i < ii; i++) {
291                 res += this[i][0] + this[i].join(",").substring(2);
292             }
293             return res.replace(/,(?=-)/g, "");
294         },
295         pathcount = [];
296     R.parsePathString = function (pathString) {
297         if (pathString in pathcache) {
298             return pathcache[pathString];
299         }
300         var paramCounts = {a: 7, c: 6, h: 1, l: 2, m: 2, q: 4, s: 4, t: 2, v: 1, z: 0},
301             data = [];
302         if (pathString.toString == path2string) {
303             data = pathString;
304         }
305         if (!data.length) {
306             (pathString + "").replace(/([achlmqstvz])[\s,]*((-?\d*\.?\d*(?:e[-+]?\d+)?\s*,?\s*)+)/ig, function (a, b, c) {
307                 var params = [],
308                     name = b.toLowerCase();
309                 c.replace(/(-?\d*\.?\d*(?:e[-+]?\d+)?)\s*,?\s*/ig, function (a, b) {
310                     b && params.push(+b);
311                 });
312                 while (params.length >= paramCounts[name]) {
313                     data.push([b].concat(params.splice(0, paramCounts[name])));
314                     if (!paramCounts[name]) {
315                         break;
316                     };
317                 }
318             });
319             data.toString = path2string;
320         }
321         if (pathcount.length > 20) {
322             delete pathcache[pathcount.unshift()];
323         }
324         pathcount.push(pathString);
325         pathcache[pathString] = data;
326         return data;
327     };
328     var pathDimensions = function (path) {
329         var pathArray = path;
330         pathArray = pathToAbsolute(pathArray);
331         var x = [],
332             y = [],
333             length = 0;
334         for (var i = 0, ii = pathArray.length; i < ii; i++) {
335             var pa = pathArray[i];
336             switch (pa[0]) {
337                 case "Z":
338                     break;
339                 case "A":
340                     x.push(pa[pa.length - 2]);
341                     y.push(pa[pa.length - 1]);
342                     break;
343                 default:
344                     for (var j = 1, jj = pa.length; j < jj; j++) {
345                         (j % 2 ? x : y).push(pa[j]);
346                     }
347             }
348         }
349         var minx = Math.min.apply(Math, x),
350             miny = Math.min.apply(Math, y);
351         if (!x.length) {
352             return {
353                 x: 0,
354                 y: 0,
355                 width: 0,
356                 height: 0,
357                 X: 0,
358                 Y: 0
359             };
360         } else {
361             return {
362                 x: minx,
363                 y: miny,
364                 width: Math.max.apply(Math, x) - minx,
365                 height: Math.max.apply(Math, y) - miny,
366                 X: x,
367                 Y: y
368             };
369         }
370     },
371         pathToRelative = function (pathArray) {
372             var res = [],
373                 x = 0,
374                 y = 0,
375                 start = 0;
376             if (typeof pathArray == "string") {
377                 pathArray = R.parsePathString(pathArray);
378             }
379             if (pathArray[0][0] == "M") {
380                 x = pathArray[0][1];
381                 y = pathArray[0][2];
382                 start++;
383                 res.push(["M", x, y]);
384             }
385             for (var i = start, ii = pathArray.length; i < ii; i++) {
386                 var r = res[i] = [],
387                     pa = pathArray[i];
388                 if (pa[0] != pa[0].toLowerCase()) {
389                     r[0] = pa[0].toLowerCase();
390                     switch (r[0]) {
391                         case "a":
392                             r[1] = pa[1];
393                             r[2] = pa[2];
394                             r[3] = pa[3];
395                             r[4] = pa[4];
396                             r[5] = pa[5];
397                             r[6] = +(pa[6] - x).toFixed(3);
398                             r[7] = +(pa[7] - y).toFixed(3);
399                             break;
400                         case "v":
401                             r[1] = +(pa[1] - y).toFixed(3);
402                             break;
403                         default:
404                             for (var j = 1, jj = pa.length; j < jj; j++) {
405                                 r[j] = +(pa[j] - ((j % 2) ? x : y)).toFixed(3);
406                             }
407                     }
408                 } else {
409                     r = res[i] = [];
410                     for (var k = 0, kk = pa.length; k < kk; k++) {
411                         res[i][k] = pa[k];
412                     }
413                 }
414                 var len = res[i].length;
415                 switch (res[i][0]) {
416                     case "z":
417                         break;
418                     case "h":
419                         x += +res[i][len - 1];
420                         break;
421                     case "v":
422                         y += +res[i][len - 1];
423                         break;
424                     default:
425                         x += +res[i][len - 2];
426                         y += +res[i][len - 1];
427                 }
428             }
429             res.toString = pathArray.toString;
430             return res;
431         },
432         pathToAbsolute = function (pathArray) {
433             var res = [],
434                 x = 0,
435                 y = 0,
436                 start = 0;
437             if (typeof pathArray == "string") {
438                 pathArray = R.parsePathString(pathArray);
439             }
440             if (pathArray[0][0] == "M") {
441                 x = +pathArray[0][1];
442                 y = +pathArray[0][2];
443                 start++;
444                 res[0] = ["M", x, y];
445             }
446             for (var i = start, ii = pathArray.length; i < ii; i++) {
447                 var r = res[i] = [],
448                     pa = pathArray[i];
449                 if (pa[0] != (pa[0] + "").toUpperCase()) {
450                     r[0] = (pa[0] + "").toUpperCase();
451                     switch (r[0]) {
452                         case "A":
453                             r[1] = pa[1];
454                             r[2] = pa[2];
455                             r[3] = 0;
456                             r[4] = pa[4];
457                             r[5] = pa[5];
458                             r[6] = +(pa[6] + x).toFixed(3);
459                             r[7] = +(pa[7] + y).toFixed(3);
460                             break;
461                         case "V":
462                             r[1] = +pa[1] + y;
463                             break;
464                         case "H":
465                             r[1] = +pa[1] + x;
466                             break;
467                         default:
468                             for (var j = 1, jj = pa.length; j < jj; j++) {
469                                 r[j] = +pa[j] + ((j % 2) ? x : y);
470                             }
471                     }
472                 } else {
473                     r = res[i] = [];
474                     for (var k = 0, kk = pa.length; k < kk; k++) {
475                         res[i][k] = pa[k];
476                     }
477                 }
478                 switch (r[0]) {
479                     case "Z":
480                         break;
481                     case "H":
482                         x = r[1];
483                         break;
484                     case "V":
485                         y = r[1];
486                         break;
487                     default:
488                         x = res[i][res[i].length - 2];
489                         y = res[i][res[i].length - 1];
490                 }
491             }
492             res.toString = pathArray.toString;
493             return res;
494         },
495         l2c = function (x1, y1, x2, y2) {
496             return [x1, y1, x2, y2, x2, y2];
497         },
498         q2c = function (x1, y1, ax, ay, x2, y2) {
499             return [
500                     2 / 3 * x1 + 1 / 3 * ax,
501                     2 / 3 * y1 + 1 / 3 * ay,
502                     2 / 3 * x1 + 1 / 3 * x2,
503                     2 / 3 * y1 + 1 / 3 * y2,
504                     x2,
505                     y2
506                 ];
507         },
508         a2c = function (x1, y1, rx, ry, angle, large_arc_flag, sweep_flag, x2, y2, recursive) {
509             // for more information of where this math came from visit:
510             // http://www.w3.org/TR/SVG11/implnote.html#ArcImplementationNotes
511             var _120 = Math.PI * 120 / 180,
512                 res = [];
513             if (!recursive) {
514                 var x = (x1 - x2) / 2,
515                     y = (y1 - y2) / 2,
516                     rx2 = rx * rx,
517                     ry2 = ry * ry,
518                     k = (large_arc_flag == sweep_flag ? -1 : 1) *
519                         Math.sqrt(Math.abs(rx2 * ry2 - rx2 * y * y - ry2 * x * x) / (rx2 * y * y + ry2 * x * x)),
520                     cx = k * rx * y / ry + (x1 + x2) / 2,
521                     cy = k * -ry * x / rx + (y1 + y2) / 2,
522                     f1 = Math.asin((y1 - cy) / ry),
523                     f2 = Math.asin((y2 - cy) / ry);
524
525                 f1 = x1 < cx ? Math.PI - f1 : f1;
526                 f2 = x2 < cx ? Math.PI - f2 : f2;
527                 f1 < 0 && (f1 = Math.PI * 2 + f1);
528                 f2 < 0 && (f2 = Math.PI * 2 + f2);
529                 if (sweep_flag && f1 > f2) {
530                     f1 = f1 - Math.PI * 2;
531                 }
532                 if (!sweep_flag && f2 > f1) {
533                     f2 = f2 - Math.PI * 2;
534                 }
535             } else {
536                 f1 = recursive[0];
537                 f2 = recursive[1];
538                 cx = recursive[2];
539                 cy = recursive[3];
540             }
541             var df = f2 - f1;
542             if (Math.abs(df) > _120) {
543                 var f2old = f2,
544                     x2old = x2,
545                     y2old = y2;
546                 f2 = f1 + _120 * (sweep_flag && f2 > f1 ? 1 : -1);
547                 x2 = cx + rx * Math.cos(f2);
548                 y2 = cy + ry * Math.sin(f2);
549                 res = arguments.callee(x2, y2, rx, ry, angle, 0, sweep_flag, x2old, y2old, [f2, f2old, cx, cy]);
550             }
551             var c1 = Math.cos(f1),
552                 s1 = Math.sin(f1),
553                 c2 = Math.cos(f2),
554                 s2 = Math.sin(f2),
555                 df = f2 - f1,
556                 t = Math.tan(df / 4),
557                 hx = 4 / 3 * rx * t,
558                 hy = 4 / 3 * ry * t,
559                 m1 = [x1, y1],
560                 m2 = [x1 + hx * s1, y1 - hy * c1],
561                 m3 = [x2 + hx * s2, y2 - hy * c2],
562                 m4 = [x2, y2];
563             m2[0] = 2 * m1[0] - m2[0];
564             m2[1] = 2 * m1[1] - m2[1];
565             if (recursive) {
566                 return [m2, m3, m4].concat(res);
567             } else {
568                 res = [m2, m3, m4].concat(res).join(",").split(",");
569                 for (var i = res.length; i--;) {
570                     res[i] = +res[i];
571                 }
572                 return res;
573             }
574         },
575         findDotAtSegment = function (p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y, t) {
576             var x = Math.pow(1 - t, 3) * p1x + Math.pow(1 - t, 2) * 3 * t * c1x + (1 - t) * 3 * t * t * c2x + Math.pow(t, 3) * p2x,
577                 y = Math.pow(1 - t, 3) * p1y + Math.pow(1 - t, 2) * 3 * t * c1y + (1 - t) * 3 * t * t * c2y + Math.pow(t, 3) * p2y,
578                 mx = p1x + 2 * t * (c1x - p1x) + t * t * (c2x - 2 * c1x + p1x),
579                 my = p1y + 2 * t * (c1y - p1y) + t * t * (c2y - 2 * c1y + p1y),
580                 nx = c1x + 2 * t * (c2x - c1x) + t * t * (p2x - 2 * c2x + c1x),
581                 ny = c1y + 2 * t * (c2y - c1y) + t * t * (p2y - 2 * c2y + c1y),
582                 ax = (1 - t) * p1x + t * c1x,
583                 ay = (1 - t) * p1y + t * c1y,
584                 cx = (1 - t) * c2x + t * p2x,
585                 cy = (1 - t) * c2y + t * p2y;
586             return {x: x, y: y, m: {x: mx, y: my}, n: {x: nx, y: ny}, start: {x: ax, y: ay}, end: {x: cx, y: cy}};
587         },
588         path2curve = function (path, path2) {
589             path2curve.cache = path2curve.cache || {};
590             path2curve.count = path2curve.count || [];
591             if (path in path2curve.cache) {
592                 return path2curve.cache[path + "&" + path2];
593             }
594             var p = pathToAbsolute(path),
595                 p2 = path2 && pathToAbsolute(path2),
596                 attrs = {x: 0, y: 0, bx: 0, by: 0, X: 0, Y: 0},
597                 attrs2 = {x: 0, y: 0, bx: 0, by: 0, X: 0, Y: 0},
598                 processPath = function (path, d) {
599                     if (!path) {
600                         return ["C", d.x, d.y, d.x, d.y, d.x, d.y];
601                     }
602                     switch (path[0]) {
603                         case "M":
604                             d.X = path[1];
605                             d.Y = path[2];
606                             break;
607                         case "A":
608                             path = ["C"].concat(a2c(d.x, d.y, path[1], path[2], path[3], path[4], path[5], path[6], path[7]));
609                             break;
610                         case "S":
611                             var nx = d.x + (d.x - (d.bx || d.x)),
612                                 ny = d.y + (d.y - (d.by || d.y));
613                             path = ["C", nx, ny, path[1], path[2], path[3], path[4]];
614                             break;
615                         case "T":
616                             var nx = d.x + (d.x - (d.bx || d.x)),
617                                 ny = d.y + (d.y - (d.by || d.y));
618                             path = ["C"].concat(q2c(d.x, d.y, nx, ny, path[1], path[2]));
619                             break;
620                         case "Q":
621                             path = ["C"].concat(q2c(d.x, d.y, path[1], path[2], path[3], path[4]));
622                             break;
623                         case "L":
624                             path = ["C"].concat(l2c(d.x, d.y, path[1], path[2]));
625                             break;
626                         case "H":
627                             path = ["C"].concat(l2c(d.x, d.y, path[1], d.y));
628                             break;
629                         case "V":
630                             path = ["C"].concat(l2c(d.x, d.y, d.x, path[1]));
631                             break;
632                         case "Z":
633                             path = ["C"].concat(l2c(d.x, d.y, d.X, d.Y));
634                             break;
635                     }
636                     return path;
637                 },
638                 fixArc = function (pp, i) {
639                     if (pp[i].length > 7) {
640                         pp[i].shift();
641                         var pi = pp[i];
642                         while (pi.length) {
643                             pp.splice(i++, 0, ["C"].concat(pi.splice(0, 6)));
644                         }
645                         pp.splice(i, 1);
646                         ii = Math.max(p.length, p2 && p2.length || 0);
647                     }
648                 },
649                 fixM = function (path1, path2, a1, a2, i) {
650                     if (path1 && path2 && path1[i][0] == "M" && path2[i][0] != "M") {
651                         path2.splice(i, 0, ["M", a2.x, a2.y]);
652                         a1.bx = 0;
653                         a1.by = 0;
654                         a1.x = path1[i][1];
655                         a1.y = path1[i][2];
656                         ii = Math.max(p.length, p2 && p2.length || 0);
657                     }
658                 };
659             for (var i = 0, ii = Math.max(p.length, p2 && p2.length || 0); i < ii; i++) {
660                 p[i] = processPath(p[i], attrs);
661                 fixArc(p, i);
662                 p2 && (p2[i] = processPath(p2[i], attrs2));
663                 p2 && fixArc(p2, i);
664                 fixM(p, p2, attrs, attrs2, i);
665                 fixM(p2, p, attrs2, attrs, i);
666                 var seg = p[i],
667                     seg2 = p2 && p2[i],
668                     seglen = seg.length,
669                     seg2len = p2 && seg2.length;
670                 attrs.bx = seg[seglen - 4] || 0;
671                 attrs.by = seg[seglen - 3] || 0;
672                 attrs.x = seg[seglen - 2];
673                 attrs.y = seg[seglen - 1];
674                 attrs2.bx = p2 && (seg2[seg2len - 4] || 0);
675                 attrs2.by = p2 && (seg2[seg2len - 3] || 0);
676                 attrs2.x = p2 && seg2[seg2len - 2];
677                 attrs2.y = p2 && seg2[seg2len - 1];
678             }
679             if (path2curve.count.length > 100) {
680                 delete path2curve.cache[path2curve.count.unshift()];
681             }
682             path2curve.count.push(path + "&" + path2);
683             return (path2curve.cache[path + "&" + path2] = p2 ? [p, p2] : p);
684         },
685         toGradient = function (gradient) {
686             if (typeof gradient == "string") {
687                 gradient = gradient.split(/\s*\-\s*/);
688                 var angle = gradient.shift();
689                 if (angle.toLowerCase() == "v") {
690                     angle = 90;
691                 } else if (angle.toLowerCase() == "h") {
692                     angle = 0;
693                 } else {
694                     angle = parseFloat(angle);
695                 }
696                 angle = -angle;
697                 var grobj = {angle: angle, type: "linear", dots: [], vector: [0, 0, Math.cos(angle * Math.PI / 180).toFixed(3), Math.sin(angle * Math.PI / 180).toFixed(3)]},
698                     max = 1 / (Math.max(Math.abs(grobj.vector[2]), Math.abs(grobj.vector[3])) || 1);
699                 grobj.vector[2] *= max;
700                 grobj.vector[3] *= max;
701                 if (grobj.vector[2] < 0) {
702                     grobj.vector[0] = -grobj.vector[2];
703                     grobj.vector[2] = 0;
704                 }
705                 if (grobj.vector[3] < 0) {
706                     grobj.vector[1] = -grobj.vector[3];
707                     grobj.vector[3] = 0;
708                 }
709                 grobj.vector[0] = grobj.vector[0].toFixed(3);
710                 grobj.vector[1] = grobj.vector[1].toFixed(3);
711                 grobj.vector[2] = grobj.vector[2].toFixed(3);
712                 grobj.vector[3] = grobj.vector[3].toFixed(3);
713                 for (var i = 0, ii = gradient.length; i < ii; i++) {
714                     var dot = {},
715                         par = gradient[i].match(/^([^:]*):?([\d\.]*)/);
716                     dot.color = R.getRGB(par[1]).hex;
717                     par[2] && (dot.offset = par[2] + "%");
718                     grobj.dots.push(dot);
719                 }
720                 for (var i = 1, ii = grobj.dots.length - 1; i < ii; i++) {
721                     if (!grobj.dots[i].offset) {
722                         var start = parseFloat(grobj.dots[i - 1].offset || 0),
723                             end = false;
724                         for (var j = i + 1; j < ii; j++) {
725                             if (grobj.dots[j].offset) {
726                                 end = grobj.dots[j].offset;
727                                 break;
728                             }
729                         }
730                         if (!end) {
731                             end = 100;
732                             j = ii;
733                         }
734                         end = parseFloat(end);
735                         var d = (end - start) / (j - i + 1);
736                         for (; i < j; i++) {
737                             start += d;
738                             grobj.dots[i].offset = start + "%";
739                         }
740                     }
741                 }
742                 return grobj;
743             } else {
744                 return gradient;
745             }
746         },
747         getContainer = function () {
748             var container,
749                 x,
750                 y,
751                 width,
752                 height;
753             if (typeof arguments[0] == "string" || typeof arguments[0] == "object") {
754                 if (typeof arguments[0] == "string") {
755                     container = doc.getElementById(arguments[0]);
756                 } else {
757                     container = arguments[0];
758                 }
759                 if (container.tagName) {
760                     if (arguments[1] == null) {
761                         return {
762                             container: container,
763                             width: container.style.pixelWidth || container.offsetWidth,
764                             height: container.style.pixelHeight || container.offsetHeight
765                         };
766                     } else {
767                         return {container: container, width: arguments[1], height: arguments[2]};
768                     }
769                 }
770             } else if (typeof arguments[0] == "number" && arguments.length > 3) {
771                 return {container: 1, x: arguments[0], y: arguments[1], width: arguments[2], height: arguments[3]};
772             }
773         },
774         plugins = function (con, add) {
775             var that = this;
776             for (var prop in add) if (add.hasOwnProperty(prop) && !(prop in con)) {
777                 switch (typeof add[prop]) {
778                     case "function":
779                         (function (f) {
780                             con[prop] = con === that ? f : function () { return f.apply(that, arguments); };
781                         })(add[prop]);
782                     break;
783                     case "object":
784                         con[prop] = con[prop] || {};
785                         plugins.call(this, con[prop], add[prop]);
786                     break;
787                     default:
788                         con[prop] = add[prop];
789                     break;
790                 }
791             }
792         };
793
794     // SVG
795     if (R.svg) {
796         R.toString = function () {
797             return  "Your browser supports SVG.\nYou are running Rapha\u00ebl " + this.version;
798         };
799         var thePath = function (params, pathString, SVG) {
800             var el = doc.createElementNS(SVG.svgns, "path");
801             if (SVG.canvas) {
802                 SVG.canvas.appendChild(el);
803             }
804             var p = new Element(el, SVG);
805             p.isAbsolute = true;
806             for (var method in pathMethods) {
807                 p[method] = pathMethods[method];
808             }
809             p.type = "path";
810             p.attrs.path = "" + (pathString || "");
811             pathString && p.node.setAttribute("d", R.parsePathString(pathString));
812             if (params) {
813                 !params.gradient && (params.fill = params.fill || "none");
814                 params.stroke = params.stroke || "#000";
815             } else {
816                 params = {fill: "none", stroke: "#000"};
817             }
818             setFillAndStroke(p, params);
819             return p;
820         };
821         var addGradientFill = function (o, gradient, SVG) {
822             gradient = toGradient(gradient);
823             var el = doc.createElementNS(SVG.svgns, (gradient.type || "linear") + "Gradient");
824             el.id = "raphael-gradient-" + R.idGenerator++;
825             if (gradient.vector && gradient.vector.length) {
826                 el.setAttribute("x1", gradient.vector[0]);
827                 el.setAttribute("y1", gradient.vector[1]);
828                 el.setAttribute("x2", gradient.vector[2]);
829                 el.setAttribute("y2", gradient.vector[3]);
830             }
831             SVG.defs.appendChild(el);
832             var isopacity = true;
833             for (var i = 0, ii = gradient.dots.length; i < ii; i++) {
834                 var stop = doc.createElementNS(SVG.svgns, "stop");
835                 if (gradient.dots[i].offset) {
836                     isopacity = false;
837                 }
838                 stop.setAttribute("offset", gradient.dots[i].offset ? gradient.dots[i].offset : (i == 0) ? "0%" : "100%");
839                 stop.setAttribute("stop-color", R.getRGB(gradient.dots[i].color).hex || "#fff");
840                 // ignoring opacity for internal points, because VML doesn't support it
841                 el.appendChild(stop);
842             };
843             if (isopacity && typeof gradient.dots[ii - 1].opacity != "undefined") {
844                 stop.setAttribute("stop-opacity", gradient.dots[ii - 1].opacity);
845             }
846             o.setAttribute("fill", "url(#" + el.id + ")");
847             o.style.fill = "";
848             o.style.opacity = 1;
849             o.style.fillOpacity = 1;
850             o.setAttribute("opacity", 1);
851             o.setAttribute("fill-opacity", 1);
852         };
853         var updatePosition = function (o) {
854             if (o.pattern) {
855                 var bbox = o.getBBox();
856                 o.pattern.setAttribute("patternTransform", "translate(".concat(bbox.x, ",", bbox.y, ")"));
857             }
858         };
859         var setFillAndStroke = function (o, params) {
860             var dasharray = {
861                     "": [0],
862                     "none": [0],
863                     "-": [3, 1],
864                     ".": [1, 1],
865                     "-.": [3, 1, 1, 1],
866                     "-..": [3, 1, 1, 1, 1, 1],
867                     ". ": [1, 3],
868                     "- ": [4, 3],
869                     "--": [8, 3],
870                     "- .": [4, 3, 1, 3],
871                     "--.": [8, 3, 1, 3],
872                     "--..": [8, 3, 1, 3, 1, 3]
873                 },
874                 node = o.node,
875                 attrs = o.attrs,
876                 rot = o.attr("rotation"),
877                 addDashes = function (o, value) {
878                     value = dasharray[(value + "").toLowerCase()];
879                     if (value) {
880                         var width = o.attrs["stroke-width"] || "1",
881                             butt = {round: width, square: width, butt: 0}[o.attrs["stroke-linecap"] || params["stroke-linecap"]] || 0,
882                             dashes = [];
883                         for (var i = 0, ii = value.length; i < ii; i++) {
884                             dashes.push(value[i] * width + ((i % 2) ? 1 : -1) * butt);
885                         }
886                         value = dashes.join(",");
887                         node.setAttribute("stroke-dasharray", value);
888                     }
889                 };
890             o.rotate(0, true);
891             for (var att in params) {
892                 if (!(att in availableAttrs)) {
893                     continue;
894                 }
895                 var value = params[att];
896                 attrs[att] = value;
897                 switch (att) {
898                     // Hyperlink
899                     case "href":
900                     case "title":
901                     case "target":
902                         var pn = node.parentNode;
903                         if (pn.tagName.toLowerCase() != "a") {
904                             var hl = doc.createElementNS(o.paper.svgns, "a");
905                             pn.insertBefore(hl, node);
906                             hl.appendChild(node);
907                             pn = hl;
908                         }
909                         pn.setAttributeNS(o.paper.xlink, att, value);
910                       break;
911                     case "path":
912                         if (o.type == "path") {
913                             node.setAttribute("d", R.parsePathString(value));
914                         }
915                     case "width":
916                         node.setAttribute(att, value);
917                         if (attrs.fx) {
918                             att = "x";
919                             value = attrs.x;
920                         } else {
921                             break;
922                         }
923                     case "x":
924                         if (attrs.fx) {
925                             value = -attrs.x - (attrs.width || 0);
926                         }
927                     case "rx":
928                     case "cx":
929                         node.setAttribute(att, value);
930                         updatePosition(o);
931                         break;
932                     case "height":
933                         node.setAttribute(att, value);
934                         if (attrs.fy) {
935                             att = "y";
936                             value = attrs.y;
937                         } else {
938                             break;
939                         }
940                     case "y":
941                         if (attrs.fy) {
942                             value = -attrs.y - (attrs.height || 0);
943                         }
944                     case "ry":
945                     case "cy":
946                         node.setAttribute(att, value);
947                         updatePosition(o);
948                         break;
949                     case "r":
950                         if (o.type == "rect") {
951                             node.setAttribute("rx", value);
952                             node.setAttribute("ry", value);
953                         } else {
954                             node.setAttribute(att, value);
955                         }
956                         break;
957                     case "src":
958                         if (o.type == "image") {
959                             node.setAttributeNS(o.paper.xlink, "href", value);
960                         }
961                         break;
962                     case "stroke-width":
963                         node.style.strokeWidth = value;
964                         // Need following line for Firefox
965                         node.setAttribute(att, value);
966                         if (attrs["stroke-dasharray"]) {
967                             addDashes(o, attrs["stroke-dasharray"]);
968                         }
969                         break;
970                     case "stroke-dasharray":
971                         addDashes(o, value);
972                         break;
973                     case "rotation":
974                         rot = value;
975                         o.rotate(value, true);
976                         break;
977                     case "translation":
978                         var xy = (value + "").split(separator);
979                         o.translate((+xy[0] + 1 || 2) - 1, (+xy[1] + 1 || 2) - 1);
980                         break;
981                     case "scale":
982                         var xy = (value + "").split(separator);
983                         o.scale(+xy[0] || 1, +xy[1] || +xy[0] || 1, +xy[2] || null, +xy[3] || null);
984                         break;
985                     case "fill":
986                         var isURL = (value + "").match(/^url\(([^\)]+)\)$/i);
987                         if (isURL) {
988                             var el = doc.createElementNS(o.paper.svgns, "pattern"),
989                                 ig = doc.createElementNS(o.paper.svgns, "image");
990                             el.id = "raphael-pattern-" + R.idGenerator++;
991                             el.setAttribute("x", 0);
992                             el.setAttribute("y", 0);
993                             el.setAttribute("patternUnits", "userSpaceOnUse");
994                             ig.setAttribute("x", 0);
995                             ig.setAttribute("y", 0);
996                             ig.setAttributeNS(o.paper.xlink, "href", isURL[1]);
997                             el.appendChild(ig);
998
999                             var img = doc.createElement("img");
1000                             img.style.position = "absolute";
1001                             img.style.top = "-9999em";
1002                             img.style.left = "-9999em";
1003                             img.onload = function () {
1004                                 el.setAttribute("width", this.offsetWidth);
1005                                 el.setAttribute("height", this.offsetHeight);
1006                                 ig.setAttribute("width", this.offsetWidth);
1007                                 ig.setAttribute("height", this.offsetHeight);
1008                                 doc.body.removeChild(this);
1009                                 paper.safari();
1010                             };
1011                             doc.body.appendChild(img);
1012                             img.src = isURL[1];
1013                             o.paper.defs.appendChild(el);
1014                             node.style.fill = "url(#" + el.id + ")";
1015                             node.setAttribute("fill", "url(#" + el.id + ")");
1016                             o.pattern = el;
1017                             updatePosition(o);
1018                             break;
1019                         }
1020                         delete params.gradient;
1021                         delete attrs.gradient;
1022                         if (typeof attrs.opacity != "undefined" && typeof params.opacity == "undefined" ) {
1023                             node.style.opacity = attrs.opacity;
1024                             // Need following line for Firefox
1025                             node.setAttribute("opacity", attrs.opacity);
1026                         }
1027                         if (typeof attrs["fill-opacity"] != "undefined" && typeof params["fill-opacity"] == "undefined" ) {
1028                             node.style.fillOpacity = o.attrs["fill-opacity"];
1029                             // Need following line for Firefox
1030                             node.setAttribute("fill-opacity", attrs["fill-opacity"]);
1031                         }
1032                     case "stroke":
1033                         node.style[att] = R.getRGB(value).hex;
1034                         // Need following line for Firefox
1035                         node.setAttribute(att, R.getRGB(value).hex);
1036                         break;
1037                     case "gradient":
1038                         addGradientFill(node, value, o.paper);
1039                         break;
1040                     case "opacity":
1041                     case "fill-opacity":
1042                         if (attrs.gradient) {
1043                             var gradient = doc.getElementById(node.getAttribute("fill").replace(/^url\(#|\)$/g, ""));
1044                             if (gradient) {
1045                                 var stops = gradient.getElementsByTagName("stop");
1046                                 stops[stops.length - 1].setAttribute("stop-opacity", value);
1047                             }
1048                             break;
1049                         }
1050                     default :
1051                         var cssrule = att.replace(/(\-.)/g, function (w) {
1052                             return w.substring(1).toUpperCase();
1053                         });
1054                         node.style[cssrule] = value;
1055                         // Need following line for Firefox
1056                         node.setAttribute(att, value);
1057                         break;
1058                 }
1059             }
1060             
1061             tuneText(o, params);
1062             o.rotate(rot, true);
1063         };
1064         var leading = 1.2;
1065         var tuneText = function (el, params) {
1066             if (el.type != "text" || !("text" in params || "font" in params || "font-size" in params || "x" in params || "y" in params)) {
1067                 return;
1068             }
1069             var a = el.attrs,
1070                 node = el.node,
1071                 fontSize = node.firstChild ? parseInt(doc.defaultView.getComputedStyle(node.firstChild, "").getPropertyValue("font-size"), 10) : 10;
1072
1073             if ("text" in params) {
1074                 while (node.firstChild) {
1075                     node.removeChild(node.firstChild);
1076                 }
1077                 var texts = (params.text + "").split("\n");
1078                 for (var i = 0, ii = texts.length; i < ii; i++) {
1079                     var tspan = doc.createElementNS(el.paper.svgns, "tspan");
1080                     i && tspan.setAttribute("dy", fontSize * leading);
1081                     i && tspan.setAttribute("x", a.x);
1082                     tspan.appendChild(doc.createTextNode(texts[i]));
1083                     node.appendChild(tspan);
1084                 }
1085             } else {
1086                 var texts = node.getElementsByTagName("tspan");
1087                 for (var i = 0, ii = texts.length; i < ii; i++) {
1088                     i && texts[i].setAttribute("dy", fontSize * leading);
1089                     i && texts[i].setAttribute("x", a.x);
1090                 }
1091             }
1092             node.setAttribute("y", a.y);
1093             var bb = el.getBBox(),
1094                 dif = a.y - (bb.y + bb.height / 2);
1095             dif && node.setAttribute("y", a.y + dif);
1096         };
1097         var Element = function (node, svg) {
1098             var X = 0,
1099                 Y = 0;
1100             this[0] = node;
1101             this.node = node;
1102             this.paper = svg;
1103             this.attrs = this.attrs || {};
1104             this.transformations = []; // rotate, translate, scale
1105             this._ = {
1106                 tx: 0,
1107                 ty: 0,
1108                 rt: {deg: 0, x: 0, y: 0},
1109                 sx: 1,
1110                 sy: 1
1111             };
1112         };
1113         Element.prototype.rotate = function (deg, cx, cy) {
1114             if (deg == null) {
1115                 if (this._.rt.cx) {
1116                     return [this._.rt.deg, this._.rt.cx, this._.rt.cy].join(" ");
1117                 }
1118                 return this._.rt.deg;
1119             }
1120             var bbox = this.getBBox();
1121             deg = (deg + "").split(separator);
1122             if (deg.length - 1) {
1123                 cx = parseFloat(deg[1]);
1124                 cy = parseFloat(deg[2]);
1125             }
1126             deg = parseFloat(deg[0]);
1127             if (cx != null) {
1128                 this._.rt.deg = deg;
1129             } else {
1130                 this._.rt.deg += deg;
1131             }
1132             (cy == null) && (cx = null);
1133             this._.rt.cx = cx;
1134             this._.rt.cy = cy;
1135             cx = cx == null ? bbox.x + bbox.width / 2 : cx;
1136             cy = cy == null ? bbox.y + bbox.height / 2 : cy;
1137             if (this._.rt.deg) {
1138                 this.transformations[0] = ("rotate(" + this._.rt.deg + " " + cx + " " + cy + ")");
1139             } else {
1140                 this.transformations[0] = "";
1141             }
1142             this.node.setAttribute("transform", this.transformations.join(" "));
1143             return this;
1144         };
1145         Element.prototype.hide = function () {
1146             this.node.style.display = "none";
1147             return this;
1148         };
1149         Element.prototype.show = function () {
1150             this.node.style.display = "block";
1151             return this;
1152         };
1153         Element.prototype.remove = function () {
1154             this.node.parentNode.removeChild(this.node);
1155         };
1156         Element.prototype.getBBox = function () {
1157             if (this.node.style.display == "none") {
1158                 this.show();
1159                 var hide = true;
1160             }
1161             var bbox = {};
1162             try {
1163                 bbox = this.node.getBBox();
1164             } catch(e) {
1165                 // Firefox 3.0.x plays badly here
1166             } finally {
1167                 bbox = bbox || {};
1168             }
1169             if (this.type == "text") {
1170                 bbox = {x: bbox.x, y: Infinity, width: bbox.width, height: 0};
1171                 for (var i = 0, ii = this.node.getNumberOfChars(); i < ii; i++) {
1172                     var bb = this.node.getExtentOfChar(i);
1173                     (bb.y < bbox.y) && (bbox.y = bb.y);
1174                     (bb.y + bb.height - bbox.y > bbox.height) && (bbox.height = bb.y + bb.height - bbox.y);
1175                 }
1176             }
1177             hide && this.hide();
1178             return bbox;
1179         };
1180         Element.prototype.attr = function () {
1181             if (arguments.length == 1 && typeof arguments[0] == "string") {
1182                 if (arguments[0] == "translation") {
1183                     return this.translate();
1184                 }
1185                 if (arguments[0] == "rotation") {
1186                     return this.rotate();
1187                 }
1188                 if (arguments[0] == "scale") {
1189                     return this.scale();
1190                 }
1191                 return this.attrs[arguments[0]];
1192             }
1193             if (arguments.length == 1 && R.isArray(arguments[0])) {
1194                 var values = {};
1195                 for (var j in arguments[0]) {
1196                     values[arguments[0][j]] = this.attrs[arguments[0][j]];
1197                 }
1198                 return values;
1199             }
1200             if (arguments.length == 2) {
1201                 var params = {};
1202                 params[arguments[0]] = arguments[1];
1203                 setFillAndStroke(this, params);
1204             } else if (arguments.length == 1 && typeof arguments[0] == "object") {
1205                 setFillAndStroke(this, arguments[0]);
1206             }
1207             return this;
1208         };
1209         Element.prototype.toFront = function () {
1210             this.node.parentNode.appendChild(this.node);
1211             return this;
1212         };
1213         Element.prototype.toBack = function () {
1214             if (this.node.parentNode.firstChild != this.node) {
1215                 this.node.parentNode.insertBefore(this.node, this.node.parentNode.firstChild);
1216             }
1217             return this;
1218         };
1219         Element.prototype.insertAfter = function (element) {
1220             if (element.node.nextSibling) {
1221                 element.node.parentNode.insertBefore(this.node, element.node.nextSibling);
1222             } else {
1223                 element.node.parentNode.appendChild(this.node);
1224             }
1225             return this;
1226         };
1227         Element.prototype.insertBefore = function (element) {
1228             var node = element.node;
1229             node.parentNode.insertBefore(this.node, node);
1230             return this;
1231         };
1232         var theCircle = function (svg, x, y, r) {
1233             var el = doc.createElementNS(svg.svgns, "circle");
1234             el.setAttribute("cx", x);
1235             el.setAttribute("cy", y);
1236             el.setAttribute("r", r);
1237             el.setAttribute("fill", "none");
1238             el.setAttribute("stroke", "#000");
1239             if (svg.canvas) {
1240                 svg.canvas.appendChild(el);
1241             }
1242             var res = new Element(el, svg);
1243             res.attrs = res.attrs || {};
1244             res.attrs.cx = x;
1245             res.attrs.cy = y;
1246             res.attrs.r = r;
1247             res.attrs.stroke = "#000";
1248             res.type = "circle";
1249             return res;
1250         };
1251         var theRect = function (svg, x, y, w, h, r) {
1252             var el = doc.createElementNS(svg.svgns, "rect");
1253             el.setAttribute("x", x);
1254             el.setAttribute("y", y);
1255             el.setAttribute("width", w);
1256             el.setAttribute("height", h);
1257             if (r) {
1258                 el.setAttribute("rx", r);
1259                 el.setAttribute("ry", r);
1260             }
1261             el.setAttribute("fill", "none");
1262             el.setAttribute("stroke", "#000");
1263             if (svg.canvas) {
1264                 svg.canvas.appendChild(el);
1265             }
1266             var res = new Element(el, svg);
1267             res.attrs = res.attrs || {};
1268             res.attrs.x = x;
1269             res.attrs.y = y;
1270             res.attrs.width = w;
1271             res.attrs.height = h;
1272             res.attrs.stroke = "#000";
1273             if (r) {
1274                 res.attrs.rx = res.attrs.ry = r;
1275             }
1276             res.type = "rect";
1277             return res;
1278         };
1279         var theEllipse = function (svg, x, y, rx, ry) {
1280             var el = doc.createElementNS(svg.svgns, "ellipse");
1281             el.setAttribute("cx", x);
1282             el.setAttribute("cy", y);
1283             el.setAttribute("rx", rx);
1284             el.setAttribute("ry", ry);
1285             el.setAttribute("fill", "none");
1286             el.setAttribute("stroke", "#000");
1287             if (svg.canvas) {
1288                 svg.canvas.appendChild(el);
1289             }
1290             var res = new Element(el, svg);
1291             res.attrs = res.attrs || {};
1292             res.attrs.cx = x;
1293             res.attrs.cy = y;
1294             res.attrs.rx = rx;
1295             res.attrs.ry = ry;
1296             res.attrs.stroke = "#000";
1297             res.type = "ellipse";
1298             return res;
1299         };
1300         var theImage = function (svg, src, x, y, w, h) {
1301             var el = doc.createElementNS(svg.svgns, "image");
1302             el.setAttribute("x", x);
1303             el.setAttribute("y", y);
1304             el.setAttribute("width", w);
1305             el.setAttribute("height", h);
1306             el.setAttribute("preserveAspectRatio", "none");
1307             el.setAttributeNS(svg.xlink, "href", src);
1308             if (svg.canvas) {
1309                 svg.canvas.appendChild(el);
1310             }
1311             var res = new Element(el, svg);
1312             res.attrs = res.attrs || {};
1313             res.attrs.src = src;
1314             res.attrs.x = x;
1315             res.attrs.y = y;
1316             res.attrs.width = w;
1317             res.attrs.height = h;
1318             res.type = "image";
1319             return res;
1320         };
1321         var theText = function (svg, x, y, text) {
1322             var el = doc.createElementNS(svg.svgns, "text");
1323             el.setAttribute("x", x);
1324             el.setAttribute("y", y);
1325             el.setAttribute("text-anchor", "middle");
1326             if (svg.canvas) {
1327                 svg.canvas.appendChild(el);
1328             }
1329             var res = new Element(el, svg);
1330             res.attrs = res.attrs || {};
1331             res.attrs.text = text;
1332             res.attrs.x = x;
1333             res.attrs.y = y;
1334             res.type = "text";
1335             setFillAndStroke(res, {font: availableAttrs.font, stroke: "none", fill: "#000", text: text});
1336             return res;
1337         };
1338         var setSize = function (width, height) {
1339             this.width = width || this.width;
1340             this.height = height || this.height;
1341             this.canvas.setAttribute("width", this.width);
1342             this.canvas.setAttribute("height", this.height);
1343             return this;
1344         };
1345         var create = function () {
1346             var con = getContainer.apply(null, arguments),
1347                 container = con.container,
1348                 x = con.x,
1349                 y = con.y,
1350                 width = con.width,
1351                 height = con.height;
1352             if (!container) {
1353                 throw new Error("SVG container not found.");
1354             }
1355             paper.canvas = doc.createElementNS(paper.svgns, "svg");
1356             paper.canvas.setAttribute("width", width || 512);
1357             paper.width = width || 512;
1358             paper.canvas.setAttribute("height", height || 342);
1359             paper.height = height || 342;
1360             if (container == 1) {
1361                 doc.body.appendChild(paper.canvas);
1362                 paper.canvas.style.position = "absolute";
1363                 paper.canvas.style.left = x + "px";
1364                 paper.canvas.style.top = y + "px";
1365             } else {
1366                 if (container.firstChild) {
1367                     container.insertBefore(paper.canvas, container.firstChild);
1368                 } else {
1369                     container.appendChild(paper.canvas);
1370                 }
1371             }
1372             container = {
1373                 canvas: paper.canvas,
1374                 clear: function () {
1375                     while (this.canvas.firstChild) {
1376                         this.canvas.removeChild(this.canvas.firstChild);
1377                     }
1378                     this.defs = doc.createElementNS(paper.svgns, "defs");
1379                     this.canvas.appendChild(this.defs);
1380                 }
1381             };
1382             for (var prop in paper) {
1383                 if (prop != "create") {
1384                     container[prop] = paper[prop];
1385                 }
1386             }
1387             plugins.call(container, container, R.fn);
1388             container.clear();
1389             container.raphael = R;
1390             return container;
1391         };
1392         paper.remove = function () {
1393             this.canvas.parentNode && this.canvas.parentNode.removeChild(this.canvas);
1394         };
1395         paper.svgns = "http://www.w3.org/2000/svg";
1396         paper.xlink = "http://www.w3.org/1999/xlink";
1397         paper.safari = function () {
1398             if ({"Apple Computer, Inc.": 1, "Google Inc.": 1}[navigator.vendor]) {
1399                 var rect = this.rect(-this.width, -this.height, this.width * 3, this.height * 3).attr({stroke: "none"});
1400                 setTimeout(function () {rect.remove();});
1401             }
1402         };
1403     }
1404
1405     // VML
1406     if (R.vml) {
1407         var path2vml = function (path) {
1408             var pa = path2curve(path);
1409             for (var i = 0, ii = pa.length; i < ii; i++) {
1410                 for (var j = 0, jj = pa[i].length; j < jj; j++) {
1411                     pa[i][j] = isNaN(pa[i][j]) ? pa[i][j] : Math.round(pa[i][j]);
1412                 }
1413             }
1414             return (pa + "").toLowerCase().replace(/z/g, "x");
1415         };
1416         R.toString = function () {
1417             return  "Your browser doesn\u2019t support SVG. Assuming it is Internet Explorer and falling down to VML.\nYou are running Rapha\u00ebl " + this.version;
1418         };
1419         var thePath = function (params, pathString, VML) {
1420             var g = createNode("group"), gl = g.style;
1421             gl.position = "absolute";
1422             gl.left = 0;
1423             gl.top = 0;
1424             gl.width = VML.width + "px";
1425             gl.height = VML.height + "px";
1426             g.coordsize = VML.coordsize;
1427             g.coordorigin = VML.coordorigin;
1428             var el = createNode("shape"), ol = el.style;
1429             ol.width = VML.width + "px";
1430             ol.height = VML.height + "px";
1431             el.path = "";
1432             if (params["class"]) {
1433                 el.className = "rvml " + params["class"];
1434             }
1435             el.coordsize = this.coordsize;
1436             el.coordorigin = this.coordorigin;
1437             g.appendChild(el);
1438             var p = new Element(el, g, VML);
1439             p.isAbsolute = true;
1440             p.type = "path";
1441             p.path = [];
1442             p.last = {x: 0, y: 0, bx: 0, by: 0, isAbsolute: true};
1443             p.Path = "";
1444             for (var method in pathMethods) {
1445                 p[method] = pathMethods[method];
1446             }
1447             
1448             if (params) {
1449                 params.fill = params.fill || "none";
1450                 params.stroke = params.stroke || "#000";
1451             } else {
1452                 params = {fill: "none", stroke: "#000"};
1453             }
1454             if (pathString) {
1455                 p.node.path = path2vml(pathString);
1456                 p.attrs.path = pathString;
1457             }
1458             setFillAndStroke(p, params);
1459             if (params.gradient) {
1460                 addGradientFill(p, params.gradient);
1461             }
1462             p.setBox();
1463             VML.canvas.appendChild(g);
1464             return p;
1465         };
1466         var setFillAndStroke = function (o, params) {
1467             var node = o.node,
1468                 s = node.style,
1469                 xy,
1470                 res = o;
1471             o.attrs = o.attrs || {};
1472             for (var par in params) {
1473                 o.attrs[par] = params[par];
1474             }
1475             params.href && (node.href = params.href);
1476             params.title && (node.title = params.title);
1477             params.target && (node.target = params.target);
1478             if (params.path && o.type == "path") {
1479                 o.node.path = path2vml(params.path);
1480             }
1481             if (params.rotation != null) {
1482                 o.rotate(params.rotation, true);
1483             }
1484             if (params.translation) {
1485                 xy = (params.translation + "").split(separator);
1486                 o.translate(xy[0], xy[1]);
1487             }
1488             if (params.scale) {
1489                 xy = (params.scale + "").split(separator);
1490                 o.scale(+xy[0] || 1, +xy[1] || +xy[0] || 1, +xy[2] || null, +xy[3] || null);
1491             }
1492             if (o.type == "image" && params.src) {
1493                 node.src = params.src;
1494             }
1495             if (o.type == "image" && params.opacity) {
1496                 node.filterOpacity = " progid:DXImageTransform.Microsoft.Alpha(opacity=" + (params.opacity * 100) + ")";
1497                 node.style.filter = (node.filterMatrix || "") + (node.filterOpacity || "");
1498             }
1499             params.font && (s.font = params.font);
1500             params["font-family"] && (s.fontFamily = '"' + params["font-family"].split(",")[0].replace(/^['"]+|['"]+$/g, "") + '"');
1501             params["font-size"] && (s.fontSize = params["font-size"]);
1502             params["font-weight"] && (s.fontWeight = params["font-weight"]);
1503             params["font-style"] && (s.fontStyle = params["font-style"]);
1504             if (typeof params.opacity != "undefined" || typeof params["stroke-width"] != "undefined" || typeof params.fill != "undefined" || typeof params.stroke != "undefined" || params["stroke-width"] || params["stroke-opacity"] || params["fill-opacity"] || params["stroke-dasharray"] || params["stroke-miterlimit"] || params["stroke-linejoin"] || params["stroke-linecap"]) {
1505                 o = o.shape || node;
1506                 var fill = (o.getElementsByTagName("fill") && o.getElementsByTagName("fill")[0]) || createNode("fill");
1507                 if ("fill-opacity" in params || "opacity" in params) {
1508                     var opacity = ((+params["fill-opacity"] + 1 || 2) - 1) * ((+params.opacity + 1 || 2) - 1);
1509                     opacity < 0 && (opacity = 0);
1510                     opacity > 1 && (opacity = 1);
1511                     fill.opacity = opacity;
1512                 }
1513                 params.fill && (fill.on = true);
1514                 if (typeof fill.on == "undefined" || params.fill == "none") {
1515                     fill.on = false;
1516                 }
1517                 if (fill.on && params.fill) {
1518                     var isURL = params.fill.match(/^url\(([^\)]+)\)$/i);
1519                     if (isURL) {
1520                         fill.src = isURL[1];
1521                         fill.type = "tile";
1522                     } else {
1523                         fill.color = R.getRGB(params.fill).hex;
1524                         fill.src = "";
1525                         fill.type = "solid";
1526                     }
1527                 }
1528                 o.appendChild(fill);
1529                 var stroke = (o.getElementsByTagName("stroke") && o.getElementsByTagName("stroke")[0]) || createNode("stroke");
1530                 if ((params.stroke && params.stroke != "none") || params["stroke-width"] || typeof params["stroke-opacity"] != "undefined" || params["stroke-dasharray"] || params["stroke-miterlimit"] || params["stroke-linejoin"] || params["stroke-linecap"]) {
1531                     stroke.on = true;
1532                 }
1533                 if (params.stroke == "none" || typeof stroke.on == "undefined" || params.stroke == 0) {
1534                     stroke.on = false;
1535                 }
1536                 if (stroke.on && params.stroke) {
1537                     stroke.color = R.getRGB(params.stroke).hex;
1538                 }
1539                 var opacity = ((+params["stroke-opacity"] + 1 || 2) - 1) * ((+params.opacity + 1 || 2) - 1);
1540                 opacity < 0 && (opacity = 0);
1541                 opacity > 1 && (opacity = 1);
1542                 stroke.opacity = opacity;
1543                 params["stroke-linejoin"] && (stroke.joinstyle = params["stroke-linejoin"] || "miter");
1544                 stroke.miterlimit = params["stroke-miterlimit"] || 8;
1545                 params["stroke-linecap"] && (stroke.endcap = {butt: "flat", square: "square", round: "round"}[params["stroke-linecap"]] || "miter");
1546                 params["stroke-width"] && (stroke.weight = (parseFloat(params["stroke-width"]) || 1) * 12 / 16);
1547                 if (params["stroke-dasharray"]) {
1548                     var dasharray = {
1549                         "-": "shortdash",
1550                         ".": "shortdot",
1551                         "-.": "shortdashdot",
1552                         "-..": "shortdashdotdot",
1553                         ". ": "dot",
1554                         "- ": "dash",
1555                         "--": "longdash",
1556                         "- .": "dashdot",
1557                         "--.": "longdashdot",
1558                         "--..": "longdashdotdot"
1559                     };
1560                     stroke.dashstyle = dasharray[params["stroke-dasharray"]] || "";
1561                 }
1562                 o.appendChild(stroke);
1563             }
1564             if (res.type == "text") {
1565                 var s = paper.span.style,
1566                     a = res.attrs;
1567                 a.font && (s.font = a.font);
1568                 a["font-family"] && (s.fontFamily = a["font-family"]);
1569                 a["font-size"] && (s.fontSize = a["font-size"]);
1570                 a["font-weight"] && (s.fontWeight = a["font-weight"]);
1571                 a["font-style"] && (s.fontStyle = a["font-style"]);
1572                 paper.span.innerHTML = "";
1573                 paper.span.appendChild(doc.createTextNode(res.node.string));
1574                 res.W = a.w = paper.span.offsetWidth;
1575                 res.H = a.h = paper.span.offsetHeight;
1576                 res.X = a.x;
1577                 res.Y = a.y + Math.round(res.H / 2);
1578
1579                 // text-anchor emulation
1580                 switch (a["text-anchor"]) {
1581                     case "start":
1582                         res.node.style["v-text-align"] = "left";
1583                         res.bbx = Math.round(res.W / 2);
1584                     break;
1585                     case "end":
1586                         res.node.style["v-text-align"] = "right";
1587                         res.bbx = -Math.round(res.W / 2);
1588                     break;
1589                     default:
1590                         res.node.style["v-text-align"] = "center";
1591                     break;
1592                 }
1593             }
1594         };
1595         var getAngle = function (a, b, c, d) {
1596             var angle = Math.round(Math.atan((parseFloat(c) - parseFloat(a)) / (parseFloat(d) - parseFloat(b))) * 57.29) || 0;
1597             if (!angle && parseFloat(a) < parseFloat(b)) {
1598                 angle = 180;
1599             }
1600             angle -= 180;
1601             if (angle < 0) {
1602                 angle += 360;
1603             }
1604             return angle;
1605         };
1606         var addGradientFill = function (o, gradient) {
1607             gradient = toGradient(gradient);
1608             o.attrs = o.attrs || {};
1609             var attrs = o.attrs,
1610                 fill = o.node.getElementsByTagName("fill");
1611             o.attrs.gradient = gradient;
1612             o = o.shape || o.node;
1613             if (fill.length) {
1614                 fill = fill[0];
1615             } else {
1616                 fill = createNode("fill");
1617             }
1618             if (gradient.dots.length) {
1619                 fill.on = true;
1620                 fill.method = "none";
1621                 fill.type = ((gradient.type + "").toLowerCase() == "radial") ? "gradientTitle" : "gradient";
1622                 if (typeof gradient.dots[0].color != "undefined") {
1623                     fill.color = R.getRGB(gradient.dots[0].color).hex;
1624                 }
1625                 if (typeof gradient.dots[gradient.dots.length - 1].color != "undefined") {
1626                     fill.color2 = R.getRGB(gradient.dots[gradient.dots.length - 1].color).hex;
1627                 }
1628                 var clrs = [];
1629                 for (var i = 0, ii = gradient.dots.length; i < ii; i++) {
1630                     if (gradient.dots[i].offset) {
1631                         clrs.push(gradient.dots[i].offset + " " + R.getRGB(gradient.dots[i].color).hex);
1632                     }
1633                 };
1634                 var fillOpacity = typeof gradient.dots[gradient.dots.length - 1].opacity == "undefined" ? (typeof attrs.opacity == "undefined" ? 1 : attrs.opacity) : gradient.dots[gradient.dots.length - 1].opacity;
1635                 if (clrs.length) {
1636                     fill.colors.value = clrs.join(",");
1637                     fillOpacity = typeof attrs.opacity == "undefined" ? 1 : attrs.opacity;
1638                 } else {
1639                     fill.colors && (fill.colors.value = "0% " + fill.color);
1640                 }
1641                 fill.opacity = fillOpacity;
1642                 if (typeof gradient.angle != "undefined") {
1643                     fill.angle = (-gradient.angle + 270) % 360;
1644                 } else if (gradient.vector) {
1645                     fill.angle = getAngle.apply(null, gradient.vector);
1646                 }
1647                 if ((gradient.type + "").toLowerCase() == "radial") {
1648                     fill.focus = "100%";
1649                     fill.focusposition = "0.5 0.5";
1650                 }
1651             }
1652         };
1653         var Element = function (node, group, vml) {
1654             var Rotation = 0,
1655                 RotX = 0,
1656                 RotY = 0,
1657                 Scale = 1;
1658             this[0] = node;
1659             this.node = node;
1660             this.X = 0;
1661             this.Y = 0;
1662             this.attrs = {};
1663             this.Group = group;
1664             this.paper = vml;
1665             this._ = {
1666                 tx: 0,
1667                 ty: 0,
1668                 rt: {deg:0},
1669                 sx: 1,
1670                 sy: 1
1671             };
1672         };
1673         Element.prototype.rotate = function (deg, cx, cy) {
1674             if (deg == null) {
1675                 if (this._.rt.cx) {
1676                     return [this._.rt.deg, this._.rt.cx, this._.rt.cy].join(" ");
1677                 }
1678                 return this._.rt.deg;
1679             }
1680             deg = (deg + "").split(separator);
1681             if (deg.length - 1) {
1682                 cx = parseFloat(deg[1]);
1683                 cy = parseFloat(deg[2]);
1684             }
1685             deg = parseFloat(deg[0]);
1686             if (cx != null) {
1687                 this._.rt.deg = deg;
1688             } else {
1689                 this._.rt.deg += deg;
1690             }
1691             (cy == null) && (cx = null);
1692             this._.rt.cx = cx;
1693             this._.rt.cy = cy;
1694             this.setBox(this.attrs, cx, cy);
1695             this.Group.style.rotation = this._.rt.deg;
1696             // gradient fix for rotation. TODO
1697             // var fill = (this.shape || this.node).getElementsByTagName("fill");
1698             // fill = fill[0] || {};
1699             // var b = ((360 - this._.rt.deg) - 270) % 360;
1700             // typeof fill.angle != "undefined" && (fill.angle = b);
1701             return this;
1702         };
1703         Element.prototype.setBox = function (params, cx, cy) {
1704             var gs = this.Group.style,
1705                 os = (this.shape && this.shape.style) || this.node.style;
1706             params = params || {};
1707             for (var i in params) {
1708                 this.attrs[i] = params[i];
1709             }
1710             cx = cx || this._.rt.cx;
1711             cy = cy || this._.rt.cy;
1712             var attr = this.attrs,
1713                 x,
1714                 y,
1715                 w,
1716                 h;
1717             switch (this.type) {
1718                 case "circle":
1719                     x = attr.cx - attr.r;
1720                     y = attr.cy - attr.r;
1721                     w = h = attr.r * 2;
1722                     break;
1723                 case "ellipse":
1724                     x = attr.cx - attr.rx;
1725                     y = attr.cy - attr.ry;
1726                     w = attr.rx * 2;
1727                     h = attr.ry * 2;
1728                     break;
1729                 case "rect":
1730                 case "image":
1731                     x = attr.x;
1732                     y = attr.y;
1733                     w = attr.width || 0;
1734                     h = attr.height || 0;
1735                     break;
1736                 case "text":
1737                     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("");
1738                     x = attr.x - Math.round(this.W / 2);
1739                     y = attr.y - this.H / 2;
1740                     w = this.W;
1741                     h = this.H;
1742                     break;
1743                 case "path":
1744                     if (!this.attrs.path) {
1745                         x = 0;
1746                         y = 0;
1747                         w = this.paper.width;
1748                         h = this.paper.height;
1749                     } else {
1750                         var dim = pathDimensions(this.attrs.path),
1751                         x = dim.x;
1752                         y = dim.y;
1753                         w = dim.width;
1754                         h = dim.height;
1755                     }
1756                     break;
1757                 default:
1758                     x = 0;
1759                     y = 0;
1760                     w = this.paper.width;
1761                     h = this.paper.height;
1762                     break;
1763             }
1764             cx = (cx == null) ? x + w / 2 : cx;
1765             cy = (cy == null) ? y + h / 2 : cy;
1766             var left = cx - this.paper.width / 2,
1767                 top = cy - this.paper.height / 2;
1768             if (this.type == "path" || this.type == "text") {
1769                 (gs.left != left + "px") && (gs.left = left + "px");
1770                 (gs.top != top + "px") && (gs.top = top + "px");
1771                 this.X = this.type == "text" ? x : -left;
1772                 this.Y = this.type == "text" ? y : -top;
1773                 this.W = w;
1774                 this.H = h;
1775                 (os.left != -left + "px") && (os.left = -left + "px");
1776                 (os.top != -top + "px") && (os.top = -top + "px");
1777             } else {
1778                 (gs.left != left + "px") && (gs.left = left + "px");
1779                 (gs.top != top + "px") && (gs.top = top + "px");
1780                 this.X = x;
1781                 this.Y = y;
1782                 this.W = w;
1783                 this.H = h;
1784                 (gs.width != this.paper.width + "px") && (gs.width = this.paper.width + "px");
1785                 (gs.height != this.paper.height + "px") && (gs.height = this.paper.height + "px");
1786                 (os.left != x - left + "px") && (os.left = x - left + "px");
1787                 (os.top != y - top + "px") && (os.top = y - top + "px");
1788                 (os.width != w + "px") && (os.width = w + "px");
1789                 (os.height != h + "px") && (os.height = h + "px");
1790                 var arcsize = (+params.r || 0) / (Math.min(w, h));
1791                 if (this.type == "rect" && this.arcsize != arcsize && (arcsize || this.arcsize)) {
1792                     // We should replace element with the new one
1793                     var o = createNode(arcsize ? "roundrect" : "rect");
1794                     o.arcsize = arcsize;
1795                     this.Group.appendChild(o);
1796                     this.node.parentNode.removeChild(this.node);
1797                     this.node = o;
1798                     this.arcsize = arcsize;
1799                     setFillAndStroke(this, this.attrs);
1800                     this.setBox(this.attrs);
1801                 }
1802             }
1803         };
1804         Element.prototype.hide = function () {
1805             this.Group.style.display = "none";
1806             return this;
1807         };
1808         Element.prototype.show = function () {
1809             this.Group.style.display = "block";
1810             return this;
1811         };
1812         Element.prototype.getBBox = function () {
1813             if (this.type == "path") {
1814                 return pathDimensions(this.attr("path"));
1815             }
1816             return {
1817                 x: this.X + (this.bbx || 0),
1818                 y: this.Y,
1819                 width: this.W,
1820                 height: this.H
1821             };
1822         };
1823         Element.prototype.remove = function () {
1824             this[0].parentNode.removeChild(this[0]);
1825             this.Group.parentNode.removeChild(this.Group);
1826             this.shape && this.shape.parentNode.removeChild(this.shape);
1827         };
1828         Element.prototype.attr = function () {
1829             if (arguments.length == 1 && typeof arguments[0] == "string") {
1830                 if (arguments[0] == "translation") {
1831                     return this.translate();
1832                 }
1833                 if (arguments[0] == "rotation") {
1834                     return this.rotate();
1835                 }
1836                 if (arguments[0] == "scale") {
1837                     return this.scale();
1838                 }
1839                 return this.attrs[arguments[0]];
1840             }
1841             if (this.attrs && arguments.length == 1 && R.isArray(arguments[0])) {
1842                 var values = {};
1843                 for (var i = 0, ii = arguments[0].length; i < ii; i++) {
1844                     values[arguments[0][i]] = this.attrs[arguments[0][i]];
1845                 };
1846                 return values;
1847             }
1848             var params;
1849             if (arguments.length == 2) {
1850                 params = {};
1851                 params[arguments[0]] = arguments[1];
1852             }
1853             if (arguments.length == 1 && typeof arguments[0] == "object") {
1854                 params = arguments[0];
1855             }
1856             if (params) {
1857                 if (params.gradient) {
1858                     addGradientFill(this, params.gradient);
1859                 }
1860                 if (params.text && this.type == "text") {
1861                     this.node.string = params.text;
1862                 }
1863                 setFillAndStroke(this, params);
1864                 this.setBox(this.attrs);
1865             }
1866             return this;
1867         };
1868         Element.prototype.toFront = function () {
1869             this.Group.parentNode.appendChild(this.Group);
1870             return this;
1871         };
1872         Element.prototype.toBack = function () {
1873             if (this.Group.parentNode.firstChild != this.Group) {
1874                 this.Group.parentNode.insertBefore(this.Group, this.Group.parentNode.firstChild);
1875             }
1876             return this;
1877         };
1878         Element.prototype.insertAfter = function (element) {
1879             if (element.Group.nextSibling) {
1880                 element.Group.parentNode.insertBefore(this.Group, element.Group.nextSibling);
1881             } else {
1882                 element.Group.parentNode.appendChild(this.Group);
1883             }
1884             return this;
1885         };
1886         Element.prototype.insertBefore = function (element) {
1887             element.Group.parentNode.insertBefore(this.Group, element.Group);
1888             return this;
1889         };
1890         var theCircle = function (vml, x, y, r) {
1891             var g = createNode("group"),
1892                 gl = g.style,
1893                 o = createNode("oval"),
1894                 ol = o.style;
1895             gl.position = "absolute";
1896             gl.left = 0;
1897             gl.top = 0;
1898             gl.width = vml.width + "px";
1899             gl.height = vml.height + "px";
1900             g.coordsize = vml.coordsize;
1901             g.coordorigin = vml.coordorigin;
1902             g.appendChild(o);
1903             var res = new Element(o, g, vml);
1904             res.type = "circle";
1905             setFillAndStroke(res, {stroke: "#000", fill: "none"});
1906             res.attrs.cx = x;
1907             res.attrs.cy = y;
1908             res.attrs.r = r;
1909             res.setBox({x: x - r, y: y - r, width: r * 2, height: r * 2});
1910             vml.canvas.appendChild(g);
1911             return res;
1912         };
1913         var theRect = function (vml, x, y, w, h, r) {
1914             var g = createNode("group"),
1915                 gl = g.style,
1916                 o = createNode(r ? "roundrect" : "rect"),
1917                 arcsize = (+r || 0) / (Math.min(w, h));
1918             o.arcsize = arcsize;
1919             gl.position = "absolute";
1920             gl.left = 0;
1921             gl.top = 0;
1922             gl.width = vml.width + "px";
1923             gl.height = vml.height + "px";
1924             g.coordsize = vml.coordsize;
1925             g.coordorigin = vml.coordorigin;
1926             g.appendChild(o);
1927             var res = new Element(o, g, vml);
1928             res.type = "rect";
1929             setFillAndStroke(res, {stroke: "#000"});
1930             res.arcsize = arcsize;
1931             res.setBox({x: x, y: y, width: w, height: h, r: +r});
1932             vml.canvas.appendChild(g);
1933             return res;
1934         };
1935         var theEllipse = function (vml, x, y, rx, ry) {
1936             var g = createNode("group"),
1937                 gl = g.style,
1938                 o = createNode("oval"),
1939                 ol = o.style;
1940             gl.position = "absolute";
1941             gl.left = 0;
1942             gl.top = 0;
1943             gl.width = vml.width + "px";
1944             gl.height = vml.height + "px";
1945             g.coordsize = vml.coordsize;
1946             g.coordorigin = vml.coordorigin;
1947             g.appendChild(o);
1948             var res = new Element(o, g, vml);
1949             res.type = "ellipse";
1950             setFillAndStroke(res, {stroke: "#000"});
1951             res.attrs.cx = x;
1952             res.attrs.cy = y;
1953             res.attrs.rx = rx;
1954             res.attrs.ry = ry;
1955             res.setBox({x: x - rx, y: y - ry, width: rx * 2, height: ry * 2});
1956             vml.canvas.appendChild(g);
1957             return res;
1958         };
1959         var theImage = function (vml, src, x, y, w, h) {
1960             var g = createNode("group"),
1961                 gl = g.style,
1962                 o = createNode("image"),
1963                 ol = o.style;
1964             gl.position = "absolute";
1965             gl.left = 0;
1966             gl.top = 0;
1967             gl.width = vml.width + "px";
1968             gl.height = vml.height + "px";
1969             g.coordsize = vml.coordsize;
1970             g.coordorigin = vml.coordorigin;
1971             o.src = src;
1972             g.appendChild(o);
1973             var res = new Element(o, g, vml);
1974             res.type = "image";
1975             res.attrs.src = src;
1976             res.attrs.x = x;
1977             res.attrs.y = y;
1978             res.attrs.w = w;
1979             res.attrs.h = h;
1980             res.setBox({x: x, y: y, width: w, height: h});
1981             vml.canvas.appendChild(g);
1982             return res;
1983         };
1984         var theText = function (vml, x, y, text) {
1985             var g = createNode("group"),
1986                 gs = g.style,
1987                 el = createNode("shape"),
1988                 ol = el.style,
1989                 path = createNode("path"),
1990                 ps = path.style,
1991                 o = createNode("textpath");
1992             gs.position = "absolute";
1993             gs.left = 0;
1994             gs.top = 0;
1995             gs.width = vml.width + "px";
1996             gs.height = vml.height + "px";
1997             g.coordsize = vml.coordsize;
1998             g.coordorigin = vml.coordorigin;
1999             path.v = ["m", Math.round(x), ", ", Math.round(y), "l", Math.round(x) + 1, ", ", Math.round(y)].join("");
2000             path.textpathok = true;
2001             ol.width = vml.width;
2002             ol.height = vml.height;
2003             gs.position = "absolute";
2004             gs.left = 0;
2005             gs.top = 0;
2006             gs.width = vml.width;
2007             gs.height = vml.height;
2008             o.string = text;
2009             o.on = true;
2010             el.appendChild(o);
2011             el.appendChild(path);
2012             g.appendChild(el);
2013             var res = new Element(o, g, vml);
2014             res.shape = el;
2015             res.textpath = path;
2016             res.type = "text";
2017             res.attrs.text = text;
2018             res.attrs.x = x;
2019             res.attrs.y = y;
2020             res.attrs.w = 1;
2021             res.attrs.h = 1;
2022             setFillAndStroke(res, {font: availableAttrs.font, stroke: "none", fill: "#000"});
2023             res.setBox();
2024             vml.canvas.appendChild(g);
2025             return res;
2026         };
2027         var setSize = function (width, height) {
2028             var cs = this.canvas.style;
2029             this.width = width || this.width;
2030             this.height = height || this.height;
2031             cs.width = this.width + "px";
2032             cs.height = this.height + "px";
2033             cs.clip = "rect(0 " + this.width + "px " + this.height + "px 0)";
2034             this.canvas.coordsize = this.width + " " + this.height;
2035             return this;
2036         };
2037         doc.createStyleSheet().addRule(".rvml", "behavior:url(#default#VML)");
2038         try {
2039             if (!doc.namespaces.rvml) {
2040                 doc.namespaces.add("rvml", "urn:schemas-microsoft-com:vml");
2041             }
2042             var createNode = function (tagName) {
2043                 return doc.createElement('<rvml:' + tagName + ' class="rvml">');
2044             };
2045         } catch (e) {
2046             var createNode = function (tagName) {
2047                 return doc.createElement('<' + tagName + ' xmlns="urn:schemas-microsoft.com:vml" class="rvml">');
2048             };
2049         }
2050         var create = function () {
2051             var con = getContainer.apply(null, arguments),
2052                 container = con.container,
2053                 x = con.x,
2054                 y = con.y,
2055                 width = con.width,
2056                 s,
2057                 height = con.height;
2058             if (!container) {
2059                 throw new Error("VML container not found.");
2060             }
2061             var c = paper.canvas = doc.createElement("div"),
2062                 cs = c.style;
2063             width = parseFloat(width) || "512px";
2064             height = parseFloat(height) || "342px";
2065             paper.width = width;
2066             paper.height = height;
2067             paper.coordsize = width + " " + height;
2068             paper.coordorigin = "0 0";
2069             paper.span = doc.createElement("span");
2070             s = paper.span.style;
2071             c.appendChild(paper.span);
2072             s.position = "absolute";
2073             s.left = "-99999px";
2074             s.top = "-99999px";
2075             s.padding = 0;
2076             s.margin = 0;
2077             s.lineHeight = 1;
2078             s.display = "inline";
2079             cs.width  = width + "px";
2080             cs.height = height + "px";
2081             cs.position = "absolute";
2082             cs.clip = "rect(0 " + width + "px " + height + "px 0)";
2083             if (container == 1) {
2084                 doc.body.appendChild(c);
2085                 cs.left = x + "px";
2086                 cs.top = y + "px";
2087                 container = {
2088                     style: {
2089                         width: width,
2090                         height: height
2091                     }
2092                 };
2093             } else {
2094                 container.style.width = width;
2095                 container.style.height = height;
2096                 if (container.firstChild) {
2097                     container.insertBefore(c, container.firstChild);
2098                 } else {
2099                     container.appendChild(c);
2100                 }
2101             }
2102             for (var prop in paper) {
2103                 container[prop] = paper[prop];
2104             }
2105             plugins.call(container, container, R.fn);
2106             container.clear = function () {
2107                 while (c.firstChild) {
2108                     c.removeChild(c.firstChild);
2109                 }
2110             };
2111             container.raphael = R;
2112             return container;
2113         };
2114         paper.remove = function () {
2115             this.canvas.parentNode.removeChild(this.canvas);
2116         };
2117         paper.safari = function () {};
2118     }
2119
2120     // rest
2121
2122     // Events
2123     var addEvent = (function () {
2124         if (doc.addEventListener) {
2125             return function (obj, type, fn, element) {
2126                 var f = function (e) {
2127                     return fn.call(element, e);
2128                 };
2129                 obj.addEventListener(type, f, false);
2130                 return function () {
2131                     obj.removeEventListener(type, f, false);
2132                     return true;
2133                 };
2134             };
2135         } else if (doc.attachEvent) {
2136             return function (obj, type, fn, element) {
2137                 var f = function (e) {
2138                     return fn.call(element, e || win.event);
2139                 };
2140                 obj.attachEvent("on" + type, f);
2141                 var detacher = function () {
2142                     obj.detachEvent("on" + type, f);
2143                     return true;
2144                 };
2145                 if (type == "mouseover") {
2146                     obj.attachEvent("onmouseenter", f);
2147                     return function () {
2148                         obj.detachEvent("onmouseenter", f);
2149                         return detacher();
2150                     };
2151                 } else if (type == "mouseout") {
2152                     obj.attachEvent("onmouseleave", f);
2153                     return function () {
2154                         obj.detachEvent("onmouseleave", f);
2155                         return detacher();
2156                     };
2157                 }
2158                 return detacher;
2159             };
2160         }
2161     })();
2162     for (var i = events.length; i--;) {
2163         (function (eventName) {
2164             Element.prototype[eventName] = function (fn) {
2165                 if (typeof fn == "function") {
2166                     this.events = this.events || {};
2167                     this.events[eventName] = this.events[eventName] || {};
2168                     this.events[eventName][fn] = this.events[eventName][fn] || [];
2169                     this.events[eventName][fn].push(addEvent(this.shape || this.node, eventName, fn, this));
2170                 }
2171                 return this;
2172             };
2173             Element.prototype["un" + eventName] = function (fn) {
2174                 this.events &&
2175                 this.events[eventName] &&
2176                 this.events[eventName][fn] &&
2177                 this.events[eventName][fn].length &&
2178                 this.events[eventName][fn].shift()() &&
2179                 !this.events[eventName][fn].length &&
2180                 delete this.events[eventName][fn];
2181             };
2182
2183         })(events[i]);
2184     }
2185     paper.circle = function (x, y, r) {
2186         return theCircle(this, x, y, r);
2187     };
2188     paper.rect = function (x, y, w, h, r) {
2189         return theRect(this, x, y, w, h, r);
2190     };
2191     paper.ellipse = function (x, y, rx, ry) {
2192         return theEllipse(this, x, y, rx, ry);
2193     };
2194     paper.path = function (params, pathString) {
2195         if (typeof params == "string" && !pathString) {
2196             pathString = params;
2197             params = {};
2198         }
2199         params = params || {};
2200         return thePath(params, pathString, this);
2201     };
2202     paper.image = function (src, x, y, w, h) {
2203         return theImage(this, src, x, y, w, h);
2204     };
2205     paper.text = function (x, y, text) {
2206         return theText(this, x, y, text);
2207     };
2208     paper.drawGrid = function (x, y, w, h, wv, hv, color) {
2209         color = color || "#000";
2210         var path = ["M", x, y, "L", x + w, y, x + w, y + h, x, y + h, x, y],
2211             rowHeight = h / hv,
2212             columnWidth = w / wv;
2213         for (var i = 1; i < hv; i++) {
2214             path = path.concat(["M", x, y + i * rowHeight, "L", x + w, y + i * rowHeight]);
2215         }
2216         for (var i = 1; i < wv; i++) {
2217             path = path.concat(["M", x + i * columnWidth, y, "L", x + i * columnWidth, y + h]);
2218         }
2219         return this.path({stroke: color, "stroke-width": 1}, path.join(","));
2220     };
2221     paper.set = function (itemsArray) {
2222         return new Set(itemsArray);
2223     };
2224     paper.setSize = setSize;
2225     Element.prototype.stop = function () {
2226         clearTimeout(this.animation_in_progress);
2227     };
2228     Element.prototype.scale = function (x, y, cx, cy) {
2229         if (x == null && y == null) {
2230             return {x: this._.sx, y: this._.sy, toString: function () { return +this.x.toFixed(3) + " " + (+this.y.toFixed(3)); }};
2231         }
2232         y = y || x;
2233         !+y && (y = x);
2234         var dx,
2235             dy,
2236             dcx,
2237             dcy,
2238             a = this.attrs;
2239         if (x != 0) {
2240             var bb = this.type == "path" ? pathDimensions(a.path) : this.getBBox(),
2241                 rcx = bb.x + bb.width / 2,
2242                 rcy = bb.y + bb.height / 2,
2243                 kx = x / this._.sx,
2244                 ky = y / this._.sy;
2245             cx = (+cx || cx == 0) ? cx : rcx;
2246             cy = (+cy || cy == 0) ? cy : rcy;
2247             var dirx = Math.round(x / Math.abs(x)),
2248                 diry = Math.round(y / Math.abs(y)),
2249                 s = this.node.style,
2250                 ncx = cx + (rcx - cx) * dirx * kx,
2251                 ncy = cy + (rcy - cy) * diry * ky;
2252             switch (this.type) {
2253                 case "rect":
2254                 case "image":
2255                     var neww = a.width * dirx * kx,
2256                         newh = a.height * diry * ky,
2257                         newx = ncx - neww / 2,
2258                         newy = ncy - newh / 2;
2259                     this.attr({
2260                         width: neww,
2261                         height: newh,
2262                         x: newx,
2263                         y: newy
2264                     });
2265                     break;
2266                 case "circle":
2267                 case "ellipse":
2268                     this.attr({
2269                         rx: a.rx * kx,
2270                         ry: a.ry * ky,
2271                         r: a.r * kx,
2272                         cx: ncx,
2273                         cy: ncy
2274                     });
2275                     break;
2276                 case "path":
2277                     var path = pathToRelative(a.path),
2278                         skip = true;
2279                     for (var i = 0, ii = path.length; i < ii; i++) {
2280                         var p = path[i];
2281                         if (p[0].toUpperCase() == "M" && skip) {
2282                             continue;
2283                         } else {
2284                             skip = false;
2285                         }
2286                         if (R.svg && p[0].toUpperCase() == "A") {
2287                             p[path[i].length - 2] *= kx;
2288                             p[path[i].length - 1] *= ky;
2289                             p[1] *= kx;
2290                             p[2] *= ky;
2291                             p[5] = +(dirx + diry ? !!+p[5] : !+p[5]);
2292                         } else {
2293                             for (var j = 1, jj = p.length; j < jj; j++) {
2294                                 p[j] *= (j % 2) ? kx : ky;
2295                             }
2296                         }
2297                     }
2298                     var dim2 = pathDimensions(path),
2299                         dx = ncx - dim2.x - dim2.width / 2,
2300                         dy = ncy - dim2.y - dim2.height / 2;
2301                     path = pathToRelative(path);
2302                     path[0][1] += dx;
2303                     path[0][2] += dy;
2304                     
2305                     this.attr({path: path.join(" ")});
2306                 break;
2307             }
2308             if (this.type in {text: 1, image:1} && (dirx != 1 || diry != 1)) {
2309                 if (this.transformations) {
2310                     this.transformations[2] = "scale(".concat(dirx, ",", diry, ")");
2311                     this.node.setAttribute("transform", this.transformations.join(" "));
2312                     dx = (dirx == -1) ? -a.x - (neww || 0) : a.x;
2313                     dy = (diry == -1) ? -a.y - (newh || 0) : a.y;
2314                     this.attr({x: dx, y: dy});
2315                     a.fx = dirx - 1;
2316                     a.fy = diry - 1;
2317                 } else {
2318                     this.node.filterMatrix = " progid:DXImageTransform.Microsoft.Matrix(M11=".concat(dirx,
2319                         ", M12=0, M21=0, M22=", diry,
2320                         ", Dx=0, Dy=0, sizingmethod='auto expand', filtertype='bilinear')");
2321                     s.filter = (this.node.filterMatrix || "") + (this.node.filterOpacity || "");
2322                 }
2323             } else {
2324                 if (this.transformations) {
2325                     this.transformations[2] = "";
2326                     this.node.setAttribute("transform", this.transformations.join(" "));
2327                     a.fx = 0;
2328                     a.fy = 0;
2329                 } else {
2330                     this.node.filterMatrix = "";
2331                     s.filter = (this.node.filterMatrix || "") + (this.node.filterOpacity || "");
2332                 }
2333             }
2334             a.scale = [x, y, cx, cy].join(" ");
2335             this._.sx = x;
2336             this._.sy = y;
2337         }
2338         return this;
2339     };
2340
2341     R.easing_formulas = {
2342         linear: function (n) {
2343             return n;
2344         },
2345         "<": function (n) {
2346             return Math.pow(n, 3);
2347         },
2348         ">": function (n) {
2349             return Math.pow(n - 1, 3) + 1;
2350         },
2351         "<>": function (n) {
2352             n = n * 2;
2353             if (n < 1) {
2354                 return Math.pow(n, 3) / 2;
2355             }
2356             n -= 2;
2357             return (Math.pow(n, 3) + 2) / 2;
2358         },
2359         backIn: function (n) {
2360             var s = 1.70158;
2361             return Math.pow(n, 2) * ((s + 1) * n - s);
2362         },
2363         backOut: function (n) {
2364             n = n - 1;
2365             var s = 1.70158;
2366             return Math.pow(n, 2) * ((s + 1) * n + s) + 1;
2367         },
2368         elastic: function (n) {
2369             if (n == 0 || n == 1) {
2370                 return n;
2371             }
2372             var p = .3,
2373                 s = p / 4;
2374             return Math.pow(2, -10 * n) * Math.sin((n - s) * (2 * Math.PI) / p) + 1;
2375         },
2376         bounce: function (n) {
2377             var s = 7.5625,
2378                 p = 2.75,
2379                 l;
2380             if (n < (1 / p)) {
2381                 l = s * Math.pow(n, 2);
2382             } else {
2383                 if (n < (2 / p)) {
2384                     n -= (1.5 / p);
2385                     l = s * Math.pow(n, 2) + .75;
2386                 } else {
2387                     if (n < (2.5 / p)) {
2388                         n -= (2.25 / p);
2389                         l = s * Math.pow(n, 2) + .9375;
2390                     } else {
2391                         n -= (2.625 / p);
2392                         l = s * Math.pow(n, 2) + .984375;
2393                     }
2394                 }
2395             }
2396             return l;
2397         }
2398     };
2399
2400     // animation easing formulas
2401     R.easing = function(easing, n) {
2402         return R.easing_formulas[easing] ? R.easing_formulas[easing](n) : n;
2403     };
2404
2405     Element.prototype.animate = function (params, ms, easing, callback) {
2406         clearTimeout(this.animation_in_progress);
2407         if (typeof easing == "function" || !easing) {
2408             callback = easing || null;
2409             easing = "linear";
2410         }
2411         var from = {},
2412             to = {},
2413             diff = {},
2414             t = {x: 0, y: 0};
2415         for (var attr in params) {
2416             if (attr in availableAnimAttrs) {
2417                 from[attr] = this.attr(attr);
2418                 (typeof from[attr] == "undefined") && (from[attr] = availableAttrs[attr]);
2419                 to[attr] = params[attr];
2420                 switch (availableAnimAttrs[attr]) {
2421                     case "number":
2422                         diff[attr] = (to[attr] - from[attr]) / ms;
2423                         break;
2424                     case "colour":
2425                         from[attr] = R.getRGB(from[attr]);
2426                         var toColour = R.getRGB(to[attr]);
2427                         diff[attr] = {
2428                             r: (toColour.r - from[attr].r) / ms,
2429                             g: (toColour.g - from[attr].g) / ms,
2430                             b: (toColour.b - from[attr].b) / ms
2431                         };
2432                         break;
2433                     case "path":
2434                         var pathes = path2curve(from[attr], to[attr]);
2435                         from[attr] = pathes[0];
2436                         to[attr] = pathes[1];
2437                         diff[attr] = [];
2438                         for (var i = 0, ii = from[attr].length; i < ii; i++) {
2439                             diff[attr][i] = [0];
2440                             for (var j = 1, jj = from[attr][i].length; j < jj; j++) {
2441                                 diff[attr][i][j] = (to[attr][i][j] - from[attr][i][j]) / ms;
2442                             }
2443                         }
2444                         break;
2445                     case "csv":
2446                         var values = (params[attr] + "").split(separator),
2447                             from2 = (from[attr] + "").split(separator);
2448                         switch (attr) {
2449                             case "translation":
2450                                 from[attr] = [0, 0];
2451                                 diff[attr] = [values[0] / ms, values[1] / ms];
2452                             break;
2453                             case "rotation":
2454                                 from[attr] = (from2[1] == values[1] && from2[2] == values[2]) ? from2 : [0, values[1], values[2]];
2455                                 diff[attr] = [(values[0] - from[attr][0]) / ms, 0, 0];
2456                             break;
2457                             case "scale":
2458                                 params[attr] = values;
2459                                 from[attr] = (from[attr] + "").split(separator);
2460                                 diff[attr] = [(values[0] - from[attr][0]) / ms, (values[1] - from[attr][1]) / ms, 0, 0];
2461                         }
2462                         to[attr] = values;
2463                 }
2464             }
2465         }
2466         var start = +new Date,
2467             prev = 0,
2468             that = this;
2469         (function tick() {
2470             var time = new Date - start,
2471                 set = {},
2472                 now;
2473             if (time < ms) {
2474                 pos = R.easing(easing, time / ms);
2475                 for (var attr in from) {
2476                     switch (availableAnimAttrs[attr]) {
2477                         case "number":
2478                             now = +from[attr] + pos * ms * diff[attr];
2479                             break;
2480                         case "colour":
2481                             now = "rgb(" + [
2482                                 Math.round(from[attr].r + pos * ms * diff[attr].r),
2483                                 Math.round(from[attr].g + pos * ms * diff[attr].g),
2484                                 Math.round(from[attr].b + pos * ms * diff[attr].b)
2485                             ].join(",") + ")";
2486                             break;
2487                         case "path":
2488                             now = [];
2489                             for (var i = 0, ii = from[attr].length; i < ii; i++) {
2490                                 now[i] = [from[attr][i][0]];
2491                                 for (var j = 1, jj = from[attr][i].length; j < jj; j++) {
2492                                     now[i][j] = +from[attr][i][j] + pos * ms * diff[attr][i][j];
2493                                 }
2494                                 now[i] = now[i].join(" ");
2495                             }
2496                             now = now.join(" ");
2497                             break;
2498                         case "csv":
2499                             switch (attr) {
2500                                 case "translation":
2501                                     var x = diff[attr][0] * (time - prev),
2502                                         y = diff[attr][1] * (time - prev);
2503                                     t.x += x;
2504                                     t.y += y;
2505                                     now = [x, y].join(" ");
2506                                 break;
2507                                 case "rotation":
2508                                     now = +from[attr][0] + pos * ms * diff[attr][0];
2509                                     from[attr][1] && (now += "," + from[attr][1] + "," + from[attr][2]);
2510                                 break;
2511                                 case "scale":
2512                                     now = [+from[attr][0] + pos * ms * diff[attr][0], +from[attr][1] + pos * ms * diff[attr][1], (2 in params[attr] ? params[attr][2] : ""), (3 in params[attr] ? params[attr][3] : "")].join(" ");
2513                             }
2514                             break;
2515                     }
2516                     if (attr == "font-size") {
2517                         set[attr] = now + "px";
2518                     } else {
2519                         set[attr] = now;
2520                     }
2521                 }
2522                 that.attr(set);
2523                 that.animation_in_progress = setTimeout(tick);
2524                 R.svg && paper.safari();
2525             } else {
2526                 (t.x || t.y) && that.translate(-t.x, -t.y);
2527                 that.attr(params);
2528                 clearTimeout(that.animation_in_progress);
2529                 R.svg && paper.safari();
2530                 (typeof callback == "function") && callback.call(that);
2531             }
2532             prev = time;
2533         })();
2534         return this;
2535     };
2536     Element.prototype.translate = function (x, y) {
2537         if (x == null) {
2538             return {x: this._.tx, y: this._.ty};
2539         }
2540         this._.tx += +x;
2541         this._.ty += +y;
2542         switch (this.type) {
2543             case "circle":
2544             case "ellipse":
2545                 this.attr({cx: +x + this.attrs.cx, cy: +y + this.attrs.cy});
2546                 break;
2547             case "rect":
2548             case "image":
2549             case "text":
2550                 this.attr({x: +x + this.attrs.x, y: +y + this.attrs.y});
2551                 break;
2552             case "path":
2553                 var path = pathToRelative(this.attrs.path);
2554                 path[0][1] += +x;
2555                 path[0][2] += +y;
2556                 this.attr({path: path.join(" ")});
2557             break;
2558         }
2559         return this;
2560     };
2561
2562     // Set
2563     var Set = function (items) {
2564         this.items = [];
2565         this.length = 0;
2566         if (items) {
2567             for (var i = 0, ii = items.length; i < ii; i++) {
2568                 if (items[i] && (items[i].constructor == Element || items[i].constructor == Set)) {
2569                     this[this.items.length] = this.items[this.items.length] = items[i];
2570                     this.length++;
2571                 }
2572             }
2573         }
2574     };
2575     Set.prototype.push = function () {
2576         var item,
2577             len;
2578         for (var i = 0, ii = arguments.length; i < ii; i++) {
2579             item = arguments[i];
2580             if (item && (item.constructor == Element || item.constructor == Set)) {
2581                 len = this.items.length;
2582                 this[len] = this.items[len] = item;
2583                 this.length++;
2584             }
2585         }
2586         return this;
2587     };
2588     Set.prototype.pop = function (id) {
2589         var res = this.items.splice(id, 1)[0];
2590         for (var j = id, jj = this.items.length; j < jj; j++) {
2591             this[j] = this[j + 1];
2592         }
2593         delete this[jj + 1];
2594         this.length--;
2595         return res;
2596     };
2597     for (var method in Element.prototype) {
2598         Set.prototype[method] = (function (methodname) {
2599             return function () {
2600                 for (var i = 0, ii = this.items.length; i < ii; i++) {
2601                     this.items[i][methodname].apply(this.items[i], arguments);
2602                 }
2603                 return this;
2604             };
2605         })(method);
2606     }
2607     Set.prototype.attr = function (name, value) {
2608         if (name && R.isArray(name) && typeof name[0] == "object") {
2609             for (var j = 0, jj = name.length; j < jj; j++) {
2610                 this.items[j].attr(name[j]);
2611             }
2612         } else {
2613             for (var i = 0, ii = this.items.length; i < ii; i++) {
2614                 this.items[i].attr.apply(this.items[i], arguments);
2615             }
2616         }
2617         return this;
2618     };
2619     
2620     Set.prototype.getBBox = function () {
2621         var x = [],
2622             y = [],
2623             w = [],
2624             h = [];
2625         for (var i = this.items.length; i--;) {
2626             var box = this.items[i].getBBox();
2627             x.push(box.x);
2628             y.push(box.y);
2629             w.push(box.x + box.width);
2630             h.push(box.y + box.height);
2631         }
2632         x = Math.min.apply(Math, x);
2633         y = Math.min.apply(Math, y);
2634         return {
2635             x: x,
2636             y: y,
2637             width: Math.max.apply(Math, w) - x,
2638             height: Math.max.apply(Math, h) - y
2639         };
2640     };
2641
2642     R.registerFont = function (font) {
2643         if (!font.face) {
2644             return font;
2645         }
2646         this.fonts = this.fonts || {};
2647         var fontcopy = {
2648                 w: font.w,
2649                 face: {},
2650                 glyphs: {}
2651             },
2652             family = font.face["font-family"];
2653         for (var prop in font.face) {
2654             fontcopy.face[prop] = font.face[prop];
2655         }
2656         if (this.fonts[family]) {
2657             this.fonts[family].push(fontcopy);
2658         } else {
2659             this.fonts[family] = [fontcopy];
2660         }
2661         if (!font.svg) {
2662             fontcopy.face["units-per-em"] = parseInt(font.face["units-per-em"], 10);
2663             for (var glyph in font.glyphs) {
2664                 var path = font.glyphs[glyph];
2665                 fontcopy.glyphs[glyph] = {
2666                     w: path.w,
2667                     k: {},
2668                     d: path.d && "M" + path.d.replace(/[mlcxtrv]/g, function (command) {
2669                             return {l: "L", c: "C", x: "z", t: "m", r: "l", v: "c"}[command] || "M";
2670                         }) + "z"
2671                 };
2672                 if (path.k) {
2673                     for (var k in path.k) {
2674                         fontcopy.glyphs[glyph].k[k] = path.k[k];
2675                     }
2676                 }
2677             }
2678         }
2679         return font;
2680     };
2681     paper.getFont = function (family, weight, style, stretch) {
2682         stretch = stretch || "normal";
2683         style = style || "normal";
2684         weight = +weight || {normal: 400, bold: 700, lighter: 300, bolder: 800}[weight] || 400;
2685         var font = R.fonts[family];
2686         if (!font) {
2687             var name = new RegExp("(^|\\s)" + family.replace(/[^\w\d\s+!~.:_-]/g, "") + "(\\s|$)", "i");
2688             for (var fontName in R.fonts) {
2689                 if (name.test(fontName)) {
2690                     font = R.fonts[fontName];
2691                     break;
2692                 }
2693             }
2694         }
2695         var thefont;
2696         if (font) {
2697             for (var i = 0, ii = font.length; i < ii; i++) {
2698                 thefont = font[i];
2699                 if (thefont.face["font-weight"] == weight && (thefont.face["font-style"] == style || !thefont.face["font-style"]) && thefont.face["font-stretch"] == stretch) {
2700                     break;
2701                 }
2702             }
2703         }
2704         return thefont;
2705     };
2706     paper.print = function (x, y, string, font, size) {
2707         var out = this.set(),
2708             letters = (string + "").split(""),
2709             shift = 0,
2710             path = "",
2711             scale;
2712         if (font) {
2713             scale = (size || 16) / font.face["units-per-em"];
2714             for (var i = 0, ii = letters.length; i < ii; i++) {
2715                 var prev = i && font.glyphs[letters[i - 1]] || {},
2716                     curr = font.glyphs[letters[i]];
2717                 shift += i ? (prev.w || font.w) + (prev.k && prev.k[letters[i]] || 0) : 0;
2718                 curr && curr.d && out.push(this.path({fill: "#000", stroke: "none"}, curr.d).translate(shift, 0));
2719             }
2720             out.scale(scale, scale, 0, y).translate(x, (size || 16) / 2);
2721         }
2722         return out;
2723     };
2724
2725     R.ninja = function () {
2726         var r = window.Raphael;
2727         if (oldRaphael.was) {
2728             window.Raphael = oldRaphael.is;
2729         } else {
2730             try {
2731                 delete window.Raphael;
2732             } catch (e) {
2733                 window.Raphael = void(0);
2734             }
2735         }
2736         return r;
2737     };
2738     R.el = Element.prototype;
2739     return R;
2740 })();
Rapheal SVG IE compatible library