From 26fd73e419ace1e95a9d5e1bb8ae318aa747c3d4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fr=C3=A9d=C3=A9ric=20van=20der=20Essen?= Date: Wed, 22 Feb 2012 10:23:20 +0100 Subject: [PATCH 001/196] Beginning the integration of the new diagram library bzr revid: fva@openerp.com-20120222092320-j05aesaglaglnovz --- addons/web_diagram/__openerp__.py | 2 + addons/web_diagram/static/src/js/diagram.js | 51 +- addons/web_diagram/static/src/js/graph.js | 485 ++ addons/web_diagram/static/src/js/raphael.js | 5462 +++++++++++++++++ .../web_diagram/static/src/js/vec2js/vec2.js | 486 ++ 5 files changed, 6479 insertions(+), 7 deletions(-) create mode 100644 addons/web_diagram/static/src/js/graph.js create mode 100644 addons/web_diagram/static/src/js/raphael.js create mode 100644 addons/web_diagram/static/src/js/vec2js/vec2.js diff --git a/addons/web_diagram/__openerp__.py b/addons/web_diagram/__openerp__.py index f46b17614b4..0aae81eb946 100644 --- a/addons/web_diagram/__openerp__.py +++ b/addons/web_diagram/__openerp__.py @@ -9,6 +9,8 @@ 'static/lib/js/dracula_graffle.js', 'static/lib/js/dracula_graph.js', 'static/lib/js/dracula_algorithms.js', + 'static/src/js/vec2js/vec2.js', + 'static/src/js/graph.js', 'static/src/js/diagram.js' ], 'css' : [ diff --git a/addons/web_diagram/static/src/js/diagram.js b/addons/web_diagram/static/src/js/diagram.js index 90f8000bc0f..cd360dcfafa 100644 --- a/addons/web_diagram/static/src/js/diagram.js +++ b/addons/web_diagram/static/src/js/diagram.js @@ -128,17 +128,54 @@ openerp.web.DiagramView = openerp.web.View.extend({ act_to: node.id }); }, + draw_diagram: function(result) { - this.selected_node = null; - var diagram = new Graph(); + console.log(result); + var res_nodes = result['nodes']; + var res_edges = result['conn']; + var id_to_node = {} + var edge_list = []; - this.active_model = result['id_model']; - var res_nodes = result['nodes']; - var res_connectors = result['conn']; - this.parent_field = result.parent_field; + var style = { "background" : 'url("grid.png")', + "edge" : "#A0A0A0", + "edge_label" : "#555", + "text" : "#333", + "outline" : "#000", + "selected" : "#0097BE", + "gray" : "#DCDCDC", + "white" : "#FFF", + "node_size_x" : 90, + "node_size_y" : 60, + "edge_spacing" : 100, + "edge_label_font_size" : 9 }; + var r = new Raphael(document.getElementById("dia-canvas"), '100%','500px'); + var graph = new CuteGraph(r,style); + + _.each(res_nodes, function(node) { + id_to_node[node.id] = new CuteNode( graph, + node.x, + node.y, + CuteGraph.wordwrap(node.name, 17), + node.shape === 'rectangle' ? 'rect' : 'circle', + node.color === 'white' ? style.white : style.gray ); + + }); + + _.each(res_edges, function(edge) { + edge_list.push( new CuteEdge( graph, + CuteGraph.wordwrap(edge.signal, 32), + id_to_node[edge.s_id], + id_to_node[edge.d_id] )); + }); + + /* //Custom logic + this.selected_node = null; + this.active_model = result['id_model']; + this.parent_field = result.parent_field; + var diagram = new Graph(); var self = this; var renderer = function(r, n) { var shape = (n.node.shape === 'rectangle') ? 'rect' : 'ellipse'; @@ -193,7 +230,7 @@ openerp.web.DiagramView = openerp.web.View.extend({ self.add_edit_node(edge_ids[index], self.connector); }); } - }); + });*/ }, add_edit_node: function(id, model, defaults) { diff --git a/addons/web_diagram/static/src/js/graph.js b/addons/web_diagram/static/src/js/graph.js new file mode 100644 index 00000000000..5228d1a6d7a --- /dev/null +++ b/addons/web_diagram/static/src/js/graph.js @@ -0,0 +1,485 @@ + +(function(window){ + + + // this serves as the end of an edge when creating a link + function EdgeEnd(pos_x,pos_y){ + this.x = pos_x; + this.y = pos_y; + + this.get_pos = function(){ + return new Vec2(this.x,this.y); + } + } + + // connectors are start and end point of edge creation drags. + function Connector(graph,node,pos_x,pos_y){ + var visible = false; + var conn_circle = graph.r.circle(node.get_pos().x + pos_x, node.get_pos().y + pos_y,4); + conn_circle.attr({'opacity':0, 'fill':graph.style.outline,'stroke':'none'}); + var self = this; + + this.update_pos = function(){ + conn_circle.attr({'cx':node.get_pos().x + pos_x, 'cy':node.get_pos().y + pos_y}); + } + this.get_pos = function(){ + return new node.get_pos().add_xy(pos_x,pos_y); + } + function hover_in(){ + if(!visible){ return;} + conn_circle.animate({'r':8},300,'elastic'); + if(graph.creating_edge){ + graph.target_node = node; + conn_circle.animate({'fill':graph.style.white,'stroke':graph.style.outline,'stroke-width':2},100,'linear'); + } + } + function hover_out(){ + if(!visible){ return;} + conn_circle.animate({'r':4, 'fill':graph.style.outline, 'stroke':'none'},400,'linear'); + graph.target_node = null; + } + conn_circle.hover(hover_in,hover_out); + + + var drag_down = function(){ + if(!visible){ return; } + self.ox = conn_circle.attr("cx"); + self.oy = conn_circle.attr("cy"); + self.edge_start = new EdgeEnd(self.ox,self.oy); + self.edge_end = new EdgeEnd(self.ox, self.oy); + self.edge_tmp = new GraphEdge(graph,'',self.edge_start,self.edge_end,true); + graph.creating_edge = true; + } + var drag_move = function(dx,dy){ + if(!visible){ return; } + self.edge_end.x = self.ox + dx; + self.edge_end.y = self.oy + dy; + self.edge_tmp.update(); + } + var drag_up = function(){ + if(!visible){ return; } + graph.creating_edge = false; + self.edge_tmp.remove(); + if(graph.target_node && graph.target_node != node){ + new GraphEdge(graph,'new edge!', node,graph.target_node); + } + } + conn_circle.drag(drag_move,drag_down,drag_up); + + function show(){ + if(!visible){ + conn_circle.animate({'opacity':1}, 100, 'linear'); + visible = true; + } + } + function hide(){ + if(visible){ + conn_circle.animate({'opacity':0}, 100, 'linear'); + visible = false; + } + } + + this.show = show; + this.hide = hide; + } + + function Graph(r,style){ + var nodes = []; // list of all nodes in the graph + var edges = []; // list of all edges in the graph + var graph = {}; // graph[n1.uid][n2.uid] -> list of all edges from n1 to n2 + var links = {} // links[n.uid] -> list of all edges from or to n + var uid = 1; // all nodes and edges have an uid used to order their display when they are curved + + this.creating_edge = false; // true if we are dragging a new edge onto a node + this.target_node = null; // this holds the target node when creating an edge and hovering a connector + this.r = r; // the raphael instance + this.style = style; // definition of the colors, spacing, fonts, ... used by the elements + + //adds a node to the graph and sets its uid. + this.add_node = function (n){ + nodes.push(n); + n.uid = uid++; + }; + //return the list of all nodes in the graph + this.get_node_list = function(){ + return nodes; + }; + //adds an edge to the graph and sets its uid + this.add_edge = function (n1,n2,e){ + edges.push(e); + e.uid = uid++; + if(!graph[n1.uid]) graph[n1.uid] = {}; + if(!graph[n1.uid][n2.uid]) graph[n1.uid][n2.uid] = []; + if(!links[n1.uid]) links[n1.uid] = []; + if(!links[n2.uid]) links[n2.uid] = []; + + graph[n1.uid][n2.uid].push(e); + links[n1.uid].push(e); + links[n2.uid].push(e); + }; + //return the list of edges from n1 to n2 + this.get_edge_list = function(n1,n2){ + var list = []; + if(!graph[n1.uid]) return list; + if(!graph[n1.uid][n2.uid]) return list; + return graph[n1.uid][n2.uid]; + }; + //returns the list of all edge connected to n + this.get_linked_edge_list = function(n){ + if(!links[n.uid]) return []; + return links[n.uid]; + } + //return a curvature index so that all edges connecting n1,n2 have different curvatures + this.get_edge_curvature = function(n1,n2,e){ + var el_12 = this.get_edge_list(n1,n2); + var c12 = el_12.length; + var el_21 = this.get_edge_list(n2,n1); + var c21 = el_21.length; + if(c12 + c21 == 1){ // only one edge + return 0; + }else{ + var index = 0; + for(var i = 0; i < c12; i++){ + if (el_12[i].uid < e.uid){ + index++; + } + } + if(c21 == 0){ // all edges in the same direction + return index - (c12-1)/2.0; + }else{ + return index + 0.5; + } + } + }; + } + + // creates a new Graph Node on Raphael document r, centered on [pos_x,pos_y], with label 'label', + // and of type 'circle' or 'rect', and of color 'color' + // TODO pass graph in constructor + function GraphNode(graph,pos_x, pos_y,label,type,color){ + var r = graph.r; + var sy = graph.style.node_size_y; + var sx = graph.style.node_size_x; + var node_fig = null; + //var node_shadow = null; + var self = this; + var selected = false; + this.update_time = 0; + this.connectors = []; + this.uid = 0; + + graph.add_node(this); + + if(type == 'circle'){ + node_fig = r.ellipse(pos_x,pos_y,sx/2,sy/2); + }else{ + node_fig = r.rect(pos_x-sx/2,pos_y-sy/2,sx,sy); + } + node_fig.attr({'fill':color, 'stroke':graph.style.outline,'stroke-width':1,'cursor':'pointer'}); + + var node_label = r.text(pos_x,pos_y,label); + node_label.attr({'fill':graph.style.text,'cursor':'pointer'}); + + + // sets the center position of the node + var set_pos = function(pos){ + if(type == 'circle'){ + node_fig.attr({'cx':pos.x,'cy':pos.y}); + }else{ + node_fig.attr({'x':pos.x-sx/2,'y':pos.y-sy/2}); + } + node_label.attr({'x':pos.x,'y':pos.y}); + for(var i = 0; i < self.connectors.length; i++){ + self.connectors[i].update_pos(); + } + var edges = graph.get_linked_edge_list(self); + for(var i = 0; i < edges.length; i++){ + edges[i].update(); + } + } + // returns the figure used to draw the node + var get_fig = function(){ + return node_fig; + } + // returns the center coordinates + var get_pos = function(){ + if(type == 'circle'){ + return new Vec2(node_fig.attr('cx'), node_fig.attr('cy')); + }else{ + return new Vec2(node_fig.attr('x') + sx/2, node_fig.attr('y') + sy/2); + } + } + // return the label string + var get_label = function(){ + return node_label.attr("text"); + } + // sets the label string + var set_label = function(text){ + node_label.attr({'text':text}); + } + var get_bound = function(){ + if(type == 'circle'){ + return new BEllipse(get_pos().x,get_pos().y,sx/2,sy/2); + }else{ + return BRect.new_centered(get_pos().x,get_pos().y,sx,sy); + } + } + // selects this node and deselects all other nodes + var set_selected = function(){ + if(!selected){ + node_fig.attr({'stroke':graph.style.selected, 'stroke-width':2}); + selected = true; + var nodes = graph.get_node_list(); + for(var i = 0; i < nodes.length; i++){ + if(nodes[i] != self){ + nodes[i].set_not_selected(); + } + } + for(var i = 0; i < self.connectors.length; i++){ + self.connectors[i].show(); + } + } + } + // deselect this node + var set_not_selected = function(){ + if(selected){ + node_fig.animate({'stroke':graph.style.outline,'stroke-width':1},100,'linear'); + selected = false; + } + for(var i = 0; i < self.connectors.length; i++){ + self.connectors[i].hide(); + } + } + + this.set_pos = set_pos; + this.get_pos = get_pos; + this.set_label = set_label; + this.get_label = get_label; + this.get_bound = get_bound; + this.get_fig = get_fig; + this.set_selected = set_selected; + this.set_not_selected = set_not_selected + + + //select the node and play an animation when clicked + var click_action = function(){ + if(type == 'circle'){ + node_fig.attr({'rx':sx/2 + 3, 'ry':sy/2+ 3}); + node_fig.animate({'rx':sx/2, 'ry':sy/2},500,'elastic'); + }else{ + var cx = get_pos().x; + var cy = get_pos().y; + node_fig.attr({'x':cx - (sx/2) - 3, 'y':cy - (sy/2) - 3, 'ẃidth':sx+6, 'height':sy+6}); + node_fig.animate({'x':cx - sx/2, 'y':cy - sy/2, 'ẃidth':sx, 'height':sy},500,'elastic'); + } + set_selected(); + } + node_fig.click(click_action); + node_label.click(click_action); + + //move the node when dragged + var drag_down = function(){ + this.opos = get_pos(); + } + var drag_move = function(dx,dy){ + // we disable labels when moving for performance reasons, + // updating the label position is quite expensive + // we put this here because drag_down is also called on simple clicks ... and this causes unwanted flicker + var edges = graph.get_linked_edge_list(self); + for(var i = 0; i < edges.length; i++){ + edges[i].label_disable(); + } + set_pos(this.opos.add_new_xy(dx,dy)); + } + var drag_up = function(){ + //we re-enable the + var edges = graph.get_linked_edge_list(self); + for(var i = 0; i < edges.length; i++){ + edges[i].label_enable(); + } + + } + node_fig.drag(drag_move,drag_down,drag_up); + node_label.drag(drag_move,drag_down,drag_up); + + //allow the user to create edges by dragging onto the node + function hover_in(){ + if(graph.creating_edge){ + graph.target_node = self; + } + } + function hover_out(){ + graph.target_node = null; + } + node_fig.hover(hover_in,hover_out); + node_label.hover(hover_in,hover_out); + + this.connectors.push(new Connector(graph,this,-sx/2,0)); + this.connectors.push(new Connector(graph,this,sx/2,0)); + this.connectors.push(new Connector(graph,this,0,-sy/2)); + this.connectors.push(new Connector(graph,this,0,sy/2)); + } + + // creates a new edge with label 'label' from start to end. start and end must implement get_pos_*, + // if tmp is true, the edge is not added to the graph, used for drag edges. TODO pass graph in constructor, + // replace tmp == false by graph == null + function GraphEdge(graph,label,start,end,tmp){ + var r = graph.r; + var update_time = -1; + var curvature = 0; // 0 = straight, != 0 curved + var s,e; // positions of the start and end point of the line between start and end + var mc; // position of the middle of the curve (bezier control point) + var elfs = graph.style.edge_label_font_size || 10 ; + var label_enabled = true; + this.uid = 0; // unique id used to order the curved edges + var self = this; + + if(!tmp){ + graph.add_edge(start,end,this); + } + + function get_label_pos(path){ + var cpos = path.getTotalLength() * 0.5; + var cindex = Math.abs(Math.floor(curvature)); + var mod = ((cindex % 3)) * (elfs * 3.1) - (elfs * 0.5); + var verticality = Math.abs(end.get_pos().sub_new(start.get_pos()).normalize().dot_xy(0,1)); + verticality = Math.max(verticality-0.5,0)*2; + + var lpos = path.getPointAtLength(cpos + mod * verticality); + return new Vec2(lpos.x,lpos.y - elfs *(1-verticality)); + } + + //computes new start and end line coordinates + function update_start_end_pos(){ + if(!tmp){ + curvature = graph.get_edge_curvature(start,end,self); + }else{ + curvature = 0; + } + s = start.get_pos(); + e = end.get_pos(); + mc = s.lerp_new(e,0.5); //middle of the line s->e + var se = e.sub_new(s); + se.normalize(); + se.rotate_deg(-90); + se.scale(curvature * graph.style.edge_spacing); + mc.add(se); + if(start.get_bound){ + var col = start.get_bound().collide_segment(s,mc); + if(col.length > 0){ + s = col[0]; + } + } + if(end.get_bound){ + var col = end.get_bound().collide_segment(mc,e); + if(col.length > 0){ + e = col[0]; + } + } + } + + function make_line(){ + return "M" + s.x + "," + s.y + "L" + e.x + "," + e.y ; + } + function make_curve(){ + return "M" + s.x + "," + s.y + "Q" + mc.x + "," + mc.y + " " + e.x + "," + e.y; + } + + update_start_end_pos(); + var edge = r.path(make_curve()).attr({'stroke':graph.style.edge, 'stroke-width':2, 'arrow-end':'block-wide-long', 'cursor':'pointer'}).insertBefore(graph.get_node_list()[0].get_fig()); + var labelpos = get_label_pos(edge); + var edge_label = r.text(labelpos.x, labelpos.y - elfs, label).attr({'fill':graph.style.edge_label, 'cursor':'pointer', 'font-size':elfs}); + + + //since we create an edge we need to recompute the edges that have the same start and end positions as this one + if(!tmp){ + var edges_start = graph.get_linked_edge_list(start); + var edges_end = graph.get_linked_edge_list(end); + var edges = edges_start.length < edges_end.length ? edges_start : edges_end; + for(var i = 0; i < edges.length; i ++){ + if(edges[i] != self){ + edges[i].update(); + } + } + } + + function label_enable(){ + if(!label_enabled){ + label_enabled = true; + edge_label.animate({'opacity':1},100,'linear'); + self.update(); + } + } + function label_disable(){ + if(label_enabled){ + label_enabled = false; + edge_label.animate({'opacity':0},100,'linear'); + } + } + //update the positions + function update(){ + update_start_end_pos(); + edge.attr({'path':make_curve()}); + if(label_enabled){ + var labelpos = get_label_pos(edge); + edge_label.attr({'x':labelpos.x, 'y':labelpos.y - 14}); + } + } + //TODO remove from graph + function remove(){ + edge.remove(); + edge_label.remove(); + } + + this.label_enable = label_enable; + this.label_disable = label_disable; + this.update = update; + this.remove = remove; + + } + // returns a new string with the same content as str, but with lines of maximum 'width' characters. + // lines are broken on words, or into words if a word is longer than 'width' + function wordwrap( str, width) { + // http://james.padolsey.com/javascript/wordwrap-for-javascript/ + width = width || 32; + var cut = true; + var brk = '\n'; + if (!str) { return str; } + var regex = '.{1,' +width+ '}(\\s|$)' + (cut ? '|.{' +width+ '}|.+$' : '|\\S+?(\\s|$)'); + return str.match( RegExp(regex, 'g') ).join( brk ); + } + + window.CuteGraph = Graph; + window.CuteNode = GraphNode; + window.CuteEdge = GraphEdge; + + window.CuteGraph.wordwrap = wordwrap; + + console.log("graph module fully loaded"); + +})(window); + +/* +window.onload = function(){ + var style = { "background" :'url("grid.png")', + "edge" :"#A0A0A0", + "edge_label" :"#555", + "text" :"#333", + "outline" :"#000", + "selected" :"#0097BE", + "gray" :"#DCDCDC", + "white" :"#FFF", + "node_size_x" : 110, + "node_size_y" : 80, + "edge_spacing" : 100 }; + + var r = new Raphael(document.getElementById("canvas_container"),'100%','100%'); + + var g = new CuteGraph(r,style); + + var n1 = new GraphNode(g,100,250,'Hello World','circle',colors.white); + var n2 = new GraphNode(g,400,250,'Hello Planet','rect',colors.white); + var n3 = new GraphNode(g,250,400,'Lonely Node','rect',colors.gray); + var e1 = new GraphEdge(g,'test',n1,n2); +}*/ + diff --git a/addons/web_diagram/static/src/js/raphael.js b/addons/web_diagram/static/src/js/raphael.js new file mode 100644 index 00000000000..bf6e741fdf2 --- /dev/null +++ b/addons/web_diagram/static/src/js/raphael.js @@ -0,0 +1,5462 @@ +// ┌─────────────────────────────────────────────────────────────────────┐ \\ +// │ Raphaël 2.0.1 - JavaScript Vector Library │ \\ +// ├─────────────────────────────────────────────────────────────────────┤ \\ +// │ Copyright (c) 2008-2011 Dmitry Baranovskiy (http://raphaeljs.com) │ \\ +// │ Copyright (c) 2008-2011 Sencha Labs (http://sencha.com) │ \\ +// │ Licensed under the MIT (http://raphaeljs.com/license.html) license. │ \\ +// └─────────────────────────────────────────────────────────────────────┘ \\ + +// ┌──────────────────────────────────────────────────────────────────────────────────────┐ \\ +// │ Eve 0.4.0 - JavaScript Events Library │ \\ +// ├──────────────────────────────────────────────────────────────────────────────────────┤ \\ +// │ Copyright (c) 2008-2011 Dmitry Baranovskiy (http://dmitry.baranovskiy.com/) │ \\ +// │ Licensed under the MIT (http://www.opensource.org/licenses/mit-license.php) license. │ \\ +// └──────────────────────────────────────────────────────────────────────────────────────┘ \\ + +(function (glob) { + var version = "0.4.0", + has = "hasOwnProperty", + separator = /[\.\/]/, + wildcard = "*", + fun = function () {}, + numsort = function (a, b) { + return a - b; + }, + current_event, + stop, + events = {n: {}}, + + eve = function (name, scope) { + var e = events, + oldstop = stop, + args = Array.prototype.slice.call(arguments, 2), + listeners = eve.listeners(name), + z = 0, + f = false, + l, + indexed = [], + queue = {}, + out = [], + errors = []; + current_event = name; + stop = 0; + for (var i = 0, ii = listeners.length; i < ii; i++) if ("zIndex" in listeners[i]) { + indexed.push(listeners[i].zIndex); + if (listeners[i].zIndex < 0) { + queue[listeners[i].zIndex] = listeners[i]; + } + } + indexed.sort(numsort); + while (indexed[z] < 0) { + l = queue[indexed[z++]]; + out.push(l.apply(scope, args)); + if (stop) { + stop = oldstop; + return out; + } + } + for (i = 0; i < ii; i++) { + l = listeners[i]; + if ("zIndex" in l) { + if (l.zIndex == indexed[z]) { + out.push(l.apply(scope, args)); + if (stop) { + stop = oldstop; + return out; + } + do { + z++; + l = queue[indexed[z]]; + l && out.push(l.apply(scope, args)); + if (stop) { + stop = oldstop; + return out; + } + } while (l) + } else { + queue[l.zIndex] = l; + } + } else { + out.push(l.apply(scope, args)); + if (stop) { + stop = oldstop; + return out; + } + } + } + stop = oldstop; + return out.length ? out : null; + }; + + eve.listeners = function (name) { + var names = name.split(separator), + e = events, + item, + items, + k, + i, + ii, + j, + jj, + nes, + es = [e], + out = []; + for (i = 0, ii = names.length; i < ii; i++) { + nes = []; + for (j = 0, jj = es.length; j < jj; j++) { + e = es[j].n; + items = [e[names[i]], e[wildcard]]; + k = 2; + while (k--) { + item = items[k]; + if (item) { + nes.push(item); + out = out.concat(item.f || []); + } + } + } + es = nes; + } + return out; + }; + + + eve.on = function (name, f) { + var names = name.split(separator), + e = events; + for (var i = 0, ii = names.length; i < ii; i++) { + e = e.n; + !e[names[i]] && (e[names[i]] = {n: {}}); + e = e[names[i]]; + } + e.f = e.f || []; + for (i = 0, ii = e.f.length; i < ii; i++) if (e.f[i] == f) { + return fun; + } + e.f.push(f); + return function (zIndex) { + if (+zIndex == +zIndex) { + f.zIndex = +zIndex; + } + }; + }; + + eve.stop = function () { + stop = 1; + }; + + eve.nt = function (subname) { + if (subname) { + return new RegExp("(?:\\.|\\/|^)" + subname + "(?:\\.|\\/|$)").test(current_event); + } + return current_event; + }; + + eve.unbind = function (name, f) { + var names = name.split(separator), + e, + key, + splice, + i, ii, j, jj, + cur = [events]; + for (i = 0, ii = names.length; i < ii; i++) { + for (j = 0; j < cur.length; j += splice.length - 2) { + splice = [j, 1]; + e = cur[j].n; + if (names[i] != wildcard) { + if (e[names[i]]) { + splice.push(e[names[i]]); + } + } else { + for (key in e) if (e[has](key)) { + splice.push(e[key]); + } + } + cur.splice.apply(cur, splice); + } + } + for (i = 0, ii = cur.length; i < ii; i++) { + e = cur[i]; + while (e.n) { + if (f) { + if (e.f) { + for (j = 0, jj = e.f.length; j < jj; j++) if (e.f[j] == f) { + e.f.splice(j, 1); + break; + } + !e.f.length && delete e.f; + } + for (key in e.n) if (e.n[has](key) && e.n[key].f) { + var funcs = e.n[key].f; + for (j = 0, jj = funcs.length; j < jj; j++) if (funcs[j] == f) { + funcs.splice(j, 1); + break; + } + !funcs.length && delete e.n[key].f; + } + } else { + delete e.f; + for (key in e.n) if (e.n[has](key) && e.n[key].f) { + delete e.n[key].f; + } + } + e = e.n; + } + } + }; + + eve.once = function (name, f) { + var f2 = function () { + f.apply(this, arguments); + eve.unbind(name, f2); + }; + return eve.on(name, f2); + }; + + eve.version = version; + eve.toString = function () { + return "You are running Eve " + version; + }; + (typeof module != "undefined" && module.exports) ? (module.exports = eve) : (glob.eve = eve); +})(this); + +// ┌─────────────────────────────────────────────────────────────────────┐ \\ +// │ "Raphaël 2.0.1" - JavaScript Vector Library │ \\ +// ├─────────────────────────────────────────────────────────────────────┤ \\ +// │ Copyright (c) 2008-2011 Dmitry Baranovskiy (http://raphaeljs.com) │ \\ +// │ Copyright (c) 2008-2011 Sencha Labs (http://sencha.com) │ \\ +// │ Licensed under the MIT (http://raphaeljs.com/license.html) license. │ \\ +// └─────────────────────────────────────────────────────────────────────┘ \\ +(function () { + + function R(first) { + if (R.is(first, "function")) { + return loaded ? first() : eve.on("DOMload", first); + } else if (R.is(first, array)) { + return R._engine.create[apply](R, first.splice(0, 3 + R.is(first[0], nu))).add(first); + } else { + var args = Array.prototype.slice.call(arguments, 0); + if (R.is(args[args.length - 1], "function")) { + var f = args.pop(); + return loaded ? f.call(R._engine.create[apply](R, args)) : eve.on("DOMload", function () { + f.call(R._engine.create[apply](R, args)); + }); + } else { + return R._engine.create[apply](R, arguments); + } + } + } + R.version = "2.0.1"; + R.eve = eve; + var loaded, + separator = /[, ]+/, + elements = {circle: 1, rect: 1, path: 1, ellipse: 1, text: 1, image: 1}, + formatrg = /\{(\d+)\}/g, + proto = "prototype", + has = "hasOwnProperty", + g = { + doc: document, + win: window + }, + oldRaphael = { + was: Object.prototype[has].call(g.win, "Raphael"), + is: g.win.Raphael + }, + Paper = function () { + + + this.ca = this.customAttributes = {}; + }, + paperproto, + appendChild = "appendChild", + apply = "apply", + concat = "concat", + supportsTouch = "createTouch" in g.doc, + E = "", + S = " ", + Str = String, + split = "split", + events = "click dblclick mousedown mousemove mouseout mouseover mouseup touchstart touchmove touchend touchcancel"[split](S), + touchMap = { + mousedown: "touchstart", + mousemove: "touchmove", + mouseup: "touchend" + }, + lowerCase = Str.prototype.toLowerCase, + math = Math, + mmax = math.max, + mmin = math.min, + abs = math.abs, + pow = math.pow, + PI = math.PI, + nu = "number", + string = "string", + array = "array", + toString = "toString", + fillString = "fill", + objectToString = Object.prototype.toString, + paper = {}, + push = "push", + ISURL = R._ISURL = /^url\(['"]?([^\)]+?)['"]?\)$/i, + colourRegExp = /^\s*((#[a-f\d]{6})|(#[a-f\d]{3})|rgba?\(\s*([\d\.]+%?\s*,\s*[\d\.]+%?\s*,\s*[\d\.]+%?(?:\s*,\s*[\d\.]+%?)?)\s*\)|hsba?\(\s*([\d\.]+(?:deg|\xb0|%)?\s*,\s*[\d\.]+%?\s*,\s*[\d\.]+(?:%?\s*,\s*[\d\.]+)?)%?\s*\)|hsla?\(\s*([\d\.]+(?:deg|\xb0|%)?\s*,\s*[\d\.]+%?\s*,\s*[\d\.]+(?:%?\s*,\s*[\d\.]+)?)%?\s*\))\s*$/i, + isnan = {"NaN": 1, "Infinity": 1, "-Infinity": 1}, + bezierrg = /^(?:cubic-)?bezier\(([^,]+),([^,]+),([^,]+),([^\)]+)\)/, + round = math.round, + setAttribute = "setAttribute", + toFloat = parseFloat, + toInt = parseInt, + upperCase = Str.prototype.toUpperCase, + availableAttrs = R._availableAttrs = { + "arrow-end": "none", + "arrow-start": "none", + blur: 0, + "clip-rect": "0 0 1e9 1e9", + cursor: "default", + 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/", + "letter-spacing": 0, + opacity: 1, + path: "M0,0", + r: 0, + rx: 0, + ry: 0, + 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", + transform: "", + width: 0, + x: 0, + y: 0 + }, + availableAnimAttrs = R._availableAnimAttrs = { + blur: nu, + "clip-rect": "csv", + cx: nu, + cy: nu, + fill: "colour", + "fill-opacity": nu, + "font-size": nu, + height: nu, + opacity: nu, + path: "path", + r: nu, + rx: nu, + ry: nu, + stroke: "colour", + "stroke-opacity": nu, + "stroke-width": nu, + transform: "transform", + width: nu, + x: nu, + y: nu + }, + commaSpaces = /\s*,\s*/, + hsrg = {hs: 1, rg: 1}, + p2s = /,?([achlmqrstvxz]),?/gi, + pathCommand = /([achlmrqstvz])[\s,]*((-?\d*\.?\d*(?:e[\-+]?\d+)?\s*,?\s*)+)/ig, + tCommand = /([rstm])[\s,]*((-?\d*\.?\d*(?:e[\-+]?\d+)?\s*,?\s*)+)/ig, + pathValues = /(-?\d*\.?\d*(?:e[\-+]?\d+)?)\s*,?\s*/ig, + radial_gradient = R._radial_gradient = /^r(?:\(([^,]+?)\s*,\s*([^\)]+?)\))?/, + eldata = {}, + sortByKey = function (a, b) { + return a.key - b.key; + }, + sortByNumber = function (a, b) { + return toFloat(a) - toFloat(b); + }, + fun = function () {}, + pipe = function (x) { + return x; + }, + rectPath = R._rectPath = function (x, y, w, h, r) { + if (r) { + return [["M", x + r, y], ["l", w - r * 2, 0], ["a", r, r, 0, 0, 1, r, r], ["l", 0, h - r * 2], ["a", r, r, 0, 0, 1, -r, r], ["l", r * 2 - w, 0], ["a", r, r, 0, 0, 1, -r, -r], ["l", 0, r * 2 - h], ["a", r, r, 0, 0, 1, r, -r], ["z"]]; + } + return [["M", x, y], ["l", w, 0], ["l", 0, h], ["l", -w, 0], ["z"]]; + }, + ellipsePath = function (x, y, rx, ry) { + if (ry == null) { + ry = rx; + } + return [["M", x, y], ["m", 0, -ry], ["a", rx, ry, 0, 1, 1, 0, 2 * ry], ["a", rx, ry, 0, 1, 1, 0, -2 * ry], ["z"]]; + }, + getPath = R._getPath = { + path: function (el) { + return el.attr("path"); + }, + circle: function (el) { + var a = el.attrs; + return ellipsePath(a.cx, a.cy, a.r); + }, + ellipse: function (el) { + var a = el.attrs; + return ellipsePath(a.cx, a.cy, a.rx, a.ry); + }, + rect: function (el) { + var a = el.attrs; + return rectPath(a.x, a.y, a.width, a.height, a.r); + }, + image: function (el) { + var a = el.attrs; + return rectPath(a.x, a.y, a.width, a.height); + }, + text: function (el) { + var bbox = el._getBBox(); + return rectPath(bbox.x, bbox.y, bbox.width, bbox.height); + } + }, + mapPath = R.mapPath = function (path, matrix) { + if (!matrix) { + return path; + } + var x, y, i, j, ii, jj, pathi; + path = path2curve(path); + for (i = 0, ii = path.length; i < ii; i++) { + pathi = path[i]; + for (j = 1, jj = pathi.length; j < jj; j += 2) { + x = matrix.x(pathi[j], pathi[j + 1]); + y = matrix.y(pathi[j], pathi[j + 1]); + pathi[j] = x; + pathi[j + 1] = y; + } + } + return path; + }; + + R._g = g; + + R.type = (g.win.SVGAngle || g.doc.implementation.hasFeature("http://www.w3.org/TR/SVG11/feature#BasicStructure", "1.1") ? "SVG" : "VML"); + if (R.type == "VML") { + var d = g.doc.createElement("div"), + b; + d.innerHTML = ''; + b = d.firstChild; + b.style.behavior = "url(#default#VML)"; + if (!(b && typeof b.adj == "object")) { + return (R.type = E); + } + d = null; + } + + + R.svg = !(R.vml = R.type == "VML"); + R._Paper = Paper; + + R.fn = paperproto = Paper.prototype = R.prototype; + R._id = 0; + R._oid = 0; + + R.is = function (o, type) { + type = lowerCase.call(type); + if (type == "finite") { + return !isnan[has](+o); + } + if (type == "array") { + return o instanceof Array; + } + return (type == "null" && o === null) || + (type == typeof o && o !== null) || + (type == "object" && o === Object(o)) || + (type == "array" && Array.isArray && Array.isArray(o)) || + objectToString.call(o).slice(8, -1).toLowerCase() == type; + }; + + R.angle = function (x1, y1, x2, y2, x3, y3) { + if (x3 == null) { + var x = x1 - x2, + y = y1 - y2; + if (!x && !y) { + return 0; + } + return (180 + math.atan2(-y, -x) * 180 / PI + 360) % 360; + } else { + return R.angle(x1, y1, x3, y3) - R.angle(x2, y2, x3, y3); + } + }; + + R.rad = function (deg) { + return deg % 360 * PI / 180; + }; + + R.deg = function (rad) { + return rad * 180 / PI % 360; + }; + + R.snapTo = function (values, value, tolerance) { + tolerance = R.is(tolerance, "finite") ? tolerance : 10; + if (R.is(values, array)) { + var i = values.length; + while (i--) if (abs(values[i] - value) <= tolerance) { + return values[i]; + } + } else { + values = +values; + var rem = value % values; + if (rem < tolerance) { + return value - rem; + } + if (rem > values - tolerance) { + return value - rem + values; + } + } + return value; + }; + + + var createUUID = R.createUUID = (function (uuidRegEx, uuidReplacer) { + return function () { + return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(uuidRegEx, uuidReplacer).toUpperCase(); + }; + })(/[xy]/g, function (c) { + var r = math.random() * 16 | 0, + v = c == "x" ? r : (r & 3 | 8); + return v.toString(16); + }); + + + R.setWindow = function (newwin) { + eve("setWindow", R, g.win, newwin); + g.win = newwin; + g.doc = g.win.document; + if (R._engine.initWin) { + R._engine.initWin(g.win); + } + }; + var toHex = function (color) { + if (R.vml) { + // http://dean.edwards.name/weblog/2009/10/convert-any-colour-value-to-hex-in-msie/ + var trim = /^\s+|\s+$/g; + var bod; + try { + var docum = new ActiveXObject("htmlfile"); + docum.write(""); + docum.close(); + bod = docum.body; + } catch(e) { + bod = createPopup().document.body; + } + var range = bod.createTextRange(); + toHex = cacher(function (color) { + try { + bod.style.color = Str(color).replace(trim, E); + var value = range.queryCommandValue("ForeColor"); + value = ((value & 255) << 16) | (value & 65280) | ((value & 16711680) >>> 16); + return "#" + ("000000" + value.toString(16)).slice(-6); + } catch(e) { + return "none"; + } + }); + } else { + var i = g.doc.createElement("i"); + i.title = "Rapha\xebl Colour Picker"; + i.style.display = "none"; + g.doc.body.appendChild(i); + toHex = cacher(function (color) { + i.style.color = color; + return g.doc.defaultView.getComputedStyle(i, E).getPropertyValue("color"); + }); + } + return toHex(color); + }, + hsbtoString = function () { + return "hsb(" + [this.h, this.s, this.b] + ")"; + }, + hsltoString = function () { + return "hsl(" + [this.h, this.s, this.l] + ")"; + }, + rgbtoString = function () { + return this.hex; + }, + prepareRGB = function (r, g, b) { + if (g == null && R.is(r, "object") && "r" in r && "g" in r && "b" in r) { + b = r.b; + g = r.g; + r = r.r; + } + if (g == null && R.is(r, string)) { + var clr = R.getRGB(r); + r = clr.r; + g = clr.g; + b = clr.b; + } + if (r > 1 || g > 1 || b > 1) { + r /= 255; + g /= 255; + b /= 255; + } + + return [r, g, b]; + }, + packageRGB = function (r, g, b, o) { + r *= 255; + g *= 255; + b *= 255; + var rgb = { + r: r, + g: g, + b: b, + hex: R.rgb(r, g, b), + toString: rgbtoString + }; + R.is(o, "finite") && (rgb.opacity = o); + return rgb; + }; + + + R.color = function (clr) { + var rgb; + if (R.is(clr, "object") && "h" in clr && "s" in clr && "b" in clr) { + rgb = R.hsb2rgb(clr); + clr.r = rgb.r; + clr.g = rgb.g; + clr.b = rgb.b; + clr.hex = rgb.hex; + } else if (R.is(clr, "object") && "h" in clr && "s" in clr && "l" in clr) { + rgb = R.hsl2rgb(clr); + clr.r = rgb.r; + clr.g = rgb.g; + clr.b = rgb.b; + clr.hex = rgb.hex; + } else { + if (R.is(clr, "string")) { + clr = R.getRGB(clr); + } + if (R.is(clr, "object") && "r" in clr && "g" in clr && "b" in clr) { + rgb = R.rgb2hsl(clr); + clr.h = rgb.h; + clr.s = rgb.s; + clr.l = rgb.l; + rgb = R.rgb2hsb(clr); + clr.v = rgb.b; + } else { + clr = {hex: "none"}; + clr.r = clr.g = clr.b = clr.h = clr.s = clr.v = clr.l = -1; + } + } + clr.toString = rgbtoString; + return clr; + }; + + R.hsb2rgb = function (h, s, v, o) { + if (this.is(h, "object") && "h" in h && "s" in h && "b" in h) { + v = h.b; + s = h.s; + h = h.h; + o = h.o; + } + h *= 360; + var R, G, B, X, C; + h = (h % 360) / 60; + C = v * s; + X = C * (1 - abs(h % 2 - 1)); + R = G = B = v - C; + + h = ~~h; + R += [C, X, 0, 0, X, C][h]; + G += [X, C, C, X, 0, 0][h]; + B += [0, 0, X, C, C, X][h]; + return packageRGB(R, G, B, o); + }; + + R.hsl2rgb = function (h, s, l, o) { + if (this.is(h, "object") && "h" in h && "s" in h && "l" in h) { + l = h.l; + s = h.s; + h = h.h; + } + if (h > 1 || s > 1 || l > 1) { + h /= 360; + s /= 100; + l /= 100; + } + h *= 360; + var R, G, B, X, C; + h = (h % 360) / 60; + C = 2 * s * (l < .5 ? l : 1 - l); + X = C * (1 - abs(h % 2 - 1)); + R = G = B = l - C / 2; + + h = ~~h; + R += [C, X, 0, 0, X, C][h]; + G += [X, C, C, X, 0, 0][h]; + B += [0, 0, X, C, C, X][h]; + return packageRGB(R, G, B, o); + }; + + R.rgb2hsb = function (r, g, b) { + b = prepareRGB(r, g, b); + r = b[0]; + g = b[1]; + b = b[2]; + + var H, S, V, C; + V = mmax(r, g, b); + C = V - mmin(r, g, b); + H = (C == 0 ? null : + V == r ? (g - b) / C : + V == g ? (b - r) / C + 2 : + (r - g) / C + 4 + ); + H = ((H + 360) % 6) * 60 / 360; + S = C == 0 ? 0 : C / V; + return {h: H, s: S, b: V, toString: hsbtoString}; + }; + + R.rgb2hsl = function (r, g, b) { + b = prepareRGB(r, g, b); + r = b[0]; + g = b[1]; + b = b[2]; + + var H, S, L, M, m, C; + M = mmax(r, g, b); + m = mmin(r, g, b); + C = M - m; + H = (C == 0 ? null : + M == r ? (g - b) / C : + M == g ? (b - r) / C + 2 : + (r - g) / C + 4); + H = ((H + 360) % 6) * 60 / 360; + L = (M + m) / 2; + S = (C == 0 ? 0 : + L < .5 ? C / (2 * L) : + C / (2 - 2 * L)); + return {h: H, s: S, l: L, toString: hsltoString}; + }; + R._path2string = function () { + return this.join(",").replace(p2s, "$1"); + }; + function repush(array, item) { + for (var i = 0, ii = array.length; i < ii; i++) if (array[i] === item) { + return array.push(array.splice(i, 1)[0]); + } + } + function cacher(f, scope, postprocessor) { + function newf() { + var arg = Array.prototype.slice.call(arguments, 0), + args = arg.join("\u2400"), + cache = newf.cache = newf.cache || {}, + count = newf.count = newf.count || []; + if (cache[has](args)) { + repush(count, args); + return postprocessor ? postprocessor(cache[args]) : cache[args]; + } + count.length >= 1e3 && delete cache[count.shift()]; + count.push(args); + cache[args] = f[apply](scope, arg); + return postprocessor ? postprocessor(cache[args]) : cache[args]; + } + return newf; + } + + var preload = R._preload = function (src, f) { + var img = g.doc.createElement("img"); + img.style.cssText = "position:absolute;left:-9999em;top:-9999em"; + img.onload = function () { + f.call(this); + this.onload = null; + g.doc.body.removeChild(this); + }; + img.onerror = function () { + g.doc.body.removeChild(this); + }; + g.doc.body.appendChild(img); + img.src = src; + }; + + function clrToString() { + return this.hex; + } + + + R.getRGB = cacher(function (colour) { + if (!colour || !!((colour = Str(colour)).indexOf("-") + 1)) { + return {r: -1, g: -1, b: -1, hex: "none", error: 1, toString: clrToString}; + } + if (colour == "none") { + return {r: -1, g: -1, b: -1, hex: "none", toString: clrToString}; + } + !(hsrg[has](colour.toLowerCase().substring(0, 2)) || colour.charAt() == "#") && (colour = toHex(colour)); + var res, + red, + green, + blue, + opacity, + t, + values, + rgb = colour.match(colourRegExp); + if (rgb) { + if (rgb[2]) { + blue = toInt(rgb[2].substring(5), 16); + green = toInt(rgb[2].substring(3, 5), 16); + red = toInt(rgb[2].substring(1, 3), 16); + } + if (rgb[3]) { + blue = toInt((t = rgb[3].charAt(3)) + t, 16); + green = toInt((t = rgb[3].charAt(2)) + t, 16); + red = toInt((t = rgb[3].charAt(1)) + t, 16); + } + if (rgb[4]) { + values = rgb[4][split](commaSpaces); + red = toFloat(values[0]); + values[0].slice(-1) == "%" && (red *= 2.55); + green = toFloat(values[1]); + values[1].slice(-1) == "%" && (green *= 2.55); + blue = toFloat(values[2]); + values[2].slice(-1) == "%" && (blue *= 2.55); + rgb[1].toLowerCase().slice(0, 4) == "rgba" && (opacity = toFloat(values[3])); + values[3] && values[3].slice(-1) == "%" && (opacity /= 100); + } + if (rgb[5]) { + values = rgb[5][split](commaSpaces); + red = toFloat(values[0]); + values[0].slice(-1) == "%" && (red *= 2.55); + green = toFloat(values[1]); + values[1].slice(-1) == "%" && (green *= 2.55); + blue = toFloat(values[2]); + values[2].slice(-1) == "%" && (blue *= 2.55); + (values[0].slice(-3) == "deg" || values[0].slice(-1) == "\xb0") && (red /= 360); + rgb[1].toLowerCase().slice(0, 4) == "hsba" && (opacity = toFloat(values[3])); + values[3] && values[3].slice(-1) == "%" && (opacity /= 100); + return R.hsb2rgb(red, green, blue, opacity); + } + if (rgb[6]) { + values = rgb[6][split](commaSpaces); + red = toFloat(values[0]); + values[0].slice(-1) == "%" && (red *= 2.55); + green = toFloat(values[1]); + values[1].slice(-1) == "%" && (green *= 2.55); + blue = toFloat(values[2]); + values[2].slice(-1) == "%" && (blue *= 2.55); + (values[0].slice(-3) == "deg" || values[0].slice(-1) == "\xb0") && (red /= 360); + rgb[1].toLowerCase().slice(0, 4) == "hsla" && (opacity = toFloat(values[3])); + values[3] && values[3].slice(-1) == "%" && (opacity /= 100); + return R.hsl2rgb(red, green, blue, opacity); + } + rgb = {r: red, g: green, b: blue, toString: clrToString}; + rgb.hex = "#" + (16777216 | blue | (green << 8) | (red << 16)).toString(16).slice(1); + R.is(opacity, "finite") && (rgb.opacity = opacity); + return rgb; + } + return {r: -1, g: -1, b: -1, hex: "none", error: 1, toString: clrToString}; + }, R); + + R.hsb = cacher(function (h, s, b) { + return R.hsb2rgb(h, s, b).hex; + }); + + R.hsl = cacher(function (h, s, l) { + return R.hsl2rgb(h, s, l).hex; + }); + + R.rgb = cacher(function (r, g, b) { + return "#" + (16777216 | b | (g << 8) | (r << 16)).toString(16).slice(1); + }); + + R.getColor = function (value) { + var start = this.getColor.start = this.getColor.start || {h: 0, s: 1, b: value || .75}, + rgb = this.hsb2rgb(start.h, start.s, start.b); + start.h += .075; + if (start.h > 1) { + start.h = 0; + start.s -= .2; + start.s <= 0 && (this.getColor.start = {h: 0, s: 1, b: start.b}); + } + return rgb.hex; + }; + + R.getColor.reset = function () { + delete this.start; + }; + + // http://schepers.cc/getting-to-the-point + function catmullRom2bezier(crp) { + var d = []; + for (var i = 0, iLen = crp.length; iLen - 2 > i; i += 2) { + var p = [{x: +crp[i], y: +crp[i + 1]}, + {x: +crp[i], y: +crp[i + 1]}, + {x: +crp[i + 2], y: +crp[i + 3]}, + {x: +crp[i + 4], y: +crp[i + 5]}]; + if (iLen - 4 == i) { + p[0] = {x: +crp[i - 2], y: +crp[i - 1]}; + p[3] = p[2]; + } else if (i) { + p[0] = {x: +crp[i - 2], y: +crp[i - 1]}; + } + d.push(["C", + (-p[0].x + 6 * p[1].x + p[2].x) / 6, + (-p[0].y + 6 * p[1].y + p[2].y) / 6, + (p[1].x + 6 * p[2].x - p[3].x) / 6, + (p[1].y + 6*p[2].y - p[3].y) / 6, + p[2].x, + p[2].y + ]); + } + + return d; + } + + R.parsePathString = cacher(function (pathString) { + if (!pathString) { + return null; + } + var paramCounts = {a: 7, c: 6, h: 1, l: 2, m: 2, r: 4, q: 4, s: 4, t: 2, v: 1, z: 0}, + data = []; + if (R.is(pathString, array) && R.is(pathString[0], array)) { // rough assumption + data = pathClone(pathString); + } + if (!data.length) { + Str(pathString).replace(pathCommand, function (a, b, c) { + var params = [], + name = b.toLowerCase(); + c.replace(pathValues, function (a, b) { + b && params.push(+b); + }); + if (name == "m" && params.length > 2) { + data.push([b][concat](params.splice(0, 2))); + name = "l"; + b = b == "m" ? "l" : "L"; + } + if (name == "r") { + data.push([b][concat](params)); + } else while (params.length >= paramCounts[name]) { + data.push([b][concat](params.splice(0, paramCounts[name]))); + if (!paramCounts[name]) { + break; + } + } + }); + } + data.toString = R._path2string; + return data; + }); + + R.parseTransformString = cacher(function (TString) { + if (!TString) { + return null; + } + var paramCounts = {r: 3, s: 4, t: 2, m: 6}, + data = []; + if (R.is(TString, array) && R.is(TString[0], array)) { // rough assumption + data = pathClone(TString); + } + if (!data.length) { + Str(TString).replace(tCommand, function (a, b, c) { + var params = [], + name = lowerCase.call(b); + c.replace(pathValues, function (a, b) { + b && params.push(+b); + }); + data.push([b][concat](params)); + }); + } + data.toString = R._path2string; + return data; + }); + + R.findDotsAtSegment = function (p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y, t) { + var t1 = 1 - t, + t13 = pow(t1, 3), + t12 = pow(t1, 2), + t2 = t * t, + t3 = t2 * t, + x = t13 * p1x + t12 * 3 * t * c1x + t1 * 3 * t * t * c2x + t3 * p2x, + y = t13 * p1y + t12 * 3 * t * c1y + t1 * 3 * t * t * c2y + t3 * p2y, + mx = p1x + 2 * t * (c1x - p1x) + t2 * (c2x - 2 * c1x + p1x), + my = p1y + 2 * t * (c1y - p1y) + t2 * (c2y - 2 * c1y + p1y), + nx = c1x + 2 * t * (c2x - c1x) + t2 * (p2x - 2 * c2x + c1x), + ny = c1y + 2 * t * (c2y - c1y) + t2 * (p2y - 2 * c2y + c1y), + ax = t1 * p1x + t * c1x, + ay = t1 * p1y + t * c1y, + cx = t1 * c2x + t * p2x, + cy = t1 * c2y + t * p2y, + alpha = (90 - math.atan2(mx - nx, my - ny) * 180 / PI); + (mx > nx || my < ny) && (alpha += 180); + 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}, + alpha: alpha + }; + }; + R._removedFactory = function (methodname) { + return function () { + throw new Error("Rapha\xebl: you are calling to method \u201c" + methodname + "\u201d of removed object"); + }; + }; + var pathDimensions = cacher(function (path) { + if (!path) { + return {x: 0, y: 0, width: 0, height: 0}; + } + path = path2curve(path); + var x = 0, + y = 0, + X = [], + Y = [], + p; + for (var i = 0, ii = path.length; i < ii; i++) { + p = path[i]; + if (p[0] == "M") { + x = p[1]; + y = p[2]; + X.push(x); + Y.push(y); + } else { + var dim = curveDim(x, y, p[1], p[2], p[3], p[4], p[5], p[6]); + X = X[concat](dim.min.x, dim.max.x); + Y = Y[concat](dim.min.y, dim.max.y); + x = p[5]; + y = p[6]; + } + } + var xmin = mmin[apply](0, X), + ymin = mmin[apply](0, Y); + return { + x: xmin, + y: ymin, + width: mmax[apply](0, X) - xmin, + height: mmax[apply](0, Y) - ymin + }; + }, null, function (o) { + return { + x: o.x, + y: o.y, + width: o.width, + height: o.height + }; + }), + pathClone = function (pathArray) { + var res = []; + if (!R.is(pathArray, array) || !R.is(pathArray && pathArray[0], array)) { // rough assumption + pathArray = R.parsePathString(pathArray); + } + for (var i = 0, ii = pathArray.length; i < ii; i++) { + res[i] = []; + for (var j = 0, jj = pathArray[i].length; j < jj; j++) { + res[i][j] = pathArray[i][j]; + } + } + res.toString = R._path2string; + return res; + }, + pathToRelative = R._pathToRelative = cacher(function (pathArray) { + if (!R.is(pathArray, array) || !R.is(pathArray && pathArray[0], array)) { // rough assumption + pathArray = R.parsePathString(pathArray); + } + var res = [], + x = 0, + y = 0, + mx = 0, + my = 0, + start = 0; + if (pathArray[0][0] == "M") { + x = pathArray[0][1]; + y = pathArray[0][2]; + mx = x; + my = y; + start++; + res.push(["M", x, y]); + } + for (var i = start, ii = pathArray.length; i < ii; i++) { + var r = res[i] = [], + pa = pathArray[i]; + if (pa[0] != lowerCase.call(pa[0])) { + r[0] = lowerCase.call(pa[0]); + switch (r[0]) { + case "a": + r[1] = pa[1]; + r[2] = pa[2]; + r[3] = pa[3]; + r[4] = pa[4]; + r[5] = pa[5]; + r[6] = +(pa[6] - x).toFixed(3); + r[7] = +(pa[7] - y).toFixed(3); + break; + case "v": + r[1] = +(pa[1] - y).toFixed(3); + break; + case "m": + mx = pa[1]; + my = pa[2]; + default: + for (var j = 1, jj = pa.length; j < jj; j++) { + r[j] = +(pa[j] - ((j % 2) ? x : y)).toFixed(3); + } + } + } else { + r = res[i] = []; + if (pa[0] == "m") { + mx = pa[1] + x; + my = pa[2] + y; + } + for (var k = 0, kk = pa.length; k < kk; k++) { + res[i][k] = pa[k]; + } + } + var len = res[i].length; + switch (res[i][0]) { + case "z": + x = mx; + y = my; + break; + case "h": + x += +res[i][len - 1]; + break; + case "v": + y += +res[i][len - 1]; + break; + default: + x += +res[i][len - 2]; + y += +res[i][len - 1]; + } + } + res.toString = R._path2string; + return res; + }, 0, pathClone), + pathToAbsolute = R._pathToAbsolute = cacher(function (pathArray) { + if (!R.is(pathArray, array) || !R.is(pathArray && pathArray[0], array)) { // rough assumption + pathArray = R.parsePathString(pathArray); + } + if (!pathArray || !pathArray.length) { + return [["M", 0, 0]]; + } + var res = [], + x = 0, + y = 0, + mx = 0, + my = 0, + start = 0; + if (pathArray[0][0] == "M") { + x = +pathArray[0][1]; + y = +pathArray[0][2]; + mx = x; + my = y; + start++; + res[0] = ["M", x, y]; + } + for (var r, pa, i = start, ii = pathArray.length; i < ii; i++) { + res.push(r = []); + pa = pathArray[i]; + if (pa[0] != upperCase.call(pa[0])) { + r[0] = upperCase.call(pa[0]); + switch (r[0]) { + case "A": + r[1] = pa[1]; + r[2] = pa[2]; + r[3] = pa[3]; + r[4] = pa[4]; + r[5] = pa[5]; + r[6] = +(pa[6] + x); + r[7] = +(pa[7] + y); + break; + case "V": + r[1] = +pa[1] + y; + break; + case "H": + r[1] = +pa[1] + x; + break; + case "R": + var dots = [x, y][concat](pa.slice(1)); + for (var j = 2, jj = dots.length; j < jj; j++) { + dots[j] = +dots[j] + x; + dots[++j] = +dots[j] + y; + } + res.pop(); + res = res[concat](catmullRom2bezier(dots)); + break; + case "M": + mx = +pa[1] + x; + my = +pa[2] + y; + default: + for (j = 1, jj = pa.length; j < jj; j++) { + r[j] = +pa[j] + ((j % 2) ? x : y); + } + } + } else if (pa[0] == "R") { + dots = [x, y][concat](pa.slice(1)); + res.pop(); + res = res[concat](catmullRom2bezier(dots)); + r = ["R"][concat](pa.slice(-2)); + } else { + for (var k = 0, kk = pa.length; k < kk; k++) { + r[k] = pa[k]; + } + } + switch (r[0]) { + case "Z": + x = mx; + y = my; + break; + case "H": + x = r[1]; + break; + case "V": + y = r[1]; + break; + case "M": + mx = r[r.length - 2]; + my = r[r.length - 1]; + default: + x = r[r.length - 2]; + y = r[r.length - 1]; + } + } + res.toString = R._path2string; + return res; + }, null, pathClone), + l2c = function (x1, y1, x2, y2) { + return [x1, y1, x2, y2, x2, y2]; + }, + q2c = function (x1, y1, ax, ay, x2, y2) { + var _13 = 1 / 3, + _23 = 2 / 3; + return [ + _13 * x1 + _23 * ax, + _13 * y1 + _23 * ay, + _13 * x2 + _23 * ax, + _13 * y2 + _23 * ay, + x2, + y2 + ]; + }, + a2c = function (x1, y1, rx, ry, angle, large_arc_flag, sweep_flag, x2, y2, recursive) { + // for more information of where this math came from visit: + // http://www.w3.org/TR/SVG11/implnote.html#ArcImplementationNotes + var _120 = PI * 120 / 180, + rad = PI / 180 * (+angle || 0), + res = [], + xy, + rotate = cacher(function (x, y, rad) { + var X = x * math.cos(rad) - y * math.sin(rad), + Y = x * math.sin(rad) + y * math.cos(rad); + return {x: X, y: Y}; + }); + if (!recursive) { + xy = rotate(x1, y1, -rad); + x1 = xy.x; + y1 = xy.y; + xy = rotate(x2, y2, -rad); + x2 = xy.x; + y2 = xy.y; + var cos = math.cos(PI / 180 * angle), + sin = math.sin(PI / 180 * angle), + x = (x1 - x2) / 2, + y = (y1 - y2) / 2; + var h = (x * x) / (rx * rx) + (y * y) / (ry * ry); + if (h > 1) { + h = math.sqrt(h); + rx = h * rx; + ry = h * ry; + } + var rx2 = rx * rx, + ry2 = ry * ry, + k = (large_arc_flag == sweep_flag ? -1 : 1) * + math.sqrt(abs((rx2 * ry2 - rx2 * y * y - ry2 * x * x) / (rx2 * y * y + ry2 * x * x))), + cx = k * rx * y / ry + (x1 + x2) / 2, + cy = k * -ry * x / rx + (y1 + y2) / 2, + f1 = math.asin(((y1 - cy) / ry).toFixed(9)), + f2 = math.asin(((y2 - cy) / ry).toFixed(9)); + + f1 = x1 < cx ? PI - f1 : f1; + f2 = x2 < cx ? PI - f2 : f2; + f1 < 0 && (f1 = PI * 2 + f1); + f2 < 0 && (f2 = PI * 2 + f2); + if (sweep_flag && f1 > f2) { + f1 = f1 - PI * 2; + } + if (!sweep_flag && f2 > f1) { + f2 = f2 - PI * 2; + } + } else { + f1 = recursive[0]; + f2 = recursive[1]; + cx = recursive[2]; + cy = recursive[3]; + } + var df = f2 - f1; + if (abs(df) > _120) { + var f2old = f2, + x2old = x2, + y2old = y2; + f2 = f1 + _120 * (sweep_flag && f2 > f1 ? 1 : -1); + x2 = cx + rx * math.cos(f2); + y2 = cy + ry * math.sin(f2); + res = a2c(x2, y2, rx, ry, angle, 0, sweep_flag, x2old, y2old, [f2, f2old, cx, cy]); + } + df = f2 - f1; + var c1 = math.cos(f1), + s1 = math.sin(f1), + c2 = math.cos(f2), + s2 = math.sin(f2), + t = math.tan(df / 4), + hx = 4 / 3 * rx * t, + hy = 4 / 3 * ry * t, + m1 = [x1, y1], + m2 = [x1 + hx * s1, y1 - hy * c1], + m3 = [x2 + hx * s2, y2 - hy * c2], + m4 = [x2, y2]; + m2[0] = 2 * m1[0] - m2[0]; + m2[1] = 2 * m1[1] - m2[1]; + if (recursive) { + return [m2, m3, m4][concat](res); + } else { + res = [m2, m3, m4][concat](res).join()[split](","); + var newres = []; + for (var i = 0, ii = res.length; i < ii; i++) { + newres[i] = i % 2 ? rotate(res[i - 1], res[i], rad).y : rotate(res[i], res[i + 1], rad).x; + } + return newres; + } + }, + findDotAtSegment = function (p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y, t) { + var t1 = 1 - t; + return { + x: pow(t1, 3) * p1x + pow(t1, 2) * 3 * t * c1x + t1 * 3 * t * t * c2x + pow(t, 3) * p2x, + y: pow(t1, 3) * p1y + pow(t1, 2) * 3 * t * c1y + t1 * 3 * t * t * c2y + pow(t, 3) * p2y + }; + }, + curveDim = cacher(function (p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y) { + var a = (c2x - 2 * c1x + p1x) - (p2x - 2 * c2x + c1x), + b = 2 * (c1x - p1x) - 2 * (c2x - c1x), + c = p1x - c1x, + t1 = (-b + math.sqrt(b * b - 4 * a * c)) / 2 / a, + t2 = (-b - math.sqrt(b * b - 4 * a * c)) / 2 / a, + y = [p1y, p2y], + x = [p1x, p2x], + dot; + abs(t1) > "1e12" && (t1 = .5); + abs(t2) > "1e12" && (t2 = .5); + if (t1 > 0 && t1 < 1) { + dot = findDotAtSegment(p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y, t1); + x.push(dot.x); + y.push(dot.y); + } + if (t2 > 0 && t2 < 1) { + dot = findDotAtSegment(p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y, t2); + x.push(dot.x); + y.push(dot.y); + } + a = (c2y - 2 * c1y + p1y) - (p2y - 2 * c2y + c1y); + b = 2 * (c1y - p1y) - 2 * (c2y - c1y); + c = p1y - c1y; + t1 = (-b + math.sqrt(b * b - 4 * a * c)) / 2 / a; + t2 = (-b - math.sqrt(b * b - 4 * a * c)) / 2 / a; + abs(t1) > "1e12" && (t1 = .5); + abs(t2) > "1e12" && (t2 = .5); + if (t1 > 0 && t1 < 1) { + dot = findDotAtSegment(p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y, t1); + x.push(dot.x); + y.push(dot.y); + } + if (t2 > 0 && t2 < 1) { + dot = findDotAtSegment(p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y, t2); + x.push(dot.x); + y.push(dot.y); + } + return { + min: {x: mmin[apply](0, x), y: mmin[apply](0, y)}, + max: {x: mmax[apply](0, x), y: mmax[apply](0, y)} + }; + }), + path2curve = R._path2curve = cacher(function (path, path2) { + var p = pathToAbsolute(path), + p2 = path2 && pathToAbsolute(path2), + attrs = {x: 0, y: 0, bx: 0, by: 0, X: 0, Y: 0, qx: null, qy: null}, + attrs2 = {x: 0, y: 0, bx: 0, by: 0, X: 0, Y: 0, qx: null, qy: null}, + processPath = function (path, d) { + var nx, ny; + if (!path) { + return ["C", d.x, d.y, d.x, d.y, d.x, d.y]; + } + !(path[0] in {T:1, Q:1}) && (d.qx = d.qy = null); + switch (path[0]) { + case "M": + d.X = path[1]; + d.Y = path[2]; + break; + case "A": + path = ["C"][concat](a2c[apply](0, [d.x, d.y][concat](path.slice(1)))); + break; + case "S": + nx = d.x + (d.x - (d.bx || d.x)); + ny = d.y + (d.y - (d.by || d.y)); + path = ["C", nx, ny][concat](path.slice(1)); + break; + case "T": + d.qx = d.x + (d.x - (d.qx || d.x)); + d.qy = d.y + (d.y - (d.qy || d.y)); + path = ["C"][concat](q2c(d.x, d.y, d.qx, d.qy, path[1], path[2])); + break; + case "Q": + d.qx = path[1]; + d.qy = path[2]; + path = ["C"][concat](q2c(d.x, d.y, path[1], path[2], path[3], path[4])); + break; + case "L": + path = ["C"][concat](l2c(d.x, d.y, path[1], path[2])); + break; + case "H": + path = ["C"][concat](l2c(d.x, d.y, path[1], d.y)); + break; + case "V": + path = ["C"][concat](l2c(d.x, d.y, d.x, path[1])); + break; + case "Z": + path = ["C"][concat](l2c(d.x, d.y, d.X, d.Y)); + break; + } + return path; + }, + fixArc = function (pp, i) { + if (pp[i].length > 7) { + pp[i].shift(); + var pi = pp[i]; + while (pi.length) { + pp.splice(i++, 0, ["C"][concat](pi.splice(0, 6))); + } + pp.splice(i, 1); + ii = mmax(p.length, p2 && p2.length || 0); + } + }, + fixM = function (path1, path2, a1, a2, i) { + if (path1 && path2 && path1[i][0] == "M" && path2[i][0] != "M") { + path2.splice(i, 0, ["M", a2.x, a2.y]); + a1.bx = 0; + a1.by = 0; + a1.x = path1[i][1]; + a1.y = path1[i][2]; + ii = mmax(p.length, p2 && p2.length || 0); + } + }; + for (var i = 0, ii = mmax(p.length, p2 && p2.length || 0); i < ii; i++) { + p[i] = processPath(p[i], attrs); + fixArc(p, i); + p2 && (p2[i] = processPath(p2[i], attrs2)); + p2 && fixArc(p2, i); + fixM(p, p2, attrs, attrs2, i); + fixM(p2, p, attrs2, attrs, i); + var seg = p[i], + seg2 = p2 && p2[i], + seglen = seg.length, + seg2len = p2 && seg2.length; + attrs.x = seg[seglen - 2]; + attrs.y = seg[seglen - 1]; + attrs.bx = toFloat(seg[seglen - 4]) || attrs.x; + attrs.by = toFloat(seg[seglen - 3]) || attrs.y; + attrs2.bx = p2 && (toFloat(seg2[seg2len - 4]) || attrs2.x); + attrs2.by = p2 && (toFloat(seg2[seg2len - 3]) || attrs2.y); + attrs2.x = p2 && seg2[seg2len - 2]; + attrs2.y = p2 && seg2[seg2len - 1]; + } + return p2 ? [p, p2] : p; + }, null, pathClone), + parseDots = R._parseDots = cacher(function (gradient) { + var dots = []; + for (var i = 0, ii = gradient.length; i < ii; i++) { + var dot = {}, + par = gradient[i].match(/^([^:]*):?([\d\.]*)/); + dot.color = R.getRGB(par[1]); + if (dot.color.error) { + return null; + } + dot.color = dot.color.hex; + par[2] && (dot.offset = par[2] + "%"); + dots.push(dot); + } + for (i = 1, ii = dots.length - 1; i < ii; i++) { + if (!dots[i].offset) { + var start = toFloat(dots[i - 1].offset || 0), + end = 0; + for (var j = i + 1; j < ii; j++) { + if (dots[j].offset) { + end = dots[j].offset; + break; + } + } + if (!end) { + end = 100; + j = ii; + } + end = toFloat(end); + var d = (end - start) / (j - i + 1); + for (; i < j; i++) { + start += d; + dots[i].offset = start + "%"; + } + } + } + return dots; + }), + tear = R._tear = function (el, paper) { + el == paper.top && (paper.top = el.prev); + el == paper.bottom && (paper.bottom = el.next); + el.next && (el.next.prev = el.prev); + el.prev && (el.prev.next = el.next); + }, + tofront = R._tofront = function (el, paper) { + if (paper.top === el) { + return; + } + tear(el, paper); + el.next = null; + el.prev = paper.top; + paper.top.next = el; + paper.top = el; + }, + toback = R._toback = function (el, paper) { + if (paper.bottom === el) { + return; + } + tear(el, paper); + el.next = paper.bottom; + el.prev = null; + paper.bottom.prev = el; + paper.bottom = el; + }, + insertafter = R._insertafter = function (el, el2, paper) { + tear(el, paper); + el2 == paper.top && (paper.top = el); + el2.next && (el2.next.prev = el); + el.next = el2.next; + el.prev = el2; + el2.next = el; + }, + insertbefore = R._insertbefore = function (el, el2, paper) { + tear(el, paper); + el2 == paper.bottom && (paper.bottom = el); + el2.prev && (el2.prev.next = el); + el.prev = el2.prev; + el2.prev = el; + el.next = el2; + }, + extractTransform = R._extractTransform = function (el, tstr) { + if (tstr == null) { + return el._.transform; + } + tstr = Str(tstr).replace(/\.{3}|\u2026/g, el._.transform || E); + var tdata = R.parseTransformString(tstr), + deg = 0, + dx = 0, + dy = 0, + sx = 1, + sy = 1, + _ = el._, + m = new Matrix; + _.transform = tdata || []; + if (tdata) { + for (var i = 0, ii = tdata.length; i < ii; i++) { + var t = tdata[i], + tlen = t.length, + command = Str(t[0]).toLowerCase(), + absolute = t[0] != command, + inver = absolute ? m.invert() : 0, + x1, + y1, + x2, + y2, + bb; + if (command == "t" && tlen == 3) { + if (absolute) { + x1 = inver.x(0, 0); + y1 = inver.y(0, 0); + x2 = inver.x(t[1], t[2]); + y2 = inver.y(t[1], t[2]); + m.translate(x2 - x1, y2 - y1); + } else { + m.translate(t[1], t[2]); + } + } else if (command == "r") { + if (tlen == 2) { + bb = bb || el.getBBox(1); + m.rotate(t[1], bb.x + bb.width / 2, bb.y + bb.height / 2); + deg += t[1]; + } else if (tlen == 4) { + if (absolute) { + x2 = inver.x(t[2], t[3]); + y2 = inver.y(t[2], t[3]); + m.rotate(t[1], x2, y2); + } else { + m.rotate(t[1], t[2], t[3]); + } + deg += t[1]; + } + } else if (command == "s") { + if (tlen == 2 || tlen == 3) { + bb = bb || el.getBBox(1); + m.scale(t[1], t[tlen - 1], bb.x + bb.width / 2, bb.y + bb.height / 2); + sx *= t[1]; + sy *= t[tlen - 1]; + } else if (tlen == 5) { + if (absolute) { + x2 = inver.x(t[3], t[4]); + y2 = inver.y(t[3], t[4]); + m.scale(t[1], t[2], x2, y2); + } else { + m.scale(t[1], t[2], t[3], t[4]); + } + sx *= t[1]; + sy *= t[2]; + } + } else if (command == "m" && tlen == 7) { + m.add(t[1], t[2], t[3], t[4], t[5], t[6]); + } + _.dirtyT = 1; + el.matrix = m; + } + } + + el.matrix = m; + + _.sx = sx; + _.sy = sy; + _.deg = deg; + _.dx = dx = m.e; + _.dy = dy = m.f; + + if (sx == 1 && sy == 1 && !deg && _.bbox) { + _.bbox.x += +dx; + _.bbox.y += +dy; + } else { + _.dirtyT = 1; + } + }, + getEmpty = function (item) { + var l = item[0]; + switch (l.toLowerCase()) { + case "t": return [l, 0, 0]; + case "m": return [l, 1, 0, 0, 1, 0, 0]; + case "r": if (item.length == 4) { + return [l, 0, item[2], item[3]]; + } else { + return [l, 0]; + } + case "s": if (item.length == 5) { + return [l, 1, 1, item[3], item[4]]; + } else if (item.length == 3) { + return [l, 1, 1]; + } else { + return [l, 1]; + } + } + }, + equaliseTransform = R._equaliseTransform = function (t1, t2) { + t2 = Str(t2).replace(/\.{3}|\u2026/g, t1); + t1 = R.parseTransformString(t1) || []; + t2 = R.parseTransformString(t2) || []; + var maxlength = mmax(t1.length, t2.length), + from = [], + to = [], + i = 0, j, jj, + tt1, tt2; + for (; i < maxlength; i++) { + tt1 = t1[i] || getEmpty(t2[i]); + tt2 = t2[i] || getEmpty(tt1); + if ((tt1[0] != tt2[0]) || + (tt1[0].toLowerCase() == "r" && (tt1[2] != tt2[2] || tt1[3] != tt2[3])) || + (tt1[0].toLowerCase() == "s" && (tt1[3] != tt2[3] || tt1[4] != tt2[4])) + ) { + return; + } + from[i] = []; + to[i] = []; + for (j = 0, jj = mmax(tt1.length, tt2.length); j < jj; j++) { + j in tt1 && (from[i][j] = tt1[j]); + j in tt2 && (to[i][j] = tt2[j]); + } + } + return { + from: from, + to: to + }; + }; + R._getContainer = function (x, y, w, h) { + var container; + container = h == null && !R.is(x, "object") ? g.doc.getElementById(x) : x; + if (container == null) { + return; + } + if (container.tagName) { + if (y == null) { + return { + container: container, + width: container.style.pixelWidth || container.offsetWidth, + height: container.style.pixelHeight || container.offsetHeight + }; + } else { + return { + container: container, + width: y, + height: w + }; + } + } + return { + container: 1, + x: x, + y: y, + width: w, + height: h + }; + }; + + R.pathToRelative = pathToRelative; + R._engine = {}; + + R.path2curve = path2curve; + + R.matrix = function (a, b, c, d, e, f) { + return new Matrix(a, b, c, d, e, f); + }; + function Matrix(a, b, c, d, e, f) { + if (a != null) { + this.a = +a; + this.b = +b; + this.c = +c; + this.d = +d; + this.e = +e; + this.f = +f; + } else { + this.a = 1; + this.b = 0; + this.c = 0; + this.d = 1; + this.e = 0; + this.f = 0; + } + } + (function (matrixproto) { + + matrixproto.add = function (a, b, c, d, e, f) { + var out = [[], [], []], + m = [[this.a, this.c, this.e], [this.b, this.d, this.f], [0, 0, 1]], + matrix = [[a, c, e], [b, d, f], [0, 0, 1]], + x, y, z, res; + + if (a && a instanceof Matrix) { + matrix = [[a.a, a.c, a.e], [a.b, a.d, a.f], [0, 0, 1]]; + } + + for (x = 0; x < 3; x++) { + for (y = 0; y < 3; y++) { + res = 0; + for (z = 0; z < 3; z++) { + res += m[x][z] * matrix[z][y]; + } + out[x][y] = res; + } + } + this.a = out[0][0]; + this.b = out[1][0]; + this.c = out[0][1]; + this.d = out[1][1]; + this.e = out[0][2]; + this.f = out[1][2]; + }; + + matrixproto.invert = function () { + var me = this, + x = me.a * me.d - me.b * me.c; + return new Matrix(me.d / x, -me.b / x, -me.c / x, me.a / x, (me.c * me.f - me.d * me.e) / x, (me.b * me.e - me.a * me.f) / x); + }; + + matrixproto.clone = function () { + return new Matrix(this.a, this.b, this.c, this.d, this.e, this.f); + }; + + matrixproto.translate = function (x, y) { + this.add(1, 0, 0, 1, x, y); + }; + + matrixproto.scale = function (x, y, cx, cy) { + y == null && (y = x); + (cx || cy) && this.add(1, 0, 0, 1, cx, cy); + this.add(x, 0, 0, y, 0, 0); + (cx || cy) && this.add(1, 0, 0, 1, -cx, -cy); + }; + + matrixproto.rotate = function (a, x, y) { + a = R.rad(a); + x = x || 0; + y = y || 0; + var cos = +math.cos(a).toFixed(9), + sin = +math.sin(a).toFixed(9); + this.add(cos, sin, -sin, cos, x, y); + this.add(1, 0, 0, 1, -x, -y); + }; + + matrixproto.x = function (x, y) { + return x * this.a + y * this.c + this.e; + }; + + matrixproto.y = function (x, y) { + return x * this.b + y * this.d + this.f; + }; + matrixproto.get = function (i) { + return +this[Str.fromCharCode(97 + i)].toFixed(4); + }; + matrixproto.toString = function () { + return R.svg ? + "matrix(" + [this.get(0), this.get(1), this.get(2), this.get(3), this.get(4), this.get(5)].join() + ")" : + [this.get(0), this.get(2), this.get(1), this.get(3), 0, 0].join(); + }; + matrixproto.toFilter = function () { + return "progid:DXImageTransform.Microsoft.Matrix(M11=" + this.get(0) + + ", M12=" + this.get(2) + ", M21=" + this.get(1) + ", M22=" + this.get(3) + + ", Dx=" + this.get(4) + ", Dy=" + this.get(5) + ", sizingmethod='auto expand')"; + }; + matrixproto.offset = function () { + return [this.e.toFixed(4), this.f.toFixed(4)]; + }; + function norm(a) { + return a[0] * a[0] + a[1] * a[1]; + } + function normalize(a) { + var mag = math.sqrt(norm(a)); + a[0] && (a[0] /= mag); + a[1] && (a[1] /= mag); + } + + matrixproto.split = function () { + var out = {}; + // translation + out.dx = this.e; + out.dy = this.f; + + // scale and shear + var row = [[this.a, this.c], [this.b, this.d]]; + out.scalex = math.sqrt(norm(row[0])); + normalize(row[0]); + + out.shear = row[0][0] * row[1][0] + row[0][1] * row[1][1]; + row[1] = [row[1][0] - row[0][0] * out.shear, row[1][1] - row[0][1] * out.shear]; + + out.scaley = math.sqrt(norm(row[1])); + normalize(row[1]); + out.shear /= out.scaley; + + // rotation + var sin = -row[0][1], + cos = row[1][1]; + if (cos < 0) { + out.rotate = R.deg(math.acos(cos)); + if (sin < 0) { + out.rotate = 360 - out.rotate; + } + } else { + out.rotate = R.deg(math.asin(sin)); + } + + out.isSimple = !+out.shear.toFixed(9) && (out.scalex.toFixed(9) == out.scaley.toFixed(9) || !out.rotate); + out.isSuperSimple = !+out.shear.toFixed(9) && out.scalex.toFixed(9) == out.scaley.toFixed(9) && !out.rotate; + out.noRotation = !+out.shear.toFixed(9) && !out.rotate; + return out; + }; + + matrixproto.toTransformString = function (shorter) { + var s = shorter || this[split](); + if (s.isSimple) { + s.scalex = +s.scalex.toFixed(4); + s.scaley = +s.scaley.toFixed(4); + s.rotate = +s.rotate.toFixed(4); + return (s.dx && s.dy ? "t" + [s.dx, s.dy] : E) + + (s.scalex != 1 || s.scaley != 1 ? "s" + [s.scalex, s.scaley, 0, 0] : E) + + (s.rotate ? "r" + [s.rotate, 0, 0] : E); + } else { + return "m" + [this.get(0), this.get(1), this.get(2), this.get(3), this.get(4), this.get(5)]; + } + }; + })(Matrix.prototype); + + // WebKit rendering bug workaround method + var version = navigator.userAgent.match(/Version\/(.*?)\s/) || navigator.userAgent.match(/Chrome\/(\d+)/); + if ((navigator.vendor == "Apple Computer, Inc.") && (version && version[1] < 4 || navigator.platform.slice(0, 2) == "iP") || + (navigator.vendor == "Google Inc." && version && version[1] < 8)) { + + paperproto.safari = function () { + var rect = this.rect(-99, -99, this.width + 99, this.height + 99).attr({stroke: "none"}); + setTimeout(function () {rect.remove();}); + }; + } else { + paperproto.safari = fun; + } + + var preventDefault = function () { + this.returnValue = false; + }, + preventTouch = function () { + return this.originalEvent.preventDefault(); + }, + stopPropagation = function () { + this.cancelBubble = true; + }, + stopTouch = function () { + return this.originalEvent.stopPropagation(); + }, + addEvent = (function () { + if (g.doc.addEventListener) { + return function (obj, type, fn, element) { + var realName = supportsTouch && touchMap[type] ? touchMap[type] : type, + f = function (e) { + var scrollY = g.doc.documentElement.scrollTop || g.doc.body.scrollTop, + scrollX = g.doc.documentElement.scrollLeft || g.doc.body.scrollLeft, + x = e.clientX + scrollX, + y = e.clientY + scrollY; + if (supportsTouch && touchMap[has](type)) { + for (var i = 0, ii = e.targetTouches && e.targetTouches.length; i < ii; i++) { + if (e.targetTouches[i].target == obj) { + var olde = e; + e = e.targetTouches[i]; + e.originalEvent = olde; + e.preventDefault = preventTouch; + e.stopPropagation = stopTouch; + break; + } + } + } + return fn.call(element, e, x, y); + }; + obj.addEventListener(realName, f, false); + return function () { + obj.removeEventListener(realName, f, false); + return true; + }; + }; + } else if (g.doc.attachEvent) { + return function (obj, type, fn, element) { + var f = function (e) { + e = e || g.win.event; + var scrollY = g.doc.documentElement.scrollTop || g.doc.body.scrollTop, + scrollX = g.doc.documentElement.scrollLeft || g.doc.body.scrollLeft, + x = e.clientX + scrollX, + y = e.clientY + scrollY; + e.preventDefault = e.preventDefault || preventDefault; + e.stopPropagation = e.stopPropagation || stopPropagation; + return fn.call(element, e, x, y); + }; + obj.attachEvent("on" + type, f); + var detacher = function () { + obj.detachEvent("on" + type, f); + return true; + }; + return detacher; + }; + } + })(), + drag = [], + dragMove = function (e) { + var x = e.clientX, + y = e.clientY, + scrollY = g.doc.documentElement.scrollTop || g.doc.body.scrollTop, + scrollX = g.doc.documentElement.scrollLeft || g.doc.body.scrollLeft, + dragi, + j = drag.length; + while (j--) { + dragi = drag[j]; + if (supportsTouch) { + var i = e.touches.length, + touch; + while (i--) { + touch = e.touches[i]; + if (touch.identifier == dragi.el._drag.id) { + x = touch.clientX; + y = touch.clientY; + (e.originalEvent ? e.originalEvent : e).preventDefault(); + break; + } + } + } else { + e.preventDefault(); + } + var node = dragi.el.node, + o, + next = node.nextSibling, + parent = node.parentNode, + display = node.style.display; + g.win.opera && parent.removeChild(node); + node.style.display = "none"; + o = dragi.el.paper.getElementByPoint(x, y); + node.style.display = display; + g.win.opera && (next ? parent.insertBefore(node, next) : parent.appendChild(node)); + o && eve("drag.over." + dragi.el.id, dragi.el, o); + x += scrollX; + y += scrollY; + eve("drag.move." + dragi.el.id, dragi.move_scope || dragi.el, x - dragi.el._drag.x, y - dragi.el._drag.y, x, y, e); + } + }, + dragUp = function (e) { + R.unmousemove(dragMove).unmouseup(dragUp); + var i = drag.length, + dragi; + while (i--) { + dragi = drag[i]; + dragi.el._drag = {}; + eve("drag.end." + dragi.el.id, dragi.end_scope || dragi.start_scope || dragi.move_scope || dragi.el, e); + } + drag = []; + }, + + elproto = R.el = {}; + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + for (var i = events.length; i--;) { + (function (eventName) { + R[eventName] = elproto[eventName] = function (fn, scope) { + if (R.is(fn, "function")) { + this.events = this.events || []; + this.events.push({name: eventName, f: fn, unbind: addEvent(this.shape || this.node || g.doc, eventName, fn, scope || this)}); + } + return this; + }; + R["un" + eventName] = elproto["un" + eventName] = function (fn) { + var events = this.events, + l = events.length; + while (l--) if (events[l].name == eventName && events[l].f == fn) { + events[l].unbind(); + events.splice(l, 1); + !events.length && delete this.events; + return this; + } + return this; + }; + })(events[i]); + } + + + elproto.data = function (key, value) { + var data = eldata[this.id] = eldata[this.id] || {}; + if (arguments.length == 1) { + if (R.is(key, "object")) { + for (var i in key) if (key[has](i)) { + this.data(i, key[i]); + } + return this; + } + eve("data.get." + this.id, this, data[key], key); + return data[key]; + } + data[key] = value; + eve("data.set." + this.id, this, value, key); + return this; + }; + + elproto.removeData = function (key) { + if (key == null) { + eldata[this.id] = {}; + } else { + eldata[this.id] && delete eldata[this.id][key]; + } + return this; + }; + + elproto.hover = function (f_in, f_out, scope_in, scope_out) { + return this.mouseover(f_in, scope_in).mouseout(f_out, scope_out || scope_in); + }; + + elproto.unhover = function (f_in, f_out) { + return this.unmouseover(f_in).unmouseout(f_out); + }; + var draggable = []; + + elproto.drag = function (onmove, onstart, onend, move_scope, start_scope, end_scope) { + function start(e) { + (e.originalEvent || e).preventDefault(); + var scrollY = g.doc.documentElement.scrollTop || g.doc.body.scrollTop, + scrollX = g.doc.documentElement.scrollLeft || g.doc.body.scrollLeft; + this._drag.x = e.clientX + scrollX; + this._drag.y = e.clientY + scrollY; + this._drag.id = e.identifier; + !drag.length && R.mousemove(dragMove).mouseup(dragUp); + drag.push({el: this, move_scope: move_scope, start_scope: start_scope, end_scope: end_scope}); + onstart && eve.on("drag.start." + this.id, onstart); + onmove && eve.on("drag.move." + this.id, onmove); + onend && eve.on("drag.end." + this.id, onend); + eve("drag.start." + this.id, start_scope || move_scope || this, e.clientX + scrollX, e.clientY + scrollY, e); + } + this._drag = {}; + draggable.push({el: this, start: start}); + this.mousedown(start); + return this; + }; + + elproto.onDragOver = function (f) { + f ? eve.on("drag.over." + this.id, f) : eve.unbind("drag.over." + this.id); + }; + + elproto.undrag = function () { + var i = draggable.length; + while (i--) if (draggable[i].el == this) { + this.unmousedown(draggable[i].start); + draggable.splice(i, 1); + eve.unbind("drag.*." + this.id); + } + !draggable.length && R.unmousemove(dragMove).unmouseup(dragUp); + }; + + paperproto.circle = function (x, y, r) { + var out = R._engine.circle(this, x || 0, y || 0, r || 0); + this.__set__ && this.__set__.push(out); + return out; + }; + + paperproto.rect = function (x, y, w, h, r) { + var out = R._engine.rect(this, x || 0, y || 0, w || 0, h || 0, r || 0); + this.__set__ && this.__set__.push(out); + return out; + }; + + paperproto.ellipse = function (x, y, rx, ry) { + var out = R._engine.ellipse(this, x || 0, y || 0, rx || 0, ry || 0); + this.__set__ && this.__set__.push(out); + return out; + }; + + paperproto.path = function (pathString) { + pathString && !R.is(pathString, string) && !R.is(pathString[0], array) && (pathString += E); + var out = R._engine.path(R.format[apply](R, arguments), this); + this.__set__ && this.__set__.push(out); + return out; + }; + + paperproto.image = function (src, x, y, w, h) { + var out = R._engine.image(this, src || "about:blank", x || 0, y || 0, w || 0, h || 0); + this.__set__ && this.__set__.push(out); + return out; + }; + + paperproto.text = function (x, y, text) { + var out = R._engine.text(this, x || 0, y || 0, Str(text)); + this.__set__ && this.__set__.push(out); + return out; + }; + + paperproto.set = function (itemsArray) { + !R.is(itemsArray, "array") && (itemsArray = Array.prototype.splice.call(arguments, 0, arguments.length)); + var out = new Set(itemsArray); + this.__set__ && this.__set__.push(out); + return out; + }; + + paperproto.setStart = function (set) { + this.__set__ = set || this.set(); + }; + + paperproto.setFinish = function (set) { + var out = this.__set__; + delete this.__set__; + return out; + }; + + paperproto.setSize = function (width, height) { + return R._engine.setSize.call(this, width, height); + }; + + paperproto.setViewBox = function (x, y, w, h, fit) { + return R._engine.setViewBox.call(this, x, y, w, h, fit); + }; + + + paperproto.top = paperproto.bottom = null; + + paperproto.raphael = R; + var getOffset = function (elem) { + var box = elem.getBoundingClientRect(), + doc = elem.ownerDocument, + body = doc.body, + docElem = doc.documentElement, + clientTop = docElem.clientTop || body.clientTop || 0, clientLeft = docElem.clientLeft || body.clientLeft || 0, + top = box.top + (g.win.pageYOffset || docElem.scrollTop || body.scrollTop ) - clientTop, + left = box.left + (g.win.pageXOffset || docElem.scrollLeft || body.scrollLeft) - clientLeft; + return { + y: top, + x: left + }; + }; + + paperproto.getElementByPoint = function (x, y) { + var paper = this, + svg = paper.canvas, + target = g.doc.elementFromPoint(x, y); + if (g.win.opera && target.tagName == "svg") { + var so = getOffset(svg), + sr = svg.createSVGRect(); + sr.x = x - so.x; + sr.y = y - so.y; + sr.width = sr.height = 1; + var hits = svg.getIntersectionList(sr, null); + if (hits.length) { + target = hits[hits.length - 1]; + } + } + if (!target) { + return null; + } + while (target.parentNode && target != svg.parentNode && !target.raphael) { + target = target.parentNode; + } + target == paper.canvas.parentNode && (target = svg); + target = target && target.raphael ? paper.getById(target.raphaelid) : null; + return target; + }; + + paperproto.getById = function (id) { + var bot = this.bottom; + while (bot) { + if (bot.id == id) { + return bot; + } + bot = bot.next; + } + return null; + }; + + paperproto.forEach = function (callback, thisArg) { + var bot = this.bottom; + while (bot) { + if (callback.call(thisArg, bot) === false) { + return this; + } + bot = bot.next; + } + return this; + }; + function x_y() { + return this.x + S + this.y; + } + function x_y_w_h() { + return this.x + S + this.y + S + this.width + " \xd7 " + this.height; + } + + elproto.getBBox = function (isWithoutTransform) { + if (this.removed) { + return {}; + } + var _ = this._; + if (isWithoutTransform) { + if (_.dirty || !_.bboxwt) { + this.realPath = getPath[this.type](this); + _.bboxwt = pathDimensions(this.realPath); + _.bboxwt.toString = x_y_w_h; + _.dirty = 0; + } + return _.bboxwt; + } + if (_.dirty || _.dirtyT || !_.bbox) { + if (_.dirty || !this.realPath) { + _.bboxwt = 0; + this.realPath = getPath[this.type](this); + } + _.bbox = pathDimensions(mapPath(this.realPath, this.matrix)); + _.bbox.toString = x_y_w_h; + _.dirty = _.dirtyT = 0; + } + return _.bbox; + }; + + elproto.clone = function () { + if (this.removed) { + return null; + } + var out = this.paper[this.type]().attr(this.attr()); + this.__set__ && this.__set__.push(out); + return out; + }; + + elproto.glow = function (glow) { + if (this.type == "text") { + return null; + } + glow = glow || {}; + var s = { + width: (glow.width || 10) + (+this.attr("stroke-width") || 1), + fill: glow.fill || false, + opacity: glow.opacity || .5, + offsetx: glow.offsetx || 0, + offsety: glow.offsety || 0, + color: glow.color || "#000" + }, + c = s.width / 2, + r = this.paper, + out = r.set(), + path = this.realPath || getPath[this.type](this); + path = this.matrix ? mapPath(path, this.matrix) : path; + for (var i = 1; i < c + 1; i++) { + out.push(r.path(path).attr({ + stroke: s.color, + fill: s.fill ? s.color : "none", + "stroke-linejoin": "round", + "stroke-linecap": "round", + "stroke-width": +(s.width / c * i).toFixed(3), + opacity: +(s.opacity / c).toFixed(3) + })); + } + return out.insertBefore(this).translate(s.offsetx, s.offsety); + }; + var curveslengths = {}, + getPointAtSegmentLength = function (p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y, length) { + var len = 0, + precision = 100, + name = [p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y].join(), + cache = curveslengths[name], + old, dot; + !cache && (curveslengths[name] = cache = {data: []}); + cache.timer && clearTimeout(cache.timer); + cache.timer = setTimeout(function () {delete curveslengths[name];}, 2e3); + if (length != null && !cache.precision) { + var total = getPointAtSegmentLength(p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y); + cache.precision = ~~total * 10; + cache.data = []; + } + precision = cache.precision || precision; + for (var i = 0; i < precision + 1; i++) { + if (cache.data[i * precision]) { + dot = cache.data[i * precision]; + } else { + dot = R.findDotsAtSegment(p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y, i / precision); + cache.data[i * precision] = dot; + } + i && (len += pow(pow(old.x - dot.x, 2) + pow(old.y - dot.y, 2), .5)); + if (length != null && len >= length) { + return dot; + } + old = dot; + } + if (length == null) { + return len; + } + }, + getLengthFactory = function (istotal, subpath) { + return function (path, length, onlystart) { + path = path2curve(path); + var x, y, p, l, sp = "", subpaths = {}, point, + len = 0; + for (var i = 0, ii = path.length; i < ii; i++) { + p = path[i]; + if (p[0] == "M") { + x = +p[1]; + y = +p[2]; + } else { + l = getPointAtSegmentLength(x, y, p[1], p[2], p[3], p[4], p[5], p[6]); + if (len + l > length) { + if (subpath && !subpaths.start) { + point = getPointAtSegmentLength(x, y, p[1], p[2], p[3], p[4], p[5], p[6], length - len); + sp += ["C" + point.start.x, point.start.y, point.m.x, point.m.y, point.x, point.y]; + if (onlystart) {return sp;} + subpaths.start = sp; + sp = ["M" + point.x, point.y + "C" + point.n.x, point.n.y, point.end.x, point.end.y, p[5], p[6]].join(); + len += l; + x = +p[5]; + y = +p[6]; + continue; + } + if (!istotal && !subpath) { + point = getPointAtSegmentLength(x, y, p[1], p[2], p[3], p[4], p[5], p[6], length - len); + return {x: point.x, y: point.y, alpha: point.alpha}; + } + } + len += l; + x = +p[5]; + y = +p[6]; + } + sp += p.shift() + p; + } + subpaths.end = sp; + point = istotal ? len : subpath ? subpaths : R.findDotsAtSegment(x, y, p[0], p[1], p[2], p[3], p[4], p[5], 1); + point.alpha && (point = {x: point.x, y: point.y, alpha: point.alpha}); + return point; + }; + }; + var getTotalLength = getLengthFactory(1), + getPointAtLength = getLengthFactory(), + getSubpathsAtLength = getLengthFactory(0, 1); + + R.getTotalLength = getTotalLength; + + R.getPointAtLength = getPointAtLength; + + R.getSubpath = function (path, from, to) { + if (this.getTotalLength(path) - to < 1e-6) { + return getSubpathsAtLength(path, from).end; + } + var a = getSubpathsAtLength(path, to, 1); + return from ? getSubpathsAtLength(a, from).end : a; + }; + + elproto.getTotalLength = function () { + if (this.type != "path") {return;} + if (this.node.getTotalLength) { + return this.node.getTotalLength(); + } + return getTotalLength(this.attrs.path); + }; + + elproto.getPointAtLength = function (length) { + if (this.type != "path") {return;} + return getPointAtLength(this.attrs.path, length); + }; + + elproto.getSubpath = function (from, to) { + if (this.type != "path") {return;} + return R.getSubpath(this.attrs.path, from, to); + }; + + var ef = R.easing_formulas = { + linear: function (n) { + return n; + }, + "<": function (n) { + return pow(n, 1.7); + }, + ">": function (n) { + return pow(n, .48); + }, + "<>": function (n) { + var q = .48 - n / 1.04, + Q = math.sqrt(.1734 + q * q), + x = Q - q, + X = pow(abs(x), 1 / 3) * (x < 0 ? -1 : 1), + y = -Q - q, + Y = pow(abs(y), 1 / 3) * (y < 0 ? -1 : 1), + t = X + Y + .5; + return (1 - t) * 3 * t * t + t * t * t; + }, + backIn: function (n) { + var s = 1.70158; + return n * n * ((s + 1) * n - s); + }, + backOut: function (n) { + n = n - 1; + var s = 1.70158; + return n * n * ((s + 1) * n + s) + 1; + }, + elastic: function (n) { + if (n == !!n) { + return n; + } + return pow(2, -10 * n) * math.sin((n - .075) * (2 * PI) / .3) + 1; + }, + bounce: function (n) { + var s = 7.5625, + p = 2.75, + l; + if (n < (1 / p)) { + l = s * n * n; + } else { + if (n < (2 / p)) { + n -= (1.5 / p); + l = s * n * n + .75; + } else { + if (n < (2.5 / p)) { + n -= (2.25 / p); + l = s * n * n + .9375; + } else { + n -= (2.625 / p); + l = s * n * n + .984375; + } + } + } + return l; + } + }; + ef.easeIn = ef["ease-in"] = ef["<"]; + ef.easeOut = ef["ease-out"] = ef[">"]; + ef.easeInOut = ef["ease-in-out"] = ef["<>"]; + ef["back-in"] = ef.backIn; + ef["back-out"] = ef.backOut; + + var animationElements = [], + requestAnimFrame = window.requestAnimationFrame || + window.webkitRequestAnimationFrame || + window.mozRequestAnimationFrame || + window.oRequestAnimationFrame || + window.msRequestAnimationFrame || + function (callback) { + setTimeout(callback, 16); + }, + animation = function () { + var Now = +new Date, + l = 0; + for (; l < animationElements.length; l++) { + var e = animationElements[l]; + if (e.el.removed || e.paused) { + continue; + } + var time = Now - e.start, + ms = e.ms, + easing = e.easing, + from = e.from, + diff = e.diff, + to = e.to, + t = e.t, + that = e.el, + set = {}, + now, + init = {}, + key; + if (e.initstatus) { + time = (e.initstatus * e.anim.top - e.prev) / (e.percent - e.prev) * ms; + e.status = e.initstatus; + delete e.initstatus; + e.stop && animationElements.splice(l--, 1); + } else { + e.status = (e.prev + (e.percent - e.prev) * (time / ms)) / e.anim.top; + } + if (time < 0) { + continue; + } + if (time < ms) { + var pos = easing(time / ms); + for (var attr in from) if (from[has](attr)) { + switch (availableAnimAttrs[attr]) { + case nu: + now = +from[attr] + pos * ms * diff[attr]; + break; + case "colour": + now = "rgb(" + [ + upto255(round(from[attr].r + pos * ms * diff[attr].r)), + upto255(round(from[attr].g + pos * ms * diff[attr].g)), + upto255(round(from[attr].b + pos * ms * diff[attr].b)) + ].join(",") + ")"; + break; + case "path": + now = []; + for (var i = 0, ii = from[attr].length; i < ii; i++) { + now[i] = [from[attr][i][0]]; + for (var j = 1, jj = from[attr][i].length; j < jj; j++) { + now[i][j] = +from[attr][i][j] + pos * ms * diff[attr][i][j]; + } + now[i] = now[i].join(S); + } + now = now.join(S); + break; + case "transform": + if (diff[attr].real) { + now = []; + for (i = 0, ii = from[attr].length; i < ii; i++) { + now[i] = [from[attr][i][0]]; + for (j = 1, jj = from[attr][i].length; j < jj; j++) { + now[i][j] = from[attr][i][j] + pos * ms * diff[attr][i][j]; + } + } + } else { + var get = function (i) { + return +from[attr][i] + pos * ms * diff[attr][i]; + }; + // now = [["r", get(2), 0, 0], ["t", get(3), get(4)], ["s", get(0), get(1), 0, 0]]; + now = [["m", get(0), get(1), get(2), get(3), get(4), get(5)]]; + } + break; + case "csv": + if (attr == "clip-rect") { + now = []; + i = 4; + while (i--) { + now[i] = +from[attr][i] + pos * ms * diff[attr][i]; + } + } + break; + default: + var from2 = [][concat](from[attr]); + now = []; + i = that.paper.customAttributes[attr].length; + while (i--) { + now[i] = +from2[i] + pos * ms * diff[attr][i]; + } + break; + } + set[attr] = now; + } + that.attr(set); + (function (id, that, anim) { + setTimeout(function () { + eve("anim.frame." + id, that, anim); + }); + })(that.id, that, e.anim); + } else { + (function(f, el, a) { + setTimeout(function() { + eve("anim.frame." + el.id, el, a); + eve("anim.finish." + el.id, el, a); + R.is(f, "function") && f.call(el); + }); + })(e.callback, that, e.anim); + that.attr(to); + animationElements.splice(l--, 1); + if (e.repeat > 1 && !e.next) { + for (key in to) if (to[has](key)) { + init[key] = e.totalOrigin[key]; + } + e.el.attr(init); + runAnimation(e.anim, e.el, e.anim.percents[0], null, e.totalOrigin, e.repeat - 1); + } + if (e.next && !e.stop) { + runAnimation(e.anim, e.el, e.next, null, e.totalOrigin, e.repeat); + } + } + } + R.svg && that && that.paper && that.paper.safari(); + animationElements.length && requestAnimFrame(animation); + }, + upto255 = function (color) { + return color > 255 ? 255 : color < 0 ? 0 : color; + }; + + elproto.animateWith = function (element, anim, params, ms, easing, callback) { + var a = params ? R.animation(params, ms, easing, callback) : anim, + status = element.status(anim); + return this.animate(a).status(a, status * anim.ms / a.ms); + }; + function CubicBezierAtTime(t, p1x, p1y, p2x, p2y, duration) { + var cx = 3 * p1x, + bx = 3 * (p2x - p1x) - cx, + ax = 1 - cx - bx, + cy = 3 * p1y, + by = 3 * (p2y - p1y) - cy, + ay = 1 - cy - by; + function sampleCurveX(t) { + return ((ax * t + bx) * t + cx) * t; + } + function solve(x, epsilon) { + var t = solveCurveX(x, epsilon); + return ((ay * t + by) * t + cy) * t; + } + function solveCurveX(x, epsilon) { + var t0, t1, t2, x2, d2, i; + for(t2 = x, i = 0; i < 8; i++) { + x2 = sampleCurveX(t2) - x; + if (abs(x2) < epsilon) { + return t2; + } + d2 = (3 * ax * t2 + 2 * bx) * t2 + cx; + if (abs(d2) < 1e-6) { + break; + } + t2 = t2 - x2 / d2; + } + t0 = 0; + t1 = 1; + t2 = x; + if (t2 < t0) { + return t0; + } + if (t2 > t1) { + return t1; + } + while (t0 < t1) { + x2 = sampleCurveX(t2); + if (abs(x2 - x) < epsilon) { + return t2; + } + if (x > x2) { + t0 = t2; + } else { + t1 = t2; + } + t2 = (t1 - t0) / 2 + t0; + } + return t2; + } + return solve(t, 1 / (200 * duration)); + } + elproto.onAnimation = function (f) { + f ? eve.on("anim.frame." + this.id, f) : eve.unbind("anim.frame." + this.id); + return this; + }; + function Animation(anim, ms) { + var percents = [], + newAnim = {}; + this.ms = ms; + this.times = 1; + if (anim) { + for (var attr in anim) if (anim[has](attr)) { + newAnim[toFloat(attr)] = anim[attr]; + percents.push(toFloat(attr)); + } + percents.sort(sortByNumber); + } + this.anim = newAnim; + this.top = percents[percents.length - 1]; + this.percents = percents; + } + + Animation.prototype.delay = function (delay) { + var a = new Animation(this.anim, this.ms); + a.times = this.times; + a.del = +delay || 0; + return a; + }; + + Animation.prototype.repeat = function (times) { + var a = new Animation(this.anim, this.ms); + a.del = this.del; + a.times = math.floor(mmax(times, 0)) || 1; + return a; + }; + function runAnimation(anim, element, percent, status, totalOrigin, times) { + percent = toFloat(percent); + var params, + isInAnim, + isInAnimSet, + percents = [], + next, + prev, + timestamp, + ms = anim.ms, + from = {}, + to = {}, + diff = {}; + if (status) { + for (i = 0, ii = animationElements.length; i < ii; i++) { + var e = animationElements[i]; + if (e.el.id == element.id && e.anim == anim) { + if (e.percent != percent) { + animationElements.splice(i, 1); + isInAnimSet = 1; + } else { + isInAnim = e; + } + element.attr(e.totalOrigin); + break; + } + } + } else { + status = +to; // NaN + } + for (var i = 0, ii = anim.percents.length; i < ii; i++) { + if (anim.percents[i] == percent || anim.percents[i] > status * anim.top) { + percent = anim.percents[i]; + prev = anim.percents[i - 1] || 0; + ms = ms / anim.top * (percent - prev); + next = anim.percents[i + 1]; + params = anim.anim[percent]; + break; + } else if (status) { + element.attr(anim.anim[anim.percents[i]]); + } + } + if (!params) { + return; + } + if (!isInAnim) { + for (var attr in params) if (params[has](attr)) { + if (availableAnimAttrs[has](attr) || element.paper.customAttributes[has](attr)) { + from[attr] = element.attr(attr); + (from[attr] == null) && (from[attr] = availableAttrs[attr]); + to[attr] = params[attr]; + switch (availableAnimAttrs[attr]) { + case nu: + diff[attr] = (to[attr] - from[attr]) / ms; + break; + case "colour": + from[attr] = R.getRGB(from[attr]); + var toColour = R.getRGB(to[attr]); + diff[attr] = { + r: (toColour.r - from[attr].r) / ms, + g: (toColour.g - from[attr].g) / ms, + b: (toColour.b - from[attr].b) / ms + }; + break; + case "path": + var pathes = path2curve(from[attr], to[attr]), + toPath = pathes[1]; + from[attr] = pathes[0]; + diff[attr] = []; + for (i = 0, ii = from[attr].length; i < ii; i++) { + diff[attr][i] = [0]; + for (var j = 1, jj = from[attr][i].length; j < jj; j++) { + diff[attr][i][j] = (toPath[i][j] - from[attr][i][j]) / ms; + } + } + break; + case "transform": + var _ = element._, + eq = equaliseTransform(_[attr], to[attr]); + if (eq) { + from[attr] = eq.from; + to[attr] = eq.to; + diff[attr] = []; + diff[attr].real = true; + for (i = 0, ii = from[attr].length; i < ii; i++) { + diff[attr][i] = [from[attr][i][0]]; + for (j = 1, jj = from[attr][i].length; j < jj; j++) { + diff[attr][i][j] = (to[attr][i][j] - from[attr][i][j]) / ms; + } + } + } else { + var m = (element.matrix || new Matrix), + to2 = { + _: {transform: _.transform}, + getBBox: function () { + return element.getBBox(1); + } + }; + from[attr] = [ + m.a, + m.b, + m.c, + m.d, + m.e, + m.f + ]; + extractTransform(to2, to[attr]); + to[attr] = to2._.transform; + diff[attr] = [ + (to2.matrix.a - m.a) / ms, + (to2.matrix.b - m.b) / ms, + (to2.matrix.c - m.c) / ms, + (to2.matrix.d - m.d) / ms, + (to2.matrix.e - m.e) / ms, + (to2.matrix.e - m.f) / ms + ]; + // from[attr] = [_.sx, _.sy, _.deg, _.dx, _.dy]; + // var to2 = {_:{}, getBBox: function () { return element.getBBox(); }}; + // extractTransform(to2, to[attr]); + // diff[attr] = [ + // (to2._.sx - _.sx) / ms, + // (to2._.sy - _.sy) / ms, + // (to2._.deg - _.deg) / ms, + // (to2._.dx - _.dx) / ms, + // (to2._.dy - _.dy) / ms + // ]; + } + break; + case "csv": + var values = Str(params[attr])[split](separator), + from2 = Str(from[attr])[split](separator); + if (attr == "clip-rect") { + from[attr] = from2; + diff[attr] = []; + i = from2.length; + while (i--) { + diff[attr][i] = (values[i] - from[attr][i]) / ms; + } + } + to[attr] = values; + break; + default: + values = [][concat](params[attr]); + from2 = [][concat](from[attr]); + diff[attr] = []; + i = element.paper.customAttributes[attr].length; + while (i--) { + diff[attr][i] = ((values[i] || 0) - (from2[i] || 0)) / ms; + } + break; + } + } + } + var easing = params.easing, + easyeasy = R.easing_formulas[easing]; + if (!easyeasy) { + easyeasy = Str(easing).match(bezierrg); + if (easyeasy && easyeasy.length == 5) { + var curve = easyeasy; + easyeasy = function (t) { + return CubicBezierAtTime(t, +curve[1], +curve[2], +curve[3], +curve[4], ms); + }; + } else { + easyeasy = pipe; + } + } + timestamp = params.start || anim.start || +new Date; + e = { + anim: anim, + percent: percent, + timestamp: timestamp, + start: timestamp + (anim.del || 0), + status: 0, + initstatus: status || 0, + stop: false, + ms: ms, + easing: easyeasy, + from: from, + diff: diff, + to: to, + el: element, + callback: params.callback, + prev: prev, + next: next, + repeat: times || anim.times, + origin: element.attr(), + totalOrigin: totalOrigin + }; + animationElements.push(e); + if (status && !isInAnim && !isInAnimSet) { + e.stop = true; + e.start = new Date - ms * status; + if (animationElements.length == 1) { + return animation(); + } + } + if (isInAnimSet) { + e.start = new Date - e.ms * status; + } + animationElements.length == 1 && requestAnimFrame(animation); + } else { + isInAnim.initstatus = status; + isInAnim.start = new Date - isInAnim.ms * status; + } + eve("anim.start." + element.id, element, anim); + } + + R.animation = function (params, ms, easing, callback) { + if (params instanceof Animation) { + return params; + } + if (R.is(easing, "function") || !easing) { + callback = callback || easing || null; + easing = null; + } + params = Object(params); + ms = +ms || 0; + var p = {}, + json, + attr; + for (attr in params) if (params[has](attr) && toFloat(attr) != attr && toFloat(attr) + "%" != attr) { + json = true; + p[attr] = params[attr]; + } + if (!json) { + return new Animation(params, ms); + } else { + easing && (p.easing = easing); + callback && (p.callback = callback); + return new Animation({100: p}, ms); + } + }; + + elproto.animate = function (params, ms, easing, callback) { + var element = this; + if (element.removed) { + callback && callback.call(element); + return element; + } + var anim = params instanceof Animation ? params : R.animation(params, ms, easing, callback); + runAnimation(anim, element, anim.percents[0], null, element.attr()); + return element; + }; + + elproto.setTime = function (anim, value) { + if (anim && value != null) { + this.status(anim, mmin(value, anim.ms) / anim.ms); + } + return this; + }; + + elproto.status = function (anim, value) { + var out = [], + i = 0, + len, + e; + if (value != null) { + runAnimation(anim, this, -1, mmin(value, 1)); + return this; + } else { + len = animationElements.length; + for (; i < len; i++) { + e = animationElements[i]; + if (e.el.id == this.id && (!anim || e.anim == anim)) { + if (anim) { + return e.status; + } + out.push({ + anim: e.anim, + status: e.status + }); + } + } + if (anim) { + return 0; + } + return out; + } + }; + + elproto.pause = function (anim) { + for (var i = 0; i < animationElements.length; i++) if (animationElements[i].el.id == this.id && (!anim || animationElements[i].anim == anim)) { + if (eve("anim.pause." + this.id, this, animationElements[i].anim) !== false) { + animationElements[i].paused = true; + } + } + return this; + }; + + elproto.resume = function (anim) { + for (var i = 0; i < animationElements.length; i++) if (animationElements[i].el.id == this.id && (!anim || animationElements[i].anim == anim)) { + var e = animationElements[i]; + if (eve("anim.resume." + this.id, this, e.anim) !== false) { + delete e.paused; + this.status(e.anim, e.status); + } + } + return this; + }; + + elproto.stop = function (anim) { + for (var i = 0; i < animationElements.length; i++) if (animationElements[i].el.id == this.id && (!anim || animationElements[i].anim == anim)) { + if (eve("anim.stop." + this.id, this, animationElements[i].anim) !== false) { + animationElements.splice(i--, 1); + } + } + return this; + }; + elproto.toString = function () { + return "Rapha\xebl\u2019s object"; + }; + + // Set + var Set = function (items) { + this.items = []; + this.length = 0; + this.type = "set"; + if (items) { + for (var i = 0, ii = items.length; i < ii; i++) { + if (items[i] && (items[i].constructor == elproto.constructor || items[i].constructor == Set)) { + this[this.items.length] = this.items[this.items.length] = items[i]; + this.length++; + } + } + } + }, + setproto = Set.prototype; + + setproto.push = function () { + var item, + len; + for (var i = 0, ii = arguments.length; i < ii; i++) { + item = arguments[i]; + if (item && (item.constructor == elproto.constructor || item.constructor == Set)) { + len = this.items.length; + this[len] = this.items[len] = item; + this.length++; + } + } + return this; + }; + + setproto.pop = function () { + this.length && delete this[this.length--]; + return this.items.pop(); + }; + + setproto.forEach = function (callback, thisArg) { + for (var i = 0, ii = this.items.length; i < ii; i++) { + if (callback.call(thisArg, this.items[i], i) === false) { + return this; + } + } + return this; + }; + for (var method in elproto) if (elproto[has](method)) { + setproto[method] = (function (methodname) { + return function () { + var arg = arguments; + return this.forEach(function (el) { + el[methodname][apply](el, arg); + }); + }; + })(method); + } + setproto.attr = function (name, value) { + if (name && R.is(name, array) && R.is(name[0], "object")) { + for (var j = 0, jj = name.length; j < jj; j++) { + this.items[j].attr(name[j]); + } + } else { + for (var i = 0, ii = this.items.length; i < ii; i++) { + this.items[i].attr(name, value); + } + } + return this; + }; + + setproto.clear = function () { + while (this.length) { + this.pop(); + } + }; + + setproto.splice = function (index, count, insertion) { + index = index < 0 ? mmax(this.length + index, 0) : index; + count = mmax(0, mmin(this.length - index, count)); + var tail = [], + todel = [], + args = [], + i; + for (i = 2; i < arguments.length; i++) { + args.push(arguments[i]); + } + for (i = 0; i < count; i++) { + todel.push(this[index + i]); + } + for (; i < this.length - index; i++) { + tail.push(this[index + i]); + } + var arglen = args.length; + for (i = 0; i < arglen + tail.length; i++) { + this.items[index + i] = this[index + i] = i < arglen ? args[i] : tail[i - arglen]; + } + i = this.items.length = this.length -= count - arglen; + while (this[i]) { + delete this[i++]; + } + return new Set(todel); + }; + + setproto.exclude = function (el) { + for (var i = 0, ii = this.length; i < ii; i++) if (this[i] == el) { + this.splice(i, 1); + return true; + } + }; + setproto.animate = function (params, ms, easing, callback) { + (R.is(easing, "function") || !easing) && (callback = easing || null); + var len = this.items.length, + i = len, + item, + set = this, + collector; + if (!len) { + return this; + } + callback && (collector = function () { + !--len && callback.call(set); + }); + easing = R.is(easing, string) ? easing : collector; + var anim = R.animation(params, ms, easing, collector); + item = this.items[--i].animate(anim); + while (i--) { + this.items[i] && !this.items[i].removed && this.items[i].animateWith(item, anim); + } + return this; + }; + setproto.insertAfter = function (el) { + var i = this.items.length; + while (i--) { + this.items[i].insertAfter(el); + } + return this; + }; + setproto.getBBox = function () { + var x = [], + y = [], + w = [], + h = []; + for (var i = this.items.length; i--;) if (!this.items[i].removed) { + var box = this.items[i].getBBox(); + x.push(box.x); + y.push(box.y); + w.push(box.x + box.width); + h.push(box.y + box.height); + } + x = mmin[apply](0, x); + y = mmin[apply](0, y); + return { + x: x, + y: y, + width: mmax[apply](0, w) - x, + height: mmax[apply](0, h) - y + }; + }; + setproto.clone = function (s) { + s = new Set; + for (var i = 0, ii = this.items.length; i < ii; i++) { + s.push(this.items[i].clone()); + } + return s; + }; + setproto.toString = function () { + return "Rapha\xebl\u2018s set"; + }; + + + R.registerFont = function (font) { + if (!font.face) { + return font; + } + this.fonts = this.fonts || {}; + var fontcopy = { + w: font.w, + face: {}, + glyphs: {} + }, + family = font.face["font-family"]; + for (var prop in font.face) if (font.face[has](prop)) { + fontcopy.face[prop] = font.face[prop]; + } + if (this.fonts[family]) { + this.fonts[family].push(fontcopy); + } else { + this.fonts[family] = [fontcopy]; + } + if (!font.svg) { + fontcopy.face["units-per-em"] = toInt(font.face["units-per-em"], 10); + for (var glyph in font.glyphs) if (font.glyphs[has](glyph)) { + var path = font.glyphs[glyph]; + fontcopy.glyphs[glyph] = { + w: path.w, + k: {}, + d: path.d && "M" + path.d.replace(/[mlcxtrv]/g, function (command) { + return {l: "L", c: "C", x: "z", t: "m", r: "l", v: "c"}[command] || "M"; + }) + "z" + }; + if (path.k) { + for (var k in path.k) if (path[has](k)) { + fontcopy.glyphs[glyph].k[k] = path.k[k]; + } + } + } + } + return font; + }; + + paperproto.getFont = function (family, weight, style, stretch) { + stretch = stretch || "normal"; + style = style || "normal"; + weight = +weight || {normal: 400, bold: 700, lighter: 300, bolder: 800}[weight] || 400; + if (!R.fonts) { + return; + } + var font = R.fonts[family]; + if (!font) { + var name = new RegExp("(^|\\s)" + family.replace(/[^\w\d\s+!~.:_-]/g, E) + "(\\s|$)", "i"); + for (var fontName in R.fonts) if (R.fonts[has](fontName)) { + if (name.test(fontName)) { + font = R.fonts[fontName]; + break; + } + } + } + var thefont; + if (font) { + for (var i = 0, ii = font.length; i < ii; i++) { + thefont = font[i]; + if (thefont.face["font-weight"] == weight && (thefont.face["font-style"] == style || !thefont.face["font-style"]) && thefont.face["font-stretch"] == stretch) { + break; + } + } + } + return thefont; + }; + + paperproto.print = function (x, y, string, font, size, origin, letter_spacing) { + origin = origin || "middle"; // baseline|middle + letter_spacing = mmax(mmin(letter_spacing || 0, 1), -1); + var out = this.set(), + letters = Str(string)[split](E), + shift = 0, + path = E, + scale; + R.is(font, string) && (font = this.getFont(font)); + if (font) { + scale = (size || 16) / font.face["units-per-em"]; + var bb = font.face.bbox[split](separator), + top = +bb[0], + height = +bb[1] + (origin == "baseline" ? bb[3] - bb[1] + (+font.face.descent) : (bb[3] - bb[1]) / 2); + for (var i = 0, ii = letters.length; i < ii; i++) { + var prev = i && font.glyphs[letters[i - 1]] || {}, + curr = font.glyphs[letters[i]]; + shift += i ? (prev.w || font.w) + (prev.k && prev.k[letters[i]] || 0) + (font.w * letter_spacing) : 0; + curr && curr.d && out.push(this.path(curr.d).attr({ + fill: "#000", + stroke: "none", + transform: [["t", shift * scale, 0]] + })); + } + out.transform(["...s", scale, scale, top, height, "t", (x - top) / scale, (y - height) / scale]); + } + return out; + }; + + + paperproto.add = function (json) { + if (R.is(json, "array")) { + var res = this.set(), + i = 0, + ii = json.length, + j; + for (; i < ii; i++) { + j = json[i] || {}; + elements[has](j.type) && res.push(this[j.type]().attr(j)); + } + } + return res; + }; + + + R.format = function (token, params) { + var args = R.is(params, array) ? [0][concat](params) : arguments; + token && R.is(token, string) && args.length - 1 && (token = token.replace(formatrg, function (str, i) { + return args[++i] == null ? E : args[i]; + })); + return token || E; + }; + + R.fullfill = (function () { + var tokenRegex = /\{([^\}]+)\}/g, + objNotationRegex = /(?:(?:^|\.)(.+?)(?=\[|\.|$|\()|\[('|")(.+?)\2\])(\(\))?/g, // matches .xxxxx or ["xxxxx"] to run over object properties + replacer = function (all, key, obj) { + var res = obj; + key.replace(objNotationRegex, function (all, name, quote, quotedName, isFunc) { + name = name || quotedName; + if (res) { + if (name in res) { + res = res[name]; + } + typeof res == "function" && isFunc && (res = res()); + } + }); + res = (res == null || res == obj ? all : res) + ""; + return res; + }; + return function (str, obj) { + return String(str).replace(tokenRegex, function (all, key) { + return replacer(all, key, obj); + }); + }; + })(); + + R.ninja = function () { + oldRaphael.was ? (g.win.Raphael = oldRaphael.is) : delete Raphael; + return R; + }; + + R.st = setproto; + // Firefox <3.6 fix: http://webreflection.blogspot.com/2009/11/195-chars-to-help-lazy-loading.html + (function (doc, loaded, f) { + if (doc.readyState == null && doc.addEventListener){ + doc.addEventListener(loaded, f = function () { + doc.removeEventListener(loaded, f, false); + doc.readyState = "complete"; + }, false); + doc.readyState = "loading"; + } + function isLoaded() { + (/in/).test(doc.readyState) ? setTimeout(isLoaded, 9) : R.eve("DOMload"); + } + isLoaded(); + })(document, "DOMContentLoaded"); + + oldRaphael.was ? (g.win.Raphael = R) : (Raphael = R); + + eve.on("DOMload", function () { + loaded = true; + }); +})(); + + +// ┌─────────────────────────────────────────────────────────────────────┐ \\ +// │ Raphaël - JavaScript Vector Library │ \\ +// ├─────────────────────────────────────────────────────────────────────┤ \\ +// │ SVG Module │ \\ +// ├─────────────────────────────────────────────────────────────────────┤ \\ +// │ Copyright (c) 2008-2011 Dmitry Baranovskiy (http://raphaeljs.com) │ \\ +// │ Copyright (c) 2008-2011 Sencha Labs (http://sencha.com) │ \\ +// │ Licensed under the MIT (http://raphaeljs.com/license.html) license. │ \\ +// └─────────────────────────────────────────────────────────────────────┘ \\ +window.Raphael.svg && function (R) { + var has = "hasOwnProperty", + Str = String, + toFloat = parseFloat, + toInt = parseInt, + math = Math, + mmax = math.max, + abs = math.abs, + pow = math.pow, + separator = /[, ]+/, + eve = R.eve, + E = "", + S = " "; + var xlink = "http://www.w3.org/1999/xlink", + markers = { + block: "M5,0 0,2.5 5,5z", + classic: "M5,0 0,2.5 5,5 3.5,3 3.5,2z", + diamond: "M2.5,0 5,2.5 2.5,5 0,2.5z", + open: "M6,1 1,3.5 6,6", + oval: "M2.5,0A2.5,2.5,0,0,1,2.5,5 2.5,2.5,0,0,1,2.5,0z" + }, + markerCounter = {}; + R.toString = function () { + return "Your browser supports SVG.\nYou are running Rapha\xebl " + this.version; + }; + var $ = function (el, attr) { + if (attr) { + if (typeof el == "string") { + el = $(el); + } + for (var key in attr) if (attr[has](key)) { + if (key.substring(0, 6) == "xlink:") { + el.setAttributeNS(xlink, key.substring(6), Str(attr[key])); + } else { + el.setAttribute(key, Str(attr[key])); + } + } + } else { + el = R._g.doc.createElementNS("http://www.w3.org/2000/svg", el); + el.style && (el.style.webkitTapHighlightColor = "rgba(0,0,0,0)"); + } + return el; + }, + addGradientFill = function (element, gradient) { + var type = "linear", + id = element.id + gradient, + fx = .5, fy = .5, + o = element.node, + SVG = element.paper, + s = o.style, + el = R._g.doc.getElementById(id); + if (!el) { + gradient = Str(gradient).replace(R._radial_gradient, function (all, _fx, _fy) { + type = "radial"; + if (_fx && _fy) { + fx = toFloat(_fx); + fy = toFloat(_fy); + var dir = ((fy > .5) * 2 - 1); + pow(fx - .5, 2) + pow(fy - .5, 2) > .25 && + (fy = math.sqrt(.25 - pow(fx - .5, 2)) * dir + .5) && + fy != .5 && + (fy = fy.toFixed(5) - 1e-5 * dir); + } + return E; + }); + gradient = gradient.split(/\s*\-\s*/); + if (type == "linear") { + var angle = gradient.shift(); + angle = -toFloat(angle); + if (isNaN(angle)) { + return null; + } + var vector = [0, 0, math.cos(R.rad(angle)), math.sin(R.rad(angle))], + max = 1 / (mmax(abs(vector[2]), abs(vector[3])) || 1); + vector[2] *= max; + vector[3] *= max; + if (vector[2] < 0) { + vector[0] = -vector[2]; + vector[2] = 0; + } + if (vector[3] < 0) { + vector[1] = -vector[3]; + vector[3] = 0; + } + } + var dots = R._parseDots(gradient); + if (!dots) { + return null; + } + id = id.replace(/[\(\)\s,\xb0#]/g, "_"); + + if (element.gradient && id != element.gradient.id) { + SVG.defs.removeChild(element.gradient); + delete element.gradient; + } + + if (!element.gradient) { + el = $(type + "Gradient", {id: id}); + element.gradient = el; + $(el, type == "radial" ? { + fx: fx, + fy: fy + } : { + x1: vector[0], + y1: vector[1], + x2: vector[2], + y2: vector[3], + gradientTransform: element.matrix.invert() + }); + SVG.defs.appendChild(el); + for (var i = 0, ii = dots.length; i < ii; i++) { + el.appendChild($("stop", { + offset: dots[i].offset ? dots[i].offset : i ? "100%" : "0%", + "stop-color": dots[i].color || "#fff" + })); + } + } + } + $(o, { + fill: "url(#" + id + ")", + opacity: 1, + "fill-opacity": 1 + }); + s.fill = E; + s.opacity = 1; + s.fillOpacity = 1; + return 1; + }, + updatePosition = function (o) { + var bbox = o.getBBox(1); + $(o.pattern, {patternTransform: o.matrix.invert() + " translate(" + bbox.x + "," + bbox.y + ")"}); + }, + addArrow = function (o, value, isEnd) { + if (o.type == "path") { + var values = Str(value).toLowerCase().split("-"), + p = o.paper, + se = isEnd ? "end" : "start", + node = o.node, + attrs = o.attrs, + stroke = attrs["stroke-width"], + i = values.length, + type = "classic", + from, + to, + dx, + refX, + attr, + w = 3, + h = 3, + t = 5; + while (i--) { + switch (values[i]) { + case "block": + case "classic": + case "oval": + case "diamond": + case "open": + case "none": + type = values[i]; + break; + case "wide": h = 5; break; + case "narrow": h = 2; break; + case "long": w = 5; break; + case "short": w = 2; break; + } + } + if (type == "open") { + w += 2; + h += 2; + t += 2; + dx = 1; + refX = isEnd ? 4 : 1; + attr = { + fill: "none", + stroke: attrs.stroke + }; + } else { + refX = dx = w / 2; + attr = { + fill: attrs.stroke, + stroke: "none" + }; + } + if (o._.arrows) { + if (isEnd) { + o._.arrows.endPath && markerCounter[o._.arrows.endPath]--; + o._.arrows.endMarker && markerCounter[o._.arrows.endMarker]--; + } else { + o._.arrows.startPath && markerCounter[o._.arrows.startPath]--; + o._.arrows.startMarker && markerCounter[o._.arrows.startMarker]--; + } + } else { + o._.arrows = {}; + } + if (type != "none") { + var pathId = "raphael-marker-" + type, + markerId = "raphael-marker-" + se + type + w + h; + if (!R._g.doc.getElementById(pathId)) { + p.defs.appendChild($($("path"), { + "stroke-linecap": "round", + d: markers[type], + id: pathId + })); + markerCounter[pathId] = 1; + } else { + markerCounter[pathId]++; + } + var marker = R._g.doc.getElementById(markerId), + use; + if (!marker) { + marker = $($("marker"), { + id: markerId, + markerHeight: h, + markerWidth: w, + orient: "auto", + refX: refX, + refY: h / 2 + }); + use = $($("use"), { + "xlink:href": "#" + pathId, + transform: (isEnd ? " rotate(180 " + w / 2 + " " + h / 2 + ") " : S) + "scale(" + w / t + "," + h / t + ")", + "stroke-width": 1 / ((w / t + h / t) / 2) + }); + marker.appendChild(use); + p.defs.appendChild(marker); + markerCounter[markerId] = 1; + } else { + markerCounter[markerId]++; + use = marker.getElementsByTagName("use")[0]; + } + $(use, attr); + var delta = dx * (type != "diamond" && type != "oval"); + if (isEnd) { + from = o._.arrows.startdx * stroke || 0; + to = R.getTotalLength(attrs.path) - delta * stroke; + } else { + from = delta * stroke; + to = R.getTotalLength(attrs.path) - (o._.arrows.enddx * stroke || 0); + } + attr = {}; + attr["marker-" + se] = "url(#" + markerId + ")"; + if (to || from) { + attr.d = Raphael.getSubpath(attrs.path, from, to); + } + $(node, attr); + o._.arrows[se + "Path"] = pathId; + o._.arrows[se + "Marker"] = markerId; + o._.arrows[se + "dx"] = delta; + o._.arrows[se + "Type"] = type; + o._.arrows[se + "String"] = value; + } else { + if (isEnd) { + from = o._.arrows.startdx * stroke || 0; + to = R.getTotalLength(attrs.path) - from; + } else { + from = 0; + to = R.getTotalLength(attrs.path) - (o._.arrows.enddx * stroke || 0); + } + o._.arrows[se + "Path"] && $(node, {d: Raphael.getSubpath(attrs.path, from, to)}); + delete o._.arrows[se + "Path"]; + delete o._.arrows[se + "Marker"]; + delete o._.arrows[se + "dx"]; + delete o._.arrows[se + "Type"]; + delete o._.arrows[se + "String"]; + } + for (attr in markerCounter) if (markerCounter[has](attr) && !markerCounter[attr]) { + var item = R._g.doc.getElementById(attr); + item && item.parentNode.removeChild(item); + } + } + }, + dasharray = { + "": [0], + "none": [0], + "-": [3, 1], + ".": [1, 1], + "-.": [3, 1, 1, 1], + "-..": [3, 1, 1, 1, 1, 1], + ". ": [1, 3], + "- ": [4, 3], + "--": [8, 3], + "- .": [4, 3, 1, 3], + "--.": [8, 3, 1, 3], + "--..": [8, 3, 1, 3, 1, 3] + }, + addDashes = function (o, value, params) { + value = dasharray[Str(value).toLowerCase()]; + if (value) { + var width = o.attrs["stroke-width"] || "1", + butt = {round: width, square: width, butt: 0}[o.attrs["stroke-linecap"] || params["stroke-linecap"]] || 0, + dashes = [], + i = value.length; + while (i--) { + dashes[i] = value[i] * width + ((i % 2) ? 1 : -1) * butt; + } + $(o.node, {"stroke-dasharray": dashes.join(",")}); + } + }, + setFillAndStroke = function (o, params) { + var node = o.node, + attrs = o.attrs, + vis = node.style.visibility; + node.style.visibility = "hidden"; + for (var att in params) { + if (params[has](att)) { + if (!R._availableAttrs[has](att)) { + continue; + } + var value = params[att]; + attrs[att] = value; + switch (att) { + case "blur": + o.blur(value); + break; + case "href": + case "title": + case "target": + var pn = node.parentNode; + if (pn.tagName.toLowerCase() != "a") { + var hl = $("a"); + pn.insertBefore(hl, node); + hl.appendChild(node); + pn = hl; + } + if (att == "target" && value == "blank") { + pn.setAttributeNS(xlink, "show", "new"); + } else { + pn.setAttributeNS(xlink, att, value); + } + break; + case "cursor": + node.style.cursor = value; + break; + case "transform": + o.transform(value); + break; + case "arrow-start": + addArrow(o, value); + break; + case "arrow-end": + addArrow(o, value, 1); + break; + case "clip-rect": + var rect = Str(value).split(separator); + if (rect.length == 4) { + o.clip && o.clip.parentNode.parentNode.removeChild(o.clip.parentNode); + var el = $("clipPath"), + rc = $("rect"); + el.id = R.createUUID(); + $(rc, { + x: rect[0], + y: rect[1], + width: rect[2], + height: rect[3] + }); + el.appendChild(rc); + o.paper.defs.appendChild(el); + $(node, {"clip-path": "url(#" + el.id + ")"}); + o.clip = rc; + } + if (!value) { + var path = node.getAttribute("clip-path"); + if (path) { + var clip = R._g.doc.getElementById(path.replace(/(^url\(#|\)$)/g, E)); + clip && clip.parentNode.removeChild(clip); + $(node, {"clip-path": E}); + delete o.clip; + } + } + break; + case "path": + if (o.type == "path") { + $(node, {d: value ? attrs.path = R._pathToAbsolute(value) : "M0,0"}); + o._.dirty = 1; + if (o._.arrows) { + "startString" in o._.arrows && addArrow(o, o._.arrows.startString); + "endString" in o._.arrows && addArrow(o, o._.arrows.endString, 1); + } + } + break; + case "width": + node.setAttribute(att, value); + o._.dirty = 1; + if (attrs.fx) { + att = "x"; + value = attrs.x; + } else { + break; + } + case "x": + if (attrs.fx) { + value = -attrs.x - (attrs.width || 0); + } + case "rx": + if (att == "rx" && o.type == "rect") { + break; + } + case "cx": + node.setAttribute(att, value); + o.pattern && updatePosition(o); + o._.dirty = 1; + break; + case "height": + node.setAttribute(att, value); + o._.dirty = 1; + if (attrs.fy) { + att = "y"; + value = attrs.y; + } else { + break; + } + case "y": + if (attrs.fy) { + value = -attrs.y - (attrs.height || 0); + } + case "ry": + if (att == "ry" && o.type == "rect") { + break; + } + case "cy": + node.setAttribute(att, value); + o.pattern && updatePosition(o); + o._.dirty = 1; + break; + case "r": + if (o.type == "rect") { + $(node, {rx: value, ry: value}); + } else { + node.setAttribute(att, value); + } + o._.dirty = 1; + break; + case "src": + if (o.type == "image") { + node.setAttributeNS(xlink, "href", value); + } + break; + case "stroke-width": + if (o._.sx != 1 || o._.sy != 1) { + value /= mmax(abs(o._.sx), abs(o._.sy)) || 1; + } + if (o.paper._vbSize) { + value *= o.paper._vbSize; + } + node.setAttribute(att, value); + if (attrs["stroke-dasharray"]) { + addDashes(o, attrs["stroke-dasharray"], params); + } + if (o._.arrows) { + "startString" in o._.arrows && addArrow(o, o._.arrows.startString); + "endString" in o._.arrows && addArrow(o, o._.arrows.endString, 1); + } + break; + case "stroke-dasharray": + addDashes(o, value, params); + break; + case "fill": + var isURL = Str(value).match(R._ISURL); + if (isURL) { + el = $("pattern"); + var ig = $("image"); + el.id = R.createUUID(); + $(el, {x: 0, y: 0, patternUnits: "userSpaceOnUse", height: 1, width: 1}); + $(ig, {x: 0, y: 0, "xlink:href": isURL[1]}); + el.appendChild(ig); + + (function (el) { + R._preload(isURL[1], function () { + var w = this.offsetWidth, + h = this.offsetHeight; + $(el, {width: w, height: h}); + $(ig, {width: w, height: h}); + o.paper.safari(); + }); + })(el); + o.paper.defs.appendChild(el); + node.style.fill = "url(#" + el.id + ")"; + $(node, {fill: "url(#" + el.id + ")"}); + o.pattern = el; + o.pattern && updatePosition(o); + break; + } + var clr = R.getRGB(value); + if (!clr.error) { + delete params.gradient; + delete attrs.gradient; + !R.is(attrs.opacity, "undefined") && + R.is(params.opacity, "undefined") && + $(node, {opacity: attrs.opacity}); + !R.is(attrs["fill-opacity"], "undefined") && + R.is(params["fill-opacity"], "undefined") && + $(node, {"fill-opacity": attrs["fill-opacity"]}); + } else if ((o.type == "circle" || o.type == "ellipse" || Str(value).charAt() != "r") && addGradientFill(o, value)) { + if ("opacity" in attrs || "fill-opacity" in attrs) { + var gradient = R._g.doc.getElementById(node.getAttribute("fill").replace(/^url\(#|\)$/g, E)); + if (gradient) { + var stops = gradient.getElementsByTagName("stop"); + $(stops[stops.length - 1], {"stop-opacity": ("opacity" in attrs ? attrs.opacity : 1) * ("fill-opacity" in attrs ? attrs["fill-opacity"] : 1)}); + } + } + attrs.gradient = value; + attrs.fill = "none"; + break; + } + clr[has]("opacity") && $(node, {"fill-opacity": clr.opacity > 1 ? clr.opacity / 100 : clr.opacity}); + case "stroke": + clr = R.getRGB(value); + node.setAttribute(att, clr.hex); + att == "stroke" && clr[has]("opacity") && $(node, {"stroke-opacity": clr.opacity > 1 ? clr.opacity / 100 : clr.opacity}); + if (att == "stroke" && o._.arrows) { + "startString" in o._.arrows && addArrow(o, o._.arrows.startString); + "endString" in o._.arrows && addArrow(o, o._.arrows.endString, 1); + } + break; + case "gradient": + (o.type == "circle" || o.type == "ellipse" || Str(value).charAt() != "r") && addGradientFill(o, value); + break; + case "opacity": + if (attrs.gradient && !attrs[has]("stroke-opacity")) { + $(node, {"stroke-opacity": value > 1 ? value / 100 : value}); + } + // fall + case "fill-opacity": + if (attrs.gradient) { + gradient = R._g.doc.getElementById(node.getAttribute("fill").replace(/^url\(#|\)$/g, E)); + if (gradient) { + stops = gradient.getElementsByTagName("stop"); + $(stops[stops.length - 1], {"stop-opacity": value}); + } + break; + } + default: + att == "font-size" && (value = toInt(value, 10) + "px"); + var cssrule = att.replace(/(\-.)/g, function (w) { + return w.substring(1).toUpperCase(); + }); + node.style[cssrule] = value; + o._.dirty = 1; + node.setAttribute(att, value); + break; + } + } + } + + tuneText(o, params); + node.style.visibility = vis; + }, + leading = 1.2, + tuneText = function (el, params) { + if (el.type != "text" || !(params[has]("text") || params[has]("font") || params[has]("font-size") || params[has]("x") || params[has]("y"))) { + return; + } + var a = el.attrs, + node = el.node, + fontSize = node.firstChild ? toInt(R._g.doc.defaultView.getComputedStyle(node.firstChild, E).getPropertyValue("font-size"), 10) : 10; + + if (params[has]("text")) { + a.text = params.text; + while (node.firstChild) { + node.removeChild(node.firstChild); + } + var texts = Str(params.text).split("\n"), + tspans = [], + tspan; + for (var i = 0, ii = texts.length; i < ii; i++) { + tspan = $("tspan"); + i && $(tspan, {dy: fontSize * leading, x: a.x}); + tspan.appendChild(R._g.doc.createTextNode(texts[i])); + node.appendChild(tspan); + tspans[i] = tspan; + } + } else { + tspans = node.getElementsByTagName("tspan"); + for (i = 0, ii = tspans.length; i < ii; i++) if (i) { + $(tspans[i], {dy: fontSize * leading, x: a.x}); + } else { + $(tspans[0], {dy: 0}); + } + } + $(node, {x: a.x, y: a.y}); + el._.dirty = 1; + var bb = el._getBBox(), + dif = a.y - (bb.y + bb.height / 2); + dif && R.is(dif, "finite") && $(tspans[0], {dy: dif}); + }, + Element = function (node, svg) { + var X = 0, + Y = 0; + + this[0] = this.node = node; + + node.raphael = true; + + this.id = R._oid++; + node.raphaelid = this.id; + this.matrix = R.matrix(); + this.realPath = null; + + this.paper = svg; + this.attrs = this.attrs || {}; + this._ = { + transform: [], + sx: 1, + sy: 1, + deg: 0, + dx: 0, + dy: 0, + dirty: 1 + }; + !svg.bottom && (svg.bottom = this); + + this.prev = svg.top; + svg.top && (svg.top.next = this); + svg.top = this; + + this.next = null; + }, + elproto = R.el; + + Element.prototype = elproto; + elproto.constructor = Element; + + R._engine.path = function (pathString, SVG) { + var el = $("path"); + SVG.canvas && SVG.canvas.appendChild(el); + var p = new Element(el, SVG); + p.type = "path"; + setFillAndStroke(p, { + fill: "none", + stroke: "#000", + path: pathString + }); + return p; + }; + + elproto.rotate = function (deg, cx, cy) { + if (this.removed) { + return this; + } + deg = Str(deg).split(separator); + if (deg.length - 1) { + cx = toFloat(deg[1]); + cy = toFloat(deg[2]); + } + deg = toFloat(deg[0]); + (cy == null) && (cx = cy); + if (cx == null || cy == null) { + var bbox = this.getBBox(1); + cx = bbox.x + bbox.width / 2; + cy = bbox.y + bbox.height / 2; + } + this.transform(this._.transform.concat([["r", deg, cx, cy]])); + return this; + }; + + elproto.scale = function (sx, sy, cx, cy) { + if (this.removed) { + return this; + } + sx = Str(sx).split(separator); + if (sx.length - 1) { + sy = toFloat(sx[1]); + cx = toFloat(sx[2]); + cy = toFloat(sx[3]); + } + sx = toFloat(sx[0]); + (sy == null) && (sy = sx); + (cy == null) && (cx = cy); + if (cx == null || cy == null) { + var bbox = this.getBBox(1); + } + cx = cx == null ? bbox.x + bbox.width / 2 : cx; + cy = cy == null ? bbox.y + bbox.height / 2 : cy; + this.transform(this._.transform.concat([["s", sx, sy, cx, cy]])); + return this; + }; + + elproto.translate = function (dx, dy) { + if (this.removed) { + return this; + } + dx = Str(dx).split(separator); + if (dx.length - 1) { + dy = toFloat(dx[1]); + } + dx = toFloat(dx[0]) || 0; + dy = +dy || 0; + this.transform(this._.transform.concat([["t", dx, dy]])); + return this; + }; + + elproto.transform = function (tstr) { + var _ = this._; + if (tstr == null) { + return _.transform; + } + R._extractTransform(this, tstr); + + this.clip && $(this.clip, {transform: this.matrix.invert()}); + this.pattern && updatePosition(this); + this.node && $(this.node, {transform: this.matrix}); + + if (_.sx != 1 || _.sy != 1) { + var sw = this.attrs[has]("stroke-width") ? this.attrs["stroke-width"] : 1; + this.attr({"stroke-width": sw}); + } + + return this; + }; + + elproto.hide = function () { + !this.removed && this.paper.safari(this.node.style.display = "none"); + return this; + }; + + elproto.show = function () { + !this.removed && this.paper.safari(this.node.style.display = ""); + return this; + }; + + elproto.remove = function () { + if (this.removed) { + return; + } + var paper = this.paper; + paper.__set__ && paper.__set__.exclude(this); + eve.unbind("*.*." + this.id); + if (this.gradient) { + paper.defs.removeChild(this.gradient); + } + R._tear(this, paper); + this.node.parentNode.removeChild(this.node); + for (var i in this) { + this[i] = typeof this[i] == "function" ? R._removedFactory(i) : null; + } + this.removed = true; + }; + elproto._getBBox = function () { + if (this.node.style.display == "none") { + this.show(); + var hide = true; + } + var bbox = {}; + try { + bbox = this.node.getBBox(); + } catch(e) { + // Firefox 3.0.x plays badly here + } finally { + bbox = bbox || {}; + } + hide && this.hide(); + return bbox; + }; + + elproto.attr = function (name, value) { + if (this.removed) { + return this; + } + if (name == null) { + var res = {}; + for (var a in this.attrs) if (this.attrs[has](a)) { + res[a] = this.attrs[a]; + } + res.gradient && res.fill == "none" && (res.fill = res.gradient) && delete res.gradient; + res.transform = this._.transform; + return res; + } + if (value == null && R.is(name, "string")) { + if (name == "fill" && this.attrs.fill == "none" && this.attrs.gradient) { + return this.attrs.gradient; + } + if (name == "transform") { + return this._.transform; + } + var names = name.split(separator), + out = {}; + for (var i = 0, ii = names.length; i < ii; i++) { + name = names[i]; + if (name in this.attrs) { + out[name] = this.attrs[name]; + } else if (R.is(this.paper.customAttributes[name], "function")) { + out[name] = this.paper.customAttributes[name].def; + } else { + out[name] = R._availableAttrs[name]; + } + } + return ii - 1 ? out : out[names[0]]; + } + if (value == null && R.is(name, "array")) { + out = {}; + for (i = 0, ii = name.length; i < ii; i++) { + out[name[i]] = this.attr(name[i]); + } + return out; + } + if (value != null) { + var params = {}; + params[name] = value; + } else if (name != null && R.is(name, "object")) { + params = name; + } + for (var key in params) { + eve("attr." + key + "." + this.id, this, params[key]); + } + for (key in this.paper.customAttributes) if (this.paper.customAttributes[has](key) && params[has](key) && R.is(this.paper.customAttributes[key], "function")) { + var par = this.paper.customAttributes[key].apply(this, [].concat(params[key])); + this.attrs[key] = params[key]; + for (var subkey in par) if (par[has](subkey)) { + params[subkey] = par[subkey]; + } + } + setFillAndStroke(this, params); + return this; + }; + + elproto.toFront = function () { + if (this.removed) { + return this; + } + if (this.node.parentNode.tagName.toLowerCase() == "a") { + this.node.parentNode.parentNode.appendChild(this.node.parentNode); + } else { + this.node.parentNode.appendChild(this.node); + } + var svg = this.paper; + svg.top != this && R._tofront(this, svg); + return this; + }; + + elproto.toBack = function () { + if (this.removed) { + return this; + } + var parent = this.node.parentNode; + if (parent.tagName.toLowerCase() == "a") { + parent.parentNode.insertBefore(this.node.parentNode, this.node.parentNode.parentNode.firstChild); + } else if (parent.firstChild != this.node) { + parent.insertBefore(this.node, this.node.parentNode.firstChild); + } + R._toback(this, this.paper); + var svg = this.paper; + return this; + }; + + elproto.insertAfter = function (element) { + if (this.removed) { + return this; + } + var node = element.node || element[element.length - 1].node; + if (node.nextSibling) { + node.parentNode.insertBefore(this.node, node.nextSibling); + } else { + node.parentNode.appendChild(this.node); + } + R._insertafter(this, element, this.paper); + return this; + }; + + elproto.insertBefore = function (element) { + if (this.removed) { + return this; + } + var node = element.node || element[0].node; + node.parentNode.insertBefore(this.node, node); + R._insertbefore(this, element, this.paper); + return this; + }; + elproto.blur = function (size) { + // Experimental. No Safari support. Use it on your own risk. + var t = this; + if (+size !== 0) { + var fltr = $("filter"), + blur = $("feGaussianBlur"); + t.attrs.blur = size; + fltr.id = R.createUUID(); + $(blur, {stdDeviation: +size || 1.5}); + fltr.appendChild(blur); + t.paper.defs.appendChild(fltr); + t._blur = fltr; + $(t.node, {filter: "url(#" + fltr.id + ")"}); + } else { + if (t._blur) { + t._blur.parentNode.removeChild(t._blur); + delete t._blur; + delete t.attrs.blur; + } + t.node.removeAttribute("filter"); + } + }; + R._engine.circle = function (svg, x, y, r) { + var el = $("circle"); + svg.canvas && svg.canvas.appendChild(el); + var res = new Element(el, svg); + res.attrs = {cx: x, cy: y, r: r, fill: "none", stroke: "#000"}; + res.type = "circle"; + $(el, res.attrs); + return res; + }; + R._engine.rect = function (svg, x, y, w, h, r) { + var el = $("rect"); + svg.canvas && svg.canvas.appendChild(el); + var res = new Element(el, svg); + res.attrs = {x: x, y: y, width: w, height: h, r: r || 0, rx: r || 0, ry: r || 0, fill: "none", stroke: "#000"}; + res.type = "rect"; + $(el, res.attrs); + return res; + }; + R._engine.ellipse = function (svg, x, y, rx, ry) { + var el = $("ellipse"); + svg.canvas && svg.canvas.appendChild(el); + var res = new Element(el, svg); + res.attrs = {cx: x, cy: y, rx: rx, ry: ry, fill: "none", stroke: "#000"}; + res.type = "ellipse"; + $(el, res.attrs); + return res; + }; + R._engine.image = function (svg, src, x, y, w, h) { + var el = $("image"); + $(el, {x: x, y: y, width: w, height: h, preserveAspectRatio: "none"}); + el.setAttributeNS(xlink, "href", src); + svg.canvas && svg.canvas.appendChild(el); + var res = new Element(el, svg); + res.attrs = {x: x, y: y, width: w, height: h, src: src}; + res.type = "image"; + return res; + }; + R._engine.text = function (svg, x, y, text) { + var el = $("text"); + // $(el, {x: x, y: y, "text-anchor": "middle"}); + svg.canvas && svg.canvas.appendChild(el); + var res = new Element(el, svg); + res.attrs = { + x: x, + y: y, + "text-anchor": "middle", + text: text, + font: R._availableAttrs.font, + stroke: "none", + fill: "#000" + }; + res.type = "text"; + setFillAndStroke(res, res.attrs); + return res; + }; + R._engine.setSize = function (width, height) { + this.width = width || this.width; + this.height = height || this.height; + this.canvas.setAttribute("width", this.width); + this.canvas.setAttribute("height", this.height); + if (this._viewBox) { + this.setViewBox.apply(this, this._viewBox); + } + return this; + }; + R._engine.create = function () { + var con = R._getContainer.apply(0, arguments), + container = con && con.container, + x = con.x, + y = con.y, + width = con.width, + height = con.height; + if (!container) { + throw new Error("SVG container not found."); + } + var cnvs = $("svg"), + css = "overflow:hidden;", + isFloating; + x = x || 0; + y = y || 0; + width = width || 512; + height = height || 342; + $(cnvs, { + height: height, + version: 1.1, + width: width, + xmlns: "http://www.w3.org/2000/svg" + }); + if (container == 1) { + cnvs.style.cssText = css + "position:absolute;left:" + x + "px;top:" + y + "px"; + R._g.doc.body.appendChild(cnvs); + isFloating = 1; + } else { + cnvs.style.cssText = css + "position:relative"; + if (container.firstChild) { + container.insertBefore(cnvs, container.firstChild); + } else { + container.appendChild(cnvs); + } + } + container = new R._Paper; + container.width = width; + container.height = height; + container.canvas = cnvs; + // plugins.call(container, container, R.fn); + container.clear(); + container._left = container._top = 0; + isFloating && (container.renderfix = function () {}); + container.renderfix(); + return container; + }; + R._engine.setViewBox = function (x, y, w, h, fit) { + eve("setViewBox", this, this._viewBox, [x, y, w, h, fit]); + var size = mmax(w / this.width, h / this.height), + top = this.top, + aspectRatio = fit ? "meet" : "xMinYMin", + vb, + sw; + if (x == null) { + if (this._vbSize) { + size = 1; + } + delete this._vbSize; + vb = "0 0 " + this.width + S + this.height; + } else { + this._vbSize = size; + vb = x + S + y + S + w + S + h; + } + $(this.canvas, { + viewBox: vb, + preserveAspectRatio: aspectRatio + }); + while (size && top) { + sw = "stroke-width" in top.attrs ? top.attrs["stroke-width"] : 1; + top.attr({"stroke-width": sw}); + top._.dirty = 1; + top._.dirtyT = 1; + top = top.prev; + } + this._viewBox = [x, y, w, h, !!fit]; + return this; + }; + + R.prototype.renderfix = function () { + var cnvs = this.canvas, + s = cnvs.style, + pos = cnvs.getScreenCTM() || cnvs.createSVGMatrix(), + left = -pos.e % 1, + top = -pos.f % 1; + if (left || top) { + if (left) { + this._left = (this._left + left) % 1; + s.left = this._left + "px"; + } + if (top) { + this._top = (this._top + top) % 1; + s.top = this._top + "px"; + } + } + }; + + R.prototype.clear = function () { + R.eve("clear", this); + var c = this.canvas; + while (c.firstChild) { + c.removeChild(c.firstChild); + } + this.bottom = this.top = null; + (this.desc = $("desc")).appendChild(R._g.doc.createTextNode("Created with Rapha\xebl " + R.version)); + c.appendChild(this.desc); + c.appendChild(this.defs = $("defs")); + }; + + R.prototype.remove = function () { + eve("remove", this); + this.canvas.parentNode && this.canvas.parentNode.removeChild(this.canvas); + for (var i in this) { + this[i] = typeof this[i] == "function" ? R._removedFactory(i) : null; + } + }; + var setproto = R.st; + for (var method in elproto) if (elproto[has](method) && !setproto[has](method)) { + setproto[method] = (function (methodname) { + return function () { + var arg = arguments; + return this.forEach(function (el) { + el[methodname].apply(el, arg); + }); + }; + })(method); + } +}(window.Raphael); + +// ┌─────────────────────────────────────────────────────────────────────┐ \\ +// │ Raphaël - JavaScript Vector Library │ \\ +// ├─────────────────────────────────────────────────────────────────────┤ \\ +// │ VML Module │ \\ +// ├─────────────────────────────────────────────────────────────────────┤ \\ +// │ Copyright (c) 2008-2011 Dmitry Baranovskiy (http://raphaeljs.com) │ \\ +// │ Copyright (c) 2008-2011 Sencha Labs (http://sencha.com) │ \\ +// │ Licensed under the MIT (http://raphaeljs.com/license.html) license. │ \\ +// └─────────────────────────────────────────────────────────────────────┘ \\ +window.Raphael.vml && function (R) { + var has = "hasOwnProperty", + Str = String, + toFloat = parseFloat, + math = Math, + round = math.round, + mmax = math.max, + mmin = math.min, + abs = math.abs, + fillString = "fill", + separator = /[, ]+/, + eve = R.eve, + ms = " progid:DXImageTransform.Microsoft", + S = " ", + E = "", + map = {M: "m", L: "l", C: "c", Z: "x", m: "t", l: "r", c: "v", z: "x"}, + bites = /([clmz]),?([^clmz]*)/gi, + blurregexp = / progid:\S+Blur\([^\)]+\)/g, + val = /-?[^,\s-]+/g, + cssDot = "position:absolute;left:0;top:0;width:1px;height:1px", + zoom = 21600, + pathTypes = {path: 1, rect: 1, image: 1}, + ovalTypes = {circle: 1, ellipse: 1}, + path2vml = function (path) { + var total = /[ahqstv]/ig, + command = R._pathToAbsolute; + Str(path).match(total) && (command = R._path2curve); + total = /[clmz]/g; + if (command == R._pathToAbsolute && !Str(path).match(total)) { + var res = Str(path).replace(bites, function (all, command, args) { + var vals = [], + isMove = command.toLowerCase() == "m", + res = map[command]; + args.replace(val, function (value) { + if (isMove && vals.length == 2) { + res += vals + map[command == "m" ? "l" : "L"]; + vals = []; + } + vals.push(round(value * zoom)); + }); + return res + vals; + }); + return res; + } + var pa = command(path), p, r; + res = []; + for (var i = 0, ii = pa.length; i < ii; i++) { + p = pa[i]; + r = pa[i][0].toLowerCase(); + r == "z" && (r = "x"); + for (var j = 1, jj = p.length; j < jj; j++) { + r += round(p[j] * zoom) + (j != jj - 1 ? "," : E); + } + res.push(r); + } + return res.join(S); + }, + compensation = function (deg, dx, dy) { + var m = R.matrix(); + m.rotate(-deg, .5, .5); + return { + dx: m.x(dx, dy), + dy: m.y(dx, dy) + }; + }, + setCoords = function (p, sx, sy, dx, dy, deg) { + var _ = p._, + m = p.matrix, + fillpos = _.fillpos, + o = p.node, + s = o.style, + y = 1, + flip = "", + dxdy, + kx = zoom / sx, + ky = zoom / sy; + s.visibility = "hidden"; + if (!sx || !sy) { + return; + } + o.coordsize = abs(kx) + S + abs(ky); + s.rotation = deg * (sx * sy < 0 ? -1 : 1); + if (deg) { + var c = compensation(deg, dx, dy); + dx = c.dx; + dy = c.dy; + } + sx < 0 && (flip += "x"); + sy < 0 && (flip += " y") && (y = -1); + s.flip = flip; + o.coordorigin = (dx * -kx) + S + (dy * -ky); + if (fillpos || _.fillsize) { + var fill = o.getElementsByTagName(fillString); + fill = fill && fill[0]; + o.removeChild(fill); + if (fillpos) { + c = compensation(deg, m.x(fillpos[0], fillpos[1]), m.y(fillpos[0], fillpos[1])); + fill.position = c.dx * y + S + c.dy * y; + } + if (_.fillsize) { + fill.size = _.fillsize[0] * abs(sx) + S + _.fillsize[1] * abs(sy); + } + o.appendChild(fill); + } + s.visibility = "visible"; + }; + R.toString = function () { + return "Your browser doesn\u2019t support SVG. Falling down to VML.\nYou are running Rapha\xebl " + this.version; + }; + var addArrow = function (o, value, isEnd) { + var values = Str(value).toLowerCase().split("-"), + se = isEnd ? "end" : "start", + i = values.length, + type = "classic", + w = "medium", + h = "medium"; + while (i--) { + switch (values[i]) { + case "block": + case "classic": + case "oval": + case "diamond": + case "open": + case "none": + type = values[i]; + break; + case "wide": + case "narrow": h = values[i]; break; + case "long": + case "short": w = values[i]; break; + } + } + var stroke = o.node.getElementsByTagName("stroke")[0]; + stroke[se + "arrow"] = type; + stroke[se + "arrowlength"] = w; + stroke[se + "arrowwidth"] = h; + }, + setFillAndStroke = function (o, params) { + // o.paper.canvas.style.display = "none"; + o.attrs = o.attrs || {}; + var node = o.node, + a = o.attrs, + s = node.style, + xy, + newpath = pathTypes[o.type] && (params.x != a.x || params.y != a.y || params.width != a.width || params.height != a.height || params.cx != a.cx || params.cy != a.cy || params.rx != a.rx || params.ry != a.ry || params.r != a.r), + isOval = ovalTypes[o.type] && (a.cx != params.cx || a.cy != params.cy || a.r != params.r || a.rx != params.rx || a.ry != params.ry), + res = o; + + + for (var par in params) if (params[has](par)) { + a[par] = params[par]; + } + if (newpath) { + a.path = R._getPath[o.type](o); + o._.dirty = 1; + } + params.href && (node.href = params.href); + params.title && (node.title = params.title); + params.target && (node.target = params.target); + params.cursor && (s.cursor = params.cursor); + "blur" in params && o.blur(params.blur); + if (params.path && o.type == "path" || newpath) { + node.path = path2vml(~Str(a.path).toLowerCase().indexOf("r") ? R._pathToAbsolute(a.path) : a.path); + if (o.type == "image") { + o._.fillpos = [a.x, a.y]; + o._.fillsize = [a.width, a.height]; + setCoords(o, 1, 1, 0, 0, 0); + } + } + "transform" in params && o.transform(params.transform); + if (isOval) { + var cx = +a.cx, + cy = +a.cy, + rx = +a.rx || +a.r || 0, + ry = +a.ry || +a.r || 0; + node.path = R.format("ar{0},{1},{2},{3},{4},{1},{4},{1}x", round((cx - rx) * zoom), round((cy - ry) * zoom), round((cx + rx) * zoom), round((cy + ry) * zoom), round(cx * zoom)); + } + if ("clip-rect" in params) { + var rect = Str(params["clip-rect"]).split(separator); + if (rect.length == 4) { + rect[2] = +rect[2] + (+rect[0]); + rect[3] = +rect[3] + (+rect[1]); + var div = node.clipRect || R._g.doc.createElement("div"), + dstyle = div.style; + dstyle.clip = R.format("rect({1}px {2}px {3}px {0}px)", rect); + if (!node.clipRect) { + dstyle.position = "absolute"; + dstyle.top = 0; + dstyle.left = 0; + dstyle.width = o.paper.width + "px"; + dstyle.height = o.paper.height + "px"; + node.parentNode.insertBefore(div, node); + div.appendChild(node); + node.clipRect = div; + } + } + if (!params["clip-rect"]) { + node.clipRect && (node.clipRect.style.clip = "auto"); + } + } + if (o.textpath) { + var textpathStyle = o.textpath.style; + params.font && (textpathStyle.font = params.font); + params["font-family"] && (textpathStyle.fontFamily = '"' + params["font-family"].split(",")[0].replace(/^['"]+|['"]+$/g, E) + '"'); + params["font-size"] && (textpathStyle.fontSize = params["font-size"]); + params["font-weight"] && (textpathStyle.fontWeight = params["font-weight"]); + params["font-style"] && (textpathStyle.fontStyle = params["font-style"]); + } + if ("arrow-start" in params) { + addArrow(res, params["arrow-start"]); + } + if ("arrow-end" in params) { + addArrow(res, params["arrow-end"], 1); + } + if (params.opacity != null || + params["stroke-width"] != null || + params.fill != null || + params.src != null || + params.stroke != null || + params["stroke-width"] != null || + params["stroke-opacity"] != null || + params["fill-opacity"] != null || + params["stroke-dasharray"] != null || + params["stroke-miterlimit"] != null || + params["stroke-linejoin"] != null || + params["stroke-linecap"] != null) { + var fill = node.getElementsByTagName(fillString), + newfill = false; + fill = fill && fill[0]; + !fill && (newfill = fill = createNode(fillString)); + if (o.type == "image" && params.src) { + fill.src = params.src; + } + params.fill && (fill.on = true); + if (fill.on == null || params.fill == "none" || params.fill === null) { + fill.on = false; + } + if (fill.on && params.fill) { + var isURL = Str(params.fill).match(R._ISURL); + if (isURL) { + fill.parentNode == node && node.removeChild(fill); + fill.rotate = true; + fill.src = isURL[1]; + fill.type = "tile"; + var bbox = o.getBBox(1); + fill.position = bbox.x + S + bbox.y; + o._.fillpos = [bbox.x, bbox.y]; + + R._preload(isURL[1], function () { + o._.fillsize = [this.offsetWidth, this.offsetHeight]; + }); + } else { + fill.color = R.getRGB(params.fill).hex; + fill.src = E; + fill.type = "solid"; + if (R.getRGB(params.fill).error && (res.type in {circle: 1, ellipse: 1} || Str(params.fill).charAt() != "r") && addGradientFill(res, params.fill, fill)) { + a.fill = "none"; + a.gradient = params.fill; + fill.rotate = false; + } + } + } + if ("fill-opacity" in params || "opacity" in params) { + var opacity = ((+a["fill-opacity"] + 1 || 2) - 1) * ((+a.opacity + 1 || 2) - 1) * ((+R.getRGB(params.fill).o + 1 || 2) - 1); + opacity = mmin(mmax(opacity, 0), 1); + fill.opacity = opacity; + if (fill.src) { + fill.color = "none"; + } + } + node.appendChild(fill); + var stroke = (node.getElementsByTagName("stroke") && node.getElementsByTagName("stroke")[0]), + newstroke = false; + !stroke && (newstroke = stroke = createNode("stroke")); + if ((params.stroke && params.stroke != "none") || + params["stroke-width"] || + params["stroke-opacity"] != null || + params["stroke-dasharray"] || + params["stroke-miterlimit"] || + params["stroke-linejoin"] || + params["stroke-linecap"]) { + stroke.on = true; + } + (params.stroke == "none" || params.stroke === null || stroke.on == null || params.stroke == 0 || params["stroke-width"] == 0) && (stroke.on = false); + var strokeColor = R.getRGB(params.stroke); + stroke.on && params.stroke && (stroke.color = strokeColor.hex); + opacity = ((+a["stroke-opacity"] + 1 || 2) - 1) * ((+a.opacity + 1 || 2) - 1) * ((+strokeColor.o + 1 || 2) - 1); + var width = (toFloat(params["stroke-width"]) || 1) * .75; + opacity = mmin(mmax(opacity, 0), 1); + params["stroke-width"] == null && (width = a["stroke-width"]); + params["stroke-width"] && (stroke.weight = width); + width && width < 1 && (opacity *= width) && (stroke.weight = 1); + stroke.opacity = opacity; + + params["stroke-linejoin"] && (stroke.joinstyle = params["stroke-linejoin"] || "miter"); + stroke.miterlimit = params["stroke-miterlimit"] || 8; + params["stroke-linecap"] && (stroke.endcap = params["stroke-linecap"] == "butt" ? "flat" : params["stroke-linecap"] == "square" ? "square" : "round"); + if (params["stroke-dasharray"]) { + var dasharray = { + "-": "shortdash", + ".": "shortdot", + "-.": "shortdashdot", + "-..": "shortdashdotdot", + ". ": "dot", + "- ": "dash", + "--": "longdash", + "- .": "dashdot", + "--.": "longdashdot", + "--..": "longdashdotdot" + }; + stroke.dashstyle = dasharray[has](params["stroke-dasharray"]) ? dasharray[params["stroke-dasharray"]] : E; + } + newstroke && node.appendChild(stroke); + } + if (res.type == "text") { + res.paper.canvas.style.display = E; + var span = res.paper.span, + m = 100, + fontSize = a.font && a.font.match(/\d+(?:\.\d*)?(?=px)/); + s = span.style; + a.font && (s.font = a.font); + a["font-family"] && (s.fontFamily = a["font-family"]); + a["font-weight"] && (s.fontWeight = a["font-weight"]); + a["font-style"] && (s.fontStyle = a["font-style"]); + fontSize = toFloat(a["font-size"] || fontSize && fontSize[0]) || 10; + s.fontSize = fontSize * m + "px"; + res.textpath.string && (span.innerHTML = Str(res.textpath.string).replace(/")); + var brect = span.getBoundingClientRect(); + res.W = a.w = (brect.right - brect.left) / m; + res.H = a.h = (brect.bottom - brect.top) / m; + // res.paper.canvas.style.display = "none"; + res.X = a.x; + res.Y = a.y + res.H / 2; + + ("x" in params || "y" in params) && (res.path.v = R.format("m{0},{1}l{2},{1}", round(a.x * zoom), round(a.y * zoom), round(a.x * zoom) + 1)); + var dirtyattrs = ["x", "y", "text", "font", "font-family", "font-weight", "font-style", "font-size"]; + for (var d = 0, dd = dirtyattrs.length; d < dd; d++) if (dirtyattrs[d] in params) { + res._.dirty = 1; + break; + } + + // text-anchor emulation + switch (a["text-anchor"]) { + case "start": + res.textpath.style["v-text-align"] = "left"; + res.bbx = res.W / 2; + break; + case "end": + res.textpath.style["v-text-align"] = "right"; + res.bbx = -res.W / 2; + break; + default: + res.textpath.style["v-text-align"] = "center"; + res.bbx = 0; + break; + } + res.textpath.style["v-text-kern"] = true; + } + // res.paper.canvas.style.display = E; + }, + addGradientFill = function (o, gradient, fill) { + o.attrs = o.attrs || {}; + var attrs = o.attrs, + pow = Math.pow, + opacity, + oindex, + type = "linear", + fxfy = ".5 .5"; + o.attrs.gradient = gradient; + gradient = Str(gradient).replace(R._radial_gradient, function (all, fx, fy) { + type = "radial"; + if (fx && fy) { + fx = toFloat(fx); + fy = toFloat(fy); + pow(fx - .5, 2) + pow(fy - .5, 2) > .25 && (fy = math.sqrt(.25 - pow(fx - .5, 2)) * ((fy > .5) * 2 - 1) + .5); + fxfy = fx + S + fy; + } + return E; + }); + gradient = gradient.split(/\s*\-\s*/); + if (type == "linear") { + var angle = gradient.shift(); + angle = -toFloat(angle); + if (isNaN(angle)) { + return null; + } + } + var dots = R._parseDots(gradient); + if (!dots) { + return null; + } + o = o.shape || o.node; + if (dots.length) { + o.removeChild(fill); + fill.on = true; + fill.method = "none"; + fill.color = dots[0].color; + fill.color2 = dots[dots.length - 1].color; + var clrs = []; + for (var i = 0, ii = dots.length; i < ii; i++) { + dots[i].offset && clrs.push(dots[i].offset + S + dots[i].color); + } + fill.colors = clrs.length ? clrs.join() : "0% " + fill.color; + if (type == "radial") { + fill.type = "gradientTitle"; + fill.focus = "100%"; + fill.focussize = "0 0"; + fill.focusposition = fxfy; + fill.angle = 0; + } else { + // fill.rotate= true; + fill.type = "gradient"; + fill.angle = (270 - angle) % 360; + } + o.appendChild(fill); + } + return 1; + }, + Element = function (node, vml) { + this[0] = this.node = node; + node.raphael = true; + this.id = R._oid++; + node.raphaelid = this.id; + this.X = 0; + this.Y = 0; + this.attrs = {}; + this.paper = vml; + this.matrix = R.matrix(); + this._ = { + transform: [], + sx: 1, + sy: 1, + dx: 0, + dy: 0, + deg: 0, + dirty: 1, + dirtyT: 1 + }; + !vml.bottom && (vml.bottom = this); + this.prev = vml.top; + vml.top && (vml.top.next = this); + vml.top = this; + this.next = null; + }; + var elproto = R.el; + + Element.prototype = elproto; + elproto.constructor = Element; + elproto.transform = function (tstr) { + if (tstr == null) { + return this._.transform; + } + var vbs = this.paper._viewBoxShift, + vbt = vbs ? "s" + [vbs.scale, vbs.scale] + "-1-1t" + [vbs.dx, vbs.dy] : E, + oldt; + if (vbs) { + oldt = tstr = Str(tstr).replace(/\.{3}|\u2026/g, this._.transform || E); + } + R._extractTransform(this, vbt + tstr); + var matrix = this.matrix.clone(), + skew = this.skew, + o = this.node, + split, + isGrad = ~Str(this.attrs.fill).indexOf("-"), + isPatt = !Str(this.attrs.fill).indexOf("url("); + matrix.translate(-.5, -.5); + if (isPatt || isGrad || this.type == "image") { + skew.matrix = "1 0 0 1"; + skew.offset = "0 0"; + split = matrix.split(); + if ((isGrad && split.noRotation) || !split.isSimple) { + o.style.filter = matrix.toFilter(); + var bb = this.getBBox(), + bbt = this.getBBox(1), + dx = bb.x - bbt.x, + dy = bb.y - bbt.y; + o.coordorigin = (dx * -zoom) + S + (dy * -zoom); + setCoords(this, 1, 1, dx, dy, 0); + } else { + o.style.filter = E; + setCoords(this, split.scalex, split.scaley, split.dx, split.dy, split.rotate); + } + } else { + o.style.filter = E; + skew.matrix = Str(matrix); + skew.offset = matrix.offset(); + } + oldt && (this._.transform = oldt); + return this; + }; + elproto.rotate = function (deg, cx, cy) { + if (this.removed) { + return this; + } + if (deg == null) { + return; + } + deg = Str(deg).split(separator); + if (deg.length - 1) { + cx = toFloat(deg[1]); + cy = toFloat(deg[2]); + } + deg = toFloat(deg[0]); + (cy == null) && (cx = cy); + if (cx == null || cy == null) { + var bbox = this.getBBox(1); + cx = bbox.x + bbox.width / 2; + cy = bbox.y + bbox.height / 2; + } + this._.dirtyT = 1; + this.transform(this._.transform.concat([["r", deg, cx, cy]])); + return this; + }; + elproto.translate = function (dx, dy) { + if (this.removed) { + return this; + } + dx = Str(dx).split(separator); + if (dx.length - 1) { + dy = toFloat(dx[1]); + } + dx = toFloat(dx[0]) || 0; + dy = +dy || 0; + if (this._.bbox) { + this._.bbox.x += dx; + this._.bbox.y += dy; + } + this.transform(this._.transform.concat([["t", dx, dy]])); + return this; + }; + elproto.scale = function (sx, sy, cx, cy) { + if (this.removed) { + return this; + } + sx = Str(sx).split(separator); + if (sx.length - 1) { + sy = toFloat(sx[1]); + cx = toFloat(sx[2]); + cy = toFloat(sx[3]); + isNaN(cx) && (cx = null); + isNaN(cy) && (cy = null); + } + sx = toFloat(sx[0]); + (sy == null) && (sy = sx); + (cy == null) && (cx = cy); + if (cx == null || cy == null) { + var bbox = this.getBBox(1); + } + cx = cx == null ? bbox.x + bbox.width / 2 : cx; + cy = cy == null ? bbox.y + bbox.height / 2 : cy; + + this.transform(this._.transform.concat([["s", sx, sy, cx, cy]])); + this._.dirtyT = 1; + return this; + }; + elproto.hide = function () { + !this.removed && (this.node.style.display = "none"); + return this; + }; + elproto.show = function () { + !this.removed && (this.node.style.display = E); + return this; + }; + elproto._getBBox = function () { + if (this.removed) { + return {}; + } + return { + x: this.X + (this.bbx || 0) - this.W / 2, + y: this.Y - this.H, + width: this.W, + height: this.H + }; + }; + elproto.remove = function () { + if (this.removed) { + return; + } + this.paper.__set__ && this.paper.__set__.exclude(this); + R.eve.unbind("*.*." + this.id); + R._tear(this, this.paper); + this.node.parentNode.removeChild(this.node); + this.shape && this.shape.parentNode.removeChild(this.shape); + for (var i in this) { + this[i] = typeof this[i] == "function" ? R._removedFactory(i) : null; + } + this.removed = true; + }; + elproto.attr = function (name, value) { + if (this.removed) { + return this; + } + if (name == null) { + var res = {}; + for (var a in this.attrs) if (this.attrs[has](a)) { + res[a] = this.attrs[a]; + } + res.gradient && res.fill == "none" && (res.fill = res.gradient) && delete res.gradient; + res.transform = this._.transform; + return res; + } + if (value == null && R.is(name, "string")) { + if (name == fillString && this.attrs.fill == "none" && this.attrs.gradient) { + return this.attrs.gradient; + } + var names = name.split(separator), + out = {}; + for (var i = 0, ii = names.length; i < ii; i++) { + name = names[i]; + if (name in this.attrs) { + out[name] = this.attrs[name]; + } else if (R.is(this.paper.customAttributes[name], "function")) { + out[name] = this.paper.customAttributes[name].def; + } else { + out[name] = R._availableAttrs[name]; + } + } + return ii - 1 ? out : out[names[0]]; + } + if (this.attrs && value == null && R.is(name, "array")) { + out = {}; + for (i = 0, ii = name.length; i < ii; i++) { + out[name[i]] = this.attr(name[i]); + } + return out; + } + var params; + if (value != null) { + params = {}; + params[name] = value; + } + value == null && R.is(name, "object") && (params = name); + for (var key in params) { + eve("attr." + key + "." + this.id, this, params[key]); + } + if (params) { + for (key in this.paper.customAttributes) if (this.paper.customAttributes[has](key) && params[has](key) && R.is(this.paper.customAttributes[key], "function")) { + var par = this.paper.customAttributes[key].apply(this, [].concat(params[key])); + this.attrs[key] = params[key]; + for (var subkey in par) if (par[has](subkey)) { + params[subkey] = par[subkey]; + } + } + // this.paper.canvas.style.display = "none"; + if (params.text && this.type == "text") { + this.textpath.string = params.text; + } + setFillAndStroke(this, params); + // this.paper.canvas.style.display = E; + } + return this; + }; + elproto.toFront = function () { + !this.removed && this.node.parentNode.appendChild(this.node); + this.paper && this.paper.top != this && R._tofront(this, this.paper); + return this; + }; + elproto.toBack = function () { + if (this.removed) { + return this; + } + if (this.node.parentNode.firstChild != this.node) { + this.node.parentNode.insertBefore(this.node, this.node.parentNode.firstChild); + R._toback(this, this.paper); + } + return this; + }; + elproto.insertAfter = function (element) { + if (this.removed) { + return this; + } + if (element.constructor == R.st.constructor) { + element = element[element.length - 1]; + } + if (element.node.nextSibling) { + element.node.parentNode.insertBefore(this.node, element.node.nextSibling); + } else { + element.node.parentNode.appendChild(this.node); + } + R._insertafter(this, element, this.paper); + return this; + }; + elproto.insertBefore = function (element) { + if (this.removed) { + return this; + } + if (element.constructor == R.st.constructor) { + element = element[0]; + } + element.node.parentNode.insertBefore(this.node, element.node); + R._insertbefore(this, element, this.paper); + return this; + }; + elproto.blur = function (size) { + var s = this.node.runtimeStyle, + f = s.filter; + f = f.replace(blurregexp, E); + if (+size !== 0) { + this.attrs.blur = size; + s.filter = f + S + ms + ".Blur(pixelradius=" + (+size || 1.5) + ")"; + s.margin = R.format("-{0}px 0 0 -{0}px", round(+size || 1.5)); + } else { + s.filter = f; + s.margin = 0; + delete this.attrs.blur; + } + }; + + R._engine.path = function (pathString, vml) { + var el = createNode("shape"); + el.style.cssText = cssDot; + el.coordsize = zoom + S + zoom; + el.coordorigin = vml.coordorigin; + var p = new Element(el, vml), + attr = {fill: "none", stroke: "#000"}; + pathString && (attr.path = pathString); + p.type = "path"; + p.path = []; + p.Path = E; + setFillAndStroke(p, attr); + vml.canvas.appendChild(el); + var skew = createNode("skew"); + skew.on = true; + el.appendChild(skew); + p.skew = skew; + p.transform(E); + return p; + }; + R._engine.rect = function (vml, x, y, w, h, r) { + var path = R._rectPath(x, y, w, h, r), + res = vml.path(path), + a = res.attrs; + res.X = a.x = x; + res.Y = a.y = y; + res.W = a.width = w; + res.H = a.height = h; + a.r = r; + a.path = path; + res.type = "rect"; + return res; + }; + R._engine.ellipse = function (vml, x, y, rx, ry) { + var res = vml.path(), + a = res.attrs; + res.X = x - rx; + res.Y = y - ry; + res.W = rx * 2; + res.H = ry * 2; + res.type = "ellipse"; + setFillAndStroke(res, { + cx: x, + cy: y, + rx: rx, + ry: ry + }); + return res; + }; + R._engine.circle = function (vml, x, y, r) { + var res = vml.path(), + a = res.attrs; + res.X = x - r; + res.Y = y - r; + res.W = res.H = r * 2; + res.type = "circle"; + setFillAndStroke(res, { + cx: x, + cy: y, + r: r + }); + return res; + }; + R._engine.image = function (vml, src, x, y, w, h) { + var path = R._rectPath(x, y, w, h), + res = vml.path(path).attr({stroke: "none"}), + a = res.attrs, + node = res.node, + fill = node.getElementsByTagName(fillString)[0]; + a.src = src; + res.X = a.x = x; + res.Y = a.y = y; + res.W = a.width = w; + res.H = a.height = h; + a.path = path; + res.type = "image"; + fill.parentNode == node && node.removeChild(fill); + fill.rotate = true; + fill.src = src; + fill.type = "tile"; + res._.fillpos = [x, y]; + res._.fillsize = [w, h]; + node.appendChild(fill); + setCoords(res, 1, 1, 0, 0, 0); + return res; + }; + R._engine.text = function (vml, x, y, text) { + var el = createNode("shape"), + path = createNode("path"), + o = createNode("textpath"); + x = x || 0; + y = y || 0; + text = text || ""; + path.v = R.format("m{0},{1}l{2},{1}", round(x * zoom), round(y * zoom), round(x * zoom) + 1); + path.textpathok = true; + o.string = Str(text); + o.on = true; + el.style.cssText = cssDot; + el.coordsize = zoom + S + zoom; + el.coordorigin = "0 0"; + var p = new Element(el, vml), + attr = { + fill: "#000", + stroke: "none", + font: R._availableAttrs.font, + text: text + }; + p.shape = el; + p.path = path; + p.textpath = o; + p.type = "text"; + p.attrs.text = Str(text); + p.attrs.x = x; + p.attrs.y = y; + p.attrs.w = 1; + p.attrs.h = 1; + setFillAndStroke(p, attr); + el.appendChild(o); + el.appendChild(path); + vml.canvas.appendChild(el); + var skew = createNode("skew"); + skew.on = true; + el.appendChild(skew); + p.skew = skew; + p.transform(E); + return p; + }; + R._engine.setSize = function (width, height) { + var cs = this.canvas.style; + this.width = width; + this.height = height; + width == +width && (width += "px"); + height == +height && (height += "px"); + cs.width = width; + cs.height = height; + cs.clip = "rect(0 " + width + " " + height + " 0)"; + if (this._viewBox) { + R._engine.setViewBox.apply(this, this._viewBox); + } + return this; + }; + R._engine.setViewBox = function (x, y, w, h, fit) { + R.eve("setViewBox", this, this._viewBox, [x, y, w, h, fit]); + var width = this.width, + height = this.height, + size = 1 / mmax(w / width, h / height), + H, W; + if (fit) { + H = height / h; + W = width / w; + if (w * H < width) { + x -= (width - w * H) / 2 / H; + } + if (h * W < height) { + y -= (height - h * W) / 2 / W; + } + } + this._viewBox = [x, y, w, h, !!fit]; + this._viewBoxShift = { + dx: -x, + dy: -y, + scale: size + }; + this.forEach(function (el) { + el.transform("..."); + }); + return this; + }; + var createNode; + R._engine.initWin = function (win) { + var doc = win.document; + doc.createStyleSheet().addRule(".rvml", "behavior:url(#default#VML)"); + try { + !doc.namespaces.rvml && doc.namespaces.add("rvml", "urn:schemas-microsoft-com:vml"); + createNode = function (tagName) { + return doc.createElement(''); + }; + } catch (e) { + createNode = function (tagName) { + return doc.createElement('<' + tagName + ' xmlns="urn:schemas-microsoft.com:vml" class="rvml">'); + }; + } + }; + R._engine.initWin(R._g.win); + R._engine.create = function () { + var con = R._getContainer.apply(0, arguments), + container = con.container, + height = con.height, + s, + width = con.width, + x = con.x, + y = con.y; + if (!container) { + throw new Error("VML container not found."); + } + var res = new R._Paper, + c = res.canvas = R._g.doc.createElement("div"), + cs = c.style; + x = x || 0; + y = y || 0; + width = width || 512; + height = height || 342; + res.width = width; + res.height = height; + width == +width && (width += "px"); + height == +height && (height += "px"); + res.coordsize = zoom * 1e3 + S + zoom * 1e3; + res.coordorigin = "0 0"; + res.span = R._g.doc.createElement("span"); + res.span.style.cssText = "position:absolute;left:-9999em;top:-9999em;padding:0;margin:0;line-height:1;"; + c.appendChild(res.span); + cs.cssText = R.format("top:0;left:0;width:{0};height:{1};display:inline-block;position:relative;clip:rect(0 {0} {1} 0);overflow:hidden", width, height); + if (container == 1) { + R._g.doc.body.appendChild(c); + cs.left = x + "px"; + cs.top = y + "px"; + cs.position = "absolute"; + } else { + if (container.firstChild) { + container.insertBefore(c, container.firstChild); + } else { + container.appendChild(c); + } + } + // plugins.call(res, res, R.fn); + res.renderfix = function () {}; + return res; + }; + R.prototype.clear = function () { + R.eve("clear", this); + this.canvas.innerHTML = E; + this.span = R._g.doc.createElement("span"); + this.span.style.cssText = "position:absolute;left:-9999em;top:-9999em;padding:0;margin:0;line-height:1;display:inline;"; + this.canvas.appendChild(this.span); + this.bottom = this.top = null; + }; + R.prototype.remove = function () { + R.eve("remove", this); + this.canvas.parentNode.removeChild(this.canvas); + for (var i in this) { + this[i] = typeof this[i] == "function" ? R._removedFactory(i) : null; + } + return true; + }; + + var setproto = R.st; + for (var method in elproto) if (elproto[has](method) && !setproto[has](method)) { + setproto[method] = (function (methodname) { + return function () { + var arg = arguments; + return this.forEach(function (el) { + el[methodname].apply(el, arg); + }); + }; + })(method); + } +}(window.Raphael); \ No newline at end of file diff --git a/addons/web_diagram/static/src/js/vec2js/vec2.js b/addons/web_diagram/static/src/js/vec2js/vec2.js new file mode 100644 index 00000000000..6f9b6faa91f --- /dev/null +++ b/addons/web_diagram/static/src/js/vec2js/vec2.js @@ -0,0 +1,486 @@ + + + +(function(window){ + + // A Javascript 2D vector library + // conventions : + // method that returns a float value do not modify the vector + // method that implement operators are applied onto the calling vector eg: + // + // v1.add(v2); // v2 is added onto v1, v2 is modified, v1 is not + // + // but the parameters are never modified + // those methods also return the result so that the calls can be chained. + // method that implement operators are usually also available with a '_new' + // suffix. those method do not modify the calling vector and return the result + // as a new vector instead. + // + // v3 = v1.add_new(v2) // v3 is set to v1 + v2. v1 and v2 are not modified + // + // methods that take a single vector as a parameter are usually also available with + // q '_xy' suffix. Those method takes two floats representing the x,y coordinates of + // the vector parameter and allow you to avoid to needlessly create a vector object : + // + // v1.add(new Vec2(3,4)); + // v1.add_xy(3,4); //equivalent to previous line + // + // angles are in radians by default but method that takes angle as parameters + // or return angle values usually have a variant with a '_deg' suffix that works in degrees + // + + // The 2D vector object + function Vec2(x,y){ + this.x = x; + this.y = y; + } + + window.Vec2 = Vec2; + + // Multiply a number expressed in radiant by rad2deg to convert it in degrees + var rad2deg = 57.29577951308232; + // Multiply a number expressed in degrees by deg2rad to convert it to radiant + var deg2rad = 0.017453292519943295; + // The numerical precision used to compare vector equality + var epsilon = 0.0000001; + + // This static method creates a new vector from polar coordinates with the angle expressed + // in degrees + Vec2.new_polar_deg = function(len,angle){ + var v = new Vec2(len,0); + v.rotate_deg(angle); + return v; + }; + // This static method creates a new vector from polar coordinates with the angle expressed in + // radians + Vec2.new_polar = function(len,angle){ + var v = new Vec2(len,0); + v.rotate(angle); + return v; + }; + // returns the length or modulus or magnitude of the vector + Vec2.prototype.len = function(){ + return Math.sqrt(this.x*this.x + this.y*this.y); + }; + // returns the squared length of the vector, this method is much faster than len() + Vec2.prototype.len_sq = function(){ + return this.x*this.x + this.y*this.y; + }; + // return the distance between this vector and the vector v + Vec2.prototype.dist = function(v){ + var dx = this.x - v.x; + var dy = this.y - v.y; + return Math.sqrt(dx*dx + dy*dy); + }; + // return the distance between this vector and the vector of coordinates (x,y) + Vec2.prototype.dist_xy = function(x,y){ + var dx = this.x - x; + var dy = this.y - y; + return Math.sqrt(dx*dx + dy*dy); + }; + // return the squared distance between this vector and the vector and the vector v + Vec2.prototype.dist_sq = function(v){ + var dx = this.x - v.x; + var dy = this.y - v.y; + return dx*dx + dy*dy; + }; + // return the squared distance between this vector and the vector of coordinates (x,y) + Vec2.prototype.dist_sq_xy = function(x,y){ + var dx = this.x - x; + var dy = this.y - y; + return dx*dx + dy*dy; + }; + // return the dot product between this vector and the vector v + Vec2.prototype.dot = function(v){ + return this.x*v.x + this.y*v.y; + }; + // return the dot product between this vector and the vector of coordinate (x,y) + Vec2.prototype.dot_xy = function(x,y){ + return this.x*x + this.y*y; + }; + // return a new vector with the same coordinates as this + Vec2.prototype.clone = function(){ + return new Vec2(this.x,this.y); + }; + // sets the coordinate of this vector to (0,0) + Vec2.prototype.zero = function(){ + this.x = 0; + this.y = 0; + return this; + }; + // sets the coordinates of this to be equal to the coordinates of v + Vec2.prototype.set = function(v){ + this.x = v.x; + this.y = v.y; + return this; + }; + // sets the coordinate of this to be equal to the vector (x,y) + Vec2.prototype.set_xy = function(x,y){ + this.x = x; + this.y = y; + return this; + }; + // sets this to be the sum of this and vector v + Vec2.prototype.add = function(v){ + this.x += v.x; + this.y += v.y; + return this; + }; + // sets this to be the sum of this and the vector (x,y) + Vec2.prototype.add_xy = function(x,y){ + this.x += x; + this.y += y; + return this; + }; + // return the sum of this and vector v as a new vector + Vec2.prototype.add_new = function(v){ + return new Vec2(this.x+v.x,this.y+v.y); + }; + // return the sum of this and vector (x,y) as a new vector + Vec2.prototype.add_new_xy = function(x,y){ + return new Vec2(this.x+x,this.y+y); + }; + // sets this to be (this - v) where v is a vector and - is the vector substraction + Vec2.prototype.sub = function(v){ + this.x -= v.x; + this.y -= v.y; + return this; + }; + // sets this to be (this - (x,y)) where - is the vector substraction + Vec2.prototype.sub_xy = function(x,y){ + this.x -= x; + this.y -= y; + return this; + }; + // returns (this - v) as a new vector where v is a vector and - is the vector substraction + Vec2.prototype.sub_new = function(v){ + return new Vec2(this.x-v.x,this.y-v.y); + }; + // returns (this - (x,y)) as a new vector where - is vector substraction + Vec2.prototype.sub_new_xy = function(x,y){ + return new Vec2(this.x-x,this.y-y); + }; + // sets this to be (this * v) where v is a vector and * is the by component product and + Vec2.prototype.mult = function(v){ + this.x *= v.x; + this.y *= v.y; + return this; + }; + // sets this to be (this * (x,y) ) where v is a vector and * is the by component product + Vec2.prototype.mult_xy = function(x,y){ + this.x *= x; + this.y *= y; + return this; + }; + // return (this * v) as a new vector where v is a vector and * is the by component product + Vec2.prototype.mult_new = function(v){ + return new Vec2(this.x*v.x,this.y*v.y); + }; + // return (this * (x,y)) as a new vector where * is the by component product + Vec2.prototype.mult_new_xy = function(x,y){ + return new Vec2(this.x*x,this.y*y); + }; + // multiply all components of this vector by float f + Vec2.prototype.scale = function(f){ + this.x *= f; + this.y *= f; + return this; + }; + // return this scaled by float f as a new fector + Vec2.prototype.scale_new = function(f){ + return new Vec2(this.x*f, this.y*f); + }; + //sets this vector to be the negative of itself + Vec2.prototype.neg = function(f){ + this.x = -this.x; + this.y = -this.y; + return this; + }; + // return the negation of this vector + Vec2.prototype.neg_new = function(f){ + return new Vec2(-this.x,-this.y); + }; + // normalizes this vector + Vec2.prototype.normalize = function(){ + var len = this.len(); + if(len == 0){ + this.x = 1; + }else if(len != 1){ + this.scale(1.0/len); + } + return this; + }; + // return this vector normalized as a new vector + Vec2.prototype.normalize_new = function(){ + var len = this.len(); + if(len == 0){ + return new Vec2(0,1); + }else if(len != 1){ + return this.scale_new(1.0/len); + } + return new Vec2(this.x,this.y); + }; + // sets the length of this vector to float l without changing its angle. (negative values of l will invert direction) + Vec2.prototype.set_len = function(l){ + this.normalize(); + this.scale(l); + return this; + }; + // return a new vector with the same direction as this vector of length float l. (negative values of l will invert direction) + Vec2.prototype.set_len_new = function(l){ + var v = this.normalize_new(); + v.scale(l); + return v; + }; + // projects this vector onto the vector v + Vec2.prototype.project = function(v){ + var d = this.dot(v); + this.set(v); + this.normalize(); + this.scale(d); + return this; + }; + // return the projection of this onto the vector v as a new vector + Vec2.prototype.project_new = function(v){ + var vc = this.clone(); + vc.project(v); + return vc; + }; + // return a string representation of this vector + Vec2.prototype.toString = function(){ + var str = ""; + str += "["; + str += this.x; + str += ","; + str += this.y; + str += "]"; + return str; + }; + // rotate this vector counterclockwise by rad radians. + Vec2.prototype.rotate = function(rad){ + var c = Math.cos(rad); + var s = Math.sin(rad); + var px = this.x * c - this.y *s; + var py = this.x * s + this.y *c; + this.x = px; + this.y = py; + return this; + }; + //rotate this vector counterclockwise by deg degrees + Vec2.prototype.rotate_deg = function(deg){ + return this.rotate(deg * deg2rad); + }; + //return this vector counterclockwise rotated by rad radians as a new vector + Vec2.prototype.rotate_new = function(rad){ + var v = this.clone(); + return v.rotate(rad); + }; + //return this vector counterclockwise rotated by deg degrees as a new vector + Vec2.prototype.rotate_deg_new = function(deg){ + var v = this.clone(); + return v.rotate_deg(deg); + }; + //linearly interpolate this vector towards the vector v by float factor alpha. + // alpha == 0 : does nothing + // alpha == 1 : sets this to v + Vec2.prototype.lerp = function(v,alpha){ + var inv_alpha = 1 - alpha; + this.x = this.x * inv_alpha + v.x * alpha; + this.y = this.y * inv_alpha + v.y * alpha; + }; + // returns this vector lerped to v by alpha as a new vector + Vec2.prototype.lerp_new = function(v,alpha){ + var inv_alpha = 1 - alpha; + var v2 = new Vec2( this.x * inv_alpha + v.x * alpha, + this.y * inv_alpha + v.y * alpha ); + return v2; + + }; + // returns the angle between this vector and the vector (1,0) in radians + Vec2.prototype.angle = function(){ + return Math.atan2(this.y,this.x); + } + // returns the angle between this vector and the vector (1,0) in degrees + Vec2.prototype.angle_deg = function(){ + return Math.atan2(this.y,this.x) * rad2deg; + }; + // returns true if this vector is equal to the vector v, with a tolerance defined by the epsilon module constant + Vec2.prototype.equals = function(v){ + if(Math.abs(this.x-v.x) > epsilon){ + return false; + }else if(Math.abs(this.y-v.y) > epsilon){ + return false; + } + return true; + }; + // returns true if this vector is equal to the vector (x,y) with a tolerance defined by the epsilon module constant + Vec2.prototype.equals_xy = function(x,y){ + if(Math.abs(this.x-x) > epsilon){ + return false; + }else if(Math.abs(this.y-y) > epsilon){ + return false; + } + return true; + }; + console.log("vec2 module fully loaded"); +})(window); + +(function(window){ + // A Bounding Shapes Library + + + // A Bounding Ellipse + // cx,cy : center of the ellipse + // rx,ry : radius of the ellipse + function BEllipse(cx,cy,rx,ry){ + this.type = 'ellipse'; + this.x = cx-rx; // minimum x coordinate contained in the ellipse + this.y = cy-ry; // minimum y coordinate contained in the ellipse + this.sx = 2*rx; // width of the ellipse on the x axis + this.sy = 2*ry; // width of the ellipse on the y axis + this.hx = rx; // half of the ellipse width on the x axis + this.hy = ry; // half of the ellipse width on the y axis + this.cx = cx; // x coordinate of the ellipse center + this.cy = cy; // y coordinqte of the ellipse center + this.mx = cx + rx; // maximum x coordinate contained in the ellipse + this.my = cy + ry; // maximum x coordinate contained in the ellipse + } + window.BEllipse = BEllipse; + + // returns an unordered list of vector defining the positions of the intersections between the ellipse's + // boundary and a line segment defined by the start and end vectors a,b + BEllipse.prototype.collide_segment = function(a,b){ + // http://paulbourke.net/geometry/sphereline/ + collisions = [] + + if(a.equals(b)){ //we do not compute the intersection in this case. TODO ? + return collisions; + } + + // make all computations in a space where the ellipse is a circle + // centered on zero + var c = new Vec2(this.cx,this.cy); + a = a.sub_new(c).mult_xy(1/this.hx,1/this.hy); + b = b.sub_new(c).mult_xy(1/this.hx,1/this.hy); + + + if(a.len_sq() < 1 && b.len_sq() < 1){ //both points inside the ellipse + return collisions; + } + + // compute the roots of the intersection + var ab = b.sub_new(a); + var A = (ab.x*ab.x + ab.y*ab.y); + var B = 2*( ab.x*a.x + ab.y*a.y); + var C = a.x*a.x + a.y*a.y - 1; + var u = B * B - 4*A*C; + + if(u < 0){ + return collisions; + } + + u = Math.sqrt(u); + var u1 = (-B + u) / (2*A); + var u2 = (-B - u) / (2*A); + + if(u1 >= 0 && u1 <= 1){ + var pos = a.clone(); + pos.add(ab.scale_new(u1)); + collisions.push(pos); + } + if(u1 != u2 && u2 >= 0 && u2 <= 1){ + var pos = a.clone(); + pos.add(ab.scale_new(u2)); + collisions.push(pos); + } + for(var i = 0; i < collisions.length; i++){ + collisions[i].mult_xy(this.hx,this.hy); + collisions[i].add_xy(this.cx,this.cy); + } + return collisions; + }; + + // A bounding rectangle + // x,y the minimum coordinate contained in the rectangle + // sx,sy the size of the rectangle along the x,y axis + function BRect(x,y,sx,sy){ + this.type = 'rect'; + this.x = x; // minimum x coordinate contained in the rectangle + this.y = y; // minimum y coordinate contained in the rectangle + this.sx = sx; // width of the rectangle on the x axis + this.sy = sy; // width of the rectangle on the y axis + this.hx = sx/2; // half of the rectangle width on the x axis + this.hy = sy/2; // half of the rectangle width on the y axis + this.cx = x + this.hx; // x coordinate of the rectangle center + this.cy = y + this.hy; // y coordinate of the rectangle center + this.mx = x + sx; // maximum x coordinate contained in the rectangle + this.my = y + sy; // maximum x coordinate contained in the rectangle + } + + window.BRect = BRect; + // Static method creating a new bounding rectangle of size (sx,sy) centered on (cx,cy) + BRect.new_centered = function(cx,cy,sx,sy){ + return new BRect(cx-sx/2,cy-sy/2,sx,sy); + }; + //intersect line a,b with line c,d, returns null if no intersection + function line_intersect(a,b,c,d){ + // http://paulbourke.net/geometry/lineline2d/ + var f = ((d.y - c.y)*(b.x - a.x) - (d.x - c.x)*(b.y - a.y)); + if(f == 0){ + return null; + } + f = 1 / f; + var fab = ((d.x - c.x)*(a.y - c.y) - (d.y - c.y)*(a.x - c.x)) * f ; + if(fab < 0 || fab > 1){ + return null; + } + var fcd = ((b.x - a.x)*(a.y - c.y) - (b.y - a.y)*(a.x - c.x)) * f ; + if(fcd < 0 || fcd > 1){ + return null; + } + return new Vec2(a.x + fab * (b.x-a.x), a.y + fab * (b.y - a.y) ); + } + + // returns an unordered list of vector defining the positions of the intersections between the ellipse's + // boundary and a line segment defined by the start and end vectors a,b + + BRect.prototype.collide_segment = function(a,b){ + var collisions = [] + var corners = [ new Vec2(this.x,this.y), new Vec2(this.x,this.my), + new Vec2(this.mx,this.my), new Vec2(this.mx,this.y) ]; + var pos = line_intersect(a,b,corners[0],corners[1]); + if(pos) collisions.push(pos); + pos = line_intersect(a,b,corners[1],corners[2]); + if(pos) collisions.push(pos); + pos = line_intersect(a,b,corners[2],corners[3]); + if(pos) collisions.push(pos); + pos = line_intersect(a,b,corners[3],corners[0]); + if(pos) collisions.push(pos); + return collisions; + }; + + // returns true if the rectangle contains the position defined by the vector 'vec' + BRect.prototype.contains_vec = function(vec){ + return ( vec.x >= this.x && vec.x <= this.mx && + vec.y >= this.y && vec.y <= this.my ); + }; + // returns true if the rectangle contains the position (x,y) + BRect.prototype.contains_xy = function(x,y){ + return ( x >= this.x && x <= this.mx && + y >= this.y && y <= this.my ); + }; + // returns true if the ellipse contains the position defined by the vector 'vec' + BEllipse.prototype.contains_vec = function(v){ + v = v.mult_new_xy(this.hx,this.hy); + return v.len_sq() <= 1; + }; + // returns true if the ellipse contains the position (x,y) + BEllipse.prototype.contains_xy = function(x,y){ + return this.contains(new Vec2(x,y)); + }; + + console.log("bounds module fully loaded"); + +})(window); + + From a444a588cd75a3768643c794fc146c2fb938ada9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fr=C3=A9d=C3=A9ric=20van=20der=20Essen?= Date: Wed, 22 Feb 2012 10:56:32 +0100 Subject: [PATCH 002/196] removing useless console.log bzr revid: fva@openerp.com-20120222095632-i9m16yrrrci71km3 --- addons/web_diagram/static/src/js/graph.js | 1 - addons/web_diagram/static/src/js/vec2js/vec2.js | 2 -- 2 files changed, 3 deletions(-) diff --git a/addons/web_diagram/static/src/js/graph.js b/addons/web_diagram/static/src/js/graph.js index 5228d1a6d7a..11c29095a95 100644 --- a/addons/web_diagram/static/src/js/graph.js +++ b/addons/web_diagram/static/src/js/graph.js @@ -455,7 +455,6 @@ window.CuteGraph.wordwrap = wordwrap; - console.log("graph module fully loaded"); })(window); diff --git a/addons/web_diagram/static/src/js/vec2js/vec2.js b/addons/web_diagram/static/src/js/vec2js/vec2.js index 6f9b6faa91f..9572060e675 100644 --- a/addons/web_diagram/static/src/js/vec2js/vec2.js +++ b/addons/web_diagram/static/src/js/vec2js/vec2.js @@ -322,7 +322,6 @@ } return true; }; - console.log("vec2 module fully loaded"); })(window); (function(window){ @@ -479,7 +478,6 @@ return this.contains(new Vec2(x,y)); }; - console.log("bounds module fully loaded"); })(window); From 9af0dcc56df638ce79548f43cad88319a1dcc8a6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fr=C3=A9d=C3=A9ric=20van=20der=20Essen?= Date: Wed, 22 Feb 2012 15:00:47 +0100 Subject: [PATCH 003/196] Dropped the _new in vector lib, Node and edge creation/modification hookup with openerp bzr revid: fva@openerp.com-20120222140047-oqpj2axm35wswyei --- addons/web_diagram/static/src/js/diagram.js | 119 +++-------- addons/web_diagram/static/src/js/graph.js | 75 +++++-- .../web_diagram/static/src/js/vec2js/vec2.js | 187 +++--------------- 3 files changed, 122 insertions(+), 259 deletions(-) diff --git a/addons/web_diagram/static/src/js/diagram.js b/addons/web_diagram/static/src/js/diagram.js index cd360dcfafa..4e43960f206 100644 --- a/addons/web_diagram/static/src/js/diagram.js +++ b/addons/web_diagram/static/src/js/diagram.js @@ -111,34 +111,16 @@ openerp.web.DiagramView = openerp.web.View.extend({ this.get_diagram_info(); } }, - select_node: function (node, element) { - if (!this.selected_node) { - this.selected_node = node; - element.attr('stroke', 'red'); - return; - } - // Re-click selected node, deselect it - if (node.id === this.selected_node.id) { - this.selected_node = null; - element.attr('stroke', 'black'); - return; - } - this.add_edit_node(null, this.connector, { - act_from: this.selected_node.id, - act_to: node.id - }); - }, draw_diagram: function(result) { + var self = this; console.log(result); var res_nodes = result['nodes']; var res_edges = result['conn']; var id_to_node = {} - var edge_list = []; - var style = { "background" : 'url("grid.png")', - "edge" : "#A0A0A0", + var style = { "edge" : "#A0A0A0", "edge_label" : "#555", "text" : "#333", "outline" : "#000", @@ -148,89 +130,48 @@ openerp.web.DiagramView = openerp.web.View.extend({ "node_size_x" : 90, "node_size_y" : 60, "edge_spacing" : 100, - "edge_label_font_size" : 9 }; + "edge_label_font_size" : 10 }; + + $('#dia-canvas *').remove(); // remove previous diagram var r = new Raphael(document.getElementById("dia-canvas"), '100%','500px'); var graph = new CuteGraph(r,style); _.each(res_nodes, function(node) { - id_to_node[node.id] = new CuteNode( graph, - node.x, - node.y, - CuteGraph.wordwrap(node.name, 17), - node.shape === 'rectangle' ? 'rect' : 'circle', - node.color === 'white' ? style.white : style.gray ); - + var n = new CuteNode( graph, + node.x, + node.y, + CuteGraph.wordwrap(node.name, 17), + node.shape === 'rectangle' ? 'rect' : 'circle', + node.color === 'white' ? style.white : style.gray ); + n.id = node.id; + id_to_node[node.id] = n; }); _.each(res_edges, function(edge) { - edge_list.push( new CuteEdge( graph, + var e = new CuteEdge( graph, CuteGraph.wordwrap(edge.signal, 32), id_to_node[edge.s_id], - id_to_node[edge.d_id] )); + id_to_node[edge.d_id] ); + e.id = edge.id; }); - /* - //Custom logic - this.selected_node = null; - this.active_model = result['id_model']; - this.parent_field = result.parent_field; - var diagram = new Graph(); - var self = this; - var renderer = function(r, n) { - var shape = (n.node.shape === 'rectangle') ? 'rect' : 'ellipse'; + CuteNode.double_click_callback = function(cutenode){ + self.add_edit_node( cutenode.id, self.node ); + } - var node = r[shape](n.node.x, n.node.y).attr({ - "fill": n.node.color + CuteEdge.double_click_callback = function(cuteedge){ + self.add_edit_node(cuteedge.id,self.connector); + } + + CuteEdge.creation_callback = function(node_start, node_end){ + console.log("creating edge from:",node_start," to:",node_end); + self.add_edit_node(null, self.connector, { + act_from: node_start.id, + act_to: node_end.id }); - - var nodes = r.set(node, r.text(n.node.x, n.node.y, (n.label || n.id))) - .attr("cursor", "pointer") - .dblclick(function() { - self.add_edit_node(n.node.id, self.node); - }) - .mousedown(function () { node.moved = false; }) - .mousemove(function () { node.moved = true; }) - .click(function () { - // Ignore click from move event - if (node.moved) { return; } - self.select_node(n.node, node); - }); - - if (shape === 'rect') { - node.attr({width: "60", height: "44"}); - node.next.attr({"text-anchor": "middle", x: n.node.x + 20, y: n.node.y + 20}); - } else { - node.attr({rx: "40", ry: "20"}); - } - - return nodes; - }; - - _.each(res_nodes, function(res_node) { - diagram.addNode(res_node['name'],{node: res_node,render: renderer}); - }); - - // Id for Path(Edges) - var edge_ids = []; - - _.each(res_connectors, function(connector, index) { - edge_ids.push(index); - diagram.addEdge(connector['source'], connector['destination'], {directed : true, label: connector['signal']}); - }); - - self.$element.find('.diagram').empty(); - - var layouter = new Graph.Layout.Ordered(diagram); - var render_diagram = new Graph.Renderer.Raphael('dia-canvas', diagram, $('div#dia-canvas').width(), $('div#dia-canvas').height()); - - _.each(diagram.edges, function(edge, index) { - if(edge.connection) { - edge.connection.fg.attr({cursor: "pointer"}).dblclick(function() { - self.add_edit_node(edge_ids[index], self.connector); - }); - } - });*/ + return {label:""}; // TODO destroy edge on cancel + } }, add_edit_node: function(id, model, defaults) { diff --git a/addons/web_diagram/static/src/js/graph.js b/addons/web_diagram/static/src/js/graph.js index 11c29095a95..77a4d6c8e38 100644 --- a/addons/web_diagram/static/src/js/graph.js +++ b/addons/web_diagram/static/src/js/graph.js @@ -1,5 +1,6 @@ (function(window){ + // this serves as the end of an edge when creating a link @@ -61,7 +62,10 @@ graph.creating_edge = false; self.edge_tmp.remove(); if(graph.target_node && graph.target_node != node){ - new GraphEdge(graph,'new edge!', node,graph.target_node); + edge_prop = GraphEdge.creation_callback(node,graph.target_node); + if(edge_prop){ + new GraphEdge(graph,edge_prop.label, node,graph.target_node); + } } } conn_circle.drag(drag_move,drag_down,drag_up); @@ -289,7 +293,7 @@ for(var i = 0; i < edges.length; i++){ edges[i].label_disable(); } - set_pos(this.opos.add_new_xy(dx,dy)); + set_pos(this.opos.add_xy(dx,dy)); } var drag_up = function(){ //we re-enable the @@ -314,12 +318,22 @@ node_fig.hover(hover_in,hover_out); node_label.hover(hover_in,hover_out); + function double_click(){ + GraphNode.double_click_callback(self); + } + node_fig.dblclick(double_click); + node_label.dblclick(double_click); + this.connectors.push(new Connector(graph,this,-sx/2,0)); this.connectors.push(new Connector(graph,this,sx/2,0)); this.connectors.push(new Connector(graph,this,0,-sy/2)); this.connectors.push(new Connector(graph,this,0,sy/2)); } + GraphNode.double_click_callback = function(node){ + console.log("double click from node:",node); + } + // creates a new edge with label 'label' from start to end. start and end must implement get_pos_*, // if tmp is true, the edge is not added to the graph, used for drag edges. TODO pass graph in constructor, // replace tmp == false by graph == null @@ -329,6 +343,7 @@ var curvature = 0; // 0 = straight, != 0 curved var s,e; // positions of the start and end point of the line between start and end var mc; // position of the middle of the curve (bezier control point) + var mc1,mc2; // control points of the cubic bezier for the loop edges var elfs = graph.style.edge_label_font_size || 10 ; var label_enabled = true; this.uid = 0; // unique id used to order the curved edges @@ -342,7 +357,7 @@ var cpos = path.getTotalLength() * 0.5; var cindex = Math.abs(Math.floor(curvature)); var mod = ((cindex % 3)) * (elfs * 3.1) - (elfs * 0.5); - var verticality = Math.abs(end.get_pos().sub_new(start.get_pos()).normalize().dot_xy(0,1)); + var verticality = Math.abs(end.get_pos().sub(start.get_pos()).normalize().dot_xy(0,1)); verticality = Math.max(verticality-0.5,0)*2; var lpos = path.getPointAtLength(cpos + mod * verticality); @@ -358,12 +373,12 @@ } s = start.get_pos(); e = end.get_pos(); - mc = s.lerp_new(e,0.5); //middle of the line s->e - var se = e.sub_new(s); - se.normalize(); - se.rotate_deg(-90); - se.scale(curvature * graph.style.edge_spacing); - mc.add(se); + mc = s.lerp(e,0.5); //middle of the line s->e + var se = e.sub(s); + se = se.normalize(); + se = se.rotate_deg(-90); + se = se.scale(curvature * graph.style.edge_spacing); + mc = mc.add(se); if(start.get_bound){ var col = start.get_bound().collide_segment(s,mc); if(col.length > 0){ @@ -377,6 +392,14 @@ } } } + /* + function update_loop_pos(){ + s = start.get_pos(); + mc = s.add_new(Vec2.new_polar_deg(graph.style.edge_loop_radius,45*self.uid)); + var p = mc.normalize_new().rotate_deg(90); + mc1 = mc.add_new + */ + function make_line(){ return "M" + s.x + "," + s.y + "L" + e.x + "," + e.y ; @@ -431,12 +454,31 @@ edge_label.remove(); } + function double_click(){ + GraphEdge.double_click_callback(self); + } + edge.dblclick(double_click); + edge_label.dblclick(double_click); + this.label_enable = label_enable; this.label_disable = label_disable; this.update = update; this.remove = remove; - } + + GraphEdge.double_click_callback = function(edge){ + console.log("double click from edge:",edge); + } + + // this is the default edge creation callback. It is called before an edge is created + // It returns an object containing the properties of the edge. + // If it returns null, the edge is not created. + GraphEdge.creation_callback = function(start,end){ + var edge_prop = {}; + edge_prop.label = 'new edge!'; + return edge_prop; + } + // returns a new string with the same content as str, but with lines of maximum 'width' characters. // lines are broken on words, or into words if a word is longer than 'width' function wordwrap( str, width) { @@ -460,6 +502,7 @@ /* window.onload = function(){ + //Example var style = { "background" :'url("grid.png")', "edge" :"#A0A0A0", "edge_label" :"#555", @@ -470,15 +513,17 @@ window.onload = function(){ "white" :"#FFF", "node_size_x" : 110, "node_size_y" : 80, - "edge_spacing" : 100 }; + "edge_spacing" : 100, + "edge_label_font_size" : 10 + "edge_loop_radius": 50 }; var r = new Raphael(document.getElementById("canvas_container"),'100%','100%'); var g = new CuteGraph(r,style); - var n1 = new GraphNode(g,100,250,'Hello World','circle',colors.white); - var n2 = new GraphNode(g,400,250,'Hello Planet','rect',colors.white); - var n3 = new GraphNode(g,250,400,'Lonely Node','rect',colors.gray); - var e1 = new GraphEdge(g,'test',n1,n2); + var n1 = new CuteNode(g,100,250,'Hello World','circle',colors.white); + var n2 = new CuteNode(g,400,250,'Hello Planet','rect',colors.white); + var n3 = new CuteNode(g,250,400,'Lonely Node','rect',colors.gray); + var e1 = new CuteEdge(g,'test',n1,n2); }*/ diff --git a/addons/web_diagram/static/src/js/vec2js/vec2.js b/addons/web_diagram/static/src/js/vec2js/vec2.js index 9572060e675..e7c0371605b 100644 --- a/addons/web_diagram/static/src/js/vec2js/vec2.js +++ b/addons/web_diagram/static/src/js/vec2js/vec2.js @@ -6,24 +6,17 @@ // A Javascript 2D vector library // conventions : // method that returns a float value do not modify the vector - // method that implement operators are applied onto the calling vector eg: + // method that implement operators return a new vector with the modifications without + // modifying the calling vector or the parameters. // - // v1.add(v2); // v2 is added onto v1, v2 is modified, v1 is not - // - // but the parameters are never modified - // those methods also return the result so that the calls can be chained. - // method that implement operators are usually also available with a '_new' - // suffix. those method do not modify the calling vector and return the result - // as a new vector instead. - // - // v3 = v1.add_new(v2) // v3 is set to v1 + v2. v1 and v2 are not modified + // v3 = v1.add(v2); // v3 is set to v1 + v2, v1, v2 are not modified // // methods that take a single vector as a parameter are usually also available with // q '_xy' suffix. Those method takes two floats representing the x,y coordinates of // the vector parameter and allow you to avoid to needlessly create a vector object : // - // v1.add(new Vec2(3,4)); - // v1.add_xy(3,4); //equivalent to previous line + // v2 = v1.add(new Vec2(3,4)); + // v2 = v1.add_xy(3,4); //equivalent to previous line // // angles are in radians by default but method that takes angle as parameters // or return angle values usually have a variant with a '_deg' suffix that works in degrees @@ -102,149 +95,55 @@ Vec2.prototype.clone = function(){ return new Vec2(this.x,this.y); }; - // sets the coordinate of this vector to (0,0) - Vec2.prototype.zero = function(){ - this.x = 0; - this.y = 0; - return this; - }; - // sets the coordinates of this to be equal to the coordinates of v - Vec2.prototype.set = function(v){ - this.x = v.x; - this.y = v.y; - return this; - }; - // sets the coordinate of this to be equal to the vector (x,y) - Vec2.prototype.set_xy = function(x,y){ - this.x = x; - this.y = y; - return this; - }; - // sets this to be the sum of this and vector v - Vec2.prototype.add = function(v){ - this.x += v.x; - this.y += v.y; - return this; - }; - // sets this to be the sum of this and the vector (x,y) - Vec2.prototype.add_xy = function(x,y){ - this.x += x; - this.y += y; - return this; - }; // return the sum of this and vector v as a new vector - Vec2.prototype.add_new = function(v){ + Vec2.prototype.add = function(v){ return new Vec2(this.x+v.x,this.y+v.y); }; // return the sum of this and vector (x,y) as a new vector - Vec2.prototype.add_new_xy = function(x,y){ + Vec2.prototype.add_xy = function(x,y){ return new Vec2(this.x+x,this.y+y); }; - // sets this to be (this - v) where v is a vector and - is the vector substraction - Vec2.prototype.sub = function(v){ - this.x -= v.x; - this.y -= v.y; - return this; - }; - // sets this to be (this - (x,y)) where - is the vector substraction - Vec2.prototype.sub_xy = function(x,y){ - this.x -= x; - this.y -= y; - return this; - }; // returns (this - v) as a new vector where v is a vector and - is the vector substraction - Vec2.prototype.sub_new = function(v){ + Vec2.prototype.sub = function(v){ return new Vec2(this.x-v.x,this.y-v.y); }; // returns (this - (x,y)) as a new vector where - is vector substraction - Vec2.prototype.sub_new_xy = function(x,y){ + Vec2.prototype.sub_xy = function(x,y){ return new Vec2(this.x-x,this.y-y); }; - // sets this to be (this * v) where v is a vector and * is the by component product and - Vec2.prototype.mult = function(v){ - this.x *= v.x; - this.y *= v.y; - return this; - }; - // sets this to be (this * (x,y) ) where v is a vector and * is the by component product - Vec2.prototype.mult_xy = function(x,y){ - this.x *= x; - this.y *= y; - return this; - }; // return (this * v) as a new vector where v is a vector and * is the by component product - Vec2.prototype.mult_new = function(v){ + Vec2.prototype.mult = function(v){ return new Vec2(this.x*v.x,this.y*v.y); }; // return (this * (x,y)) as a new vector where * is the by component product - Vec2.prototype.mult_new_xy = function(x,y){ + Vec2.prototype.mult_xy = function(x,y){ return new Vec2(this.x*x,this.y*y); }; - // multiply all components of this vector by float f - Vec2.prototype.scale = function(f){ - this.x *= f; - this.y *= f; - return this; - }; // return this scaled by float f as a new fector - Vec2.prototype.scale_new = function(f){ + Vec2.prototype.scale = function(f){ return new Vec2(this.x*f, this.y*f); }; - //sets this vector to be the negative of itself - Vec2.prototype.neg = function(f){ - this.x = -this.x; - this.y = -this.y; - return this; - }; // return the negation of this vector - Vec2.prototype.neg_new = function(f){ + Vec2.prototype.neg = function(f){ return new Vec2(-this.x,-this.y); }; - // normalizes this vector - Vec2.prototype.normalize = function(){ - var len = this.len(); - if(len == 0){ - this.x = 1; - }else if(len != 1){ - this.scale(1.0/len); - } - return this; - }; // return this vector normalized as a new vector - Vec2.prototype.normalize_new = function(){ + Vec2.prototype.normalize = function(){ var len = this.len(); if(len == 0){ return new Vec2(0,1); }else if(len != 1){ - return this.scale_new(1.0/len); + return this.scale(1.0/len); } return new Vec2(this.x,this.y); }; - // sets the length of this vector to float l without changing its angle. (negative values of l will invert direction) - Vec2.prototype.set_len = function(l){ - this.normalize(); - this.scale(l); - return this; - }; // return a new vector with the same direction as this vector of length float l. (negative values of l will invert direction) - Vec2.prototype.set_len_new = function(l){ - var v = this.normalize_new(); - v.scale(l); - return v; - }; - // projects this vector onto the vector v - Vec2.prototype.project = function(v){ - var d = this.dot(v); - this.set(v); - this.normalize(); - this.scale(d); - return this; + Vec2.prototype.set_len = function(l){ + return this.normalize().scale(l); }; // return the projection of this onto the vector v as a new vector - Vec2.prototype.project_new = function(v){ - var vc = this.clone(); - vc.project(v); - return vc; + Vec2.prototype.project = function(v){ + return v.set_len(this.dot(v)); }; // return a string representation of this vector Vec2.prototype.toString = function(){ @@ -256,45 +155,25 @@ str += "]"; return str; }; - // rotate this vector counterclockwise by rad radians. + //return this vector counterclockwise rotated by rad radians as a new vector Vec2.prototype.rotate = function(rad){ var c = Math.cos(rad); var s = Math.sin(rad); var px = this.x * c - this.y *s; var py = this.x * s + this.y *c; - this.x = px; - this.y = py; - return this; - }; - //rotate this vector counterclockwise by deg degrees - Vec2.prototype.rotate_deg = function(deg){ - return this.rotate(deg * deg2rad); - }; - //return this vector counterclockwise rotated by rad radians as a new vector - Vec2.prototype.rotate_new = function(rad){ - var v = this.clone(); - return v.rotate(rad); + return new Vec2(px,py); }; //return this vector counterclockwise rotated by deg degrees as a new vector - Vec2.prototype.rotate_deg_new = function(deg){ - var v = this.clone(); - return v.rotate_deg(deg); + Vec2.prototype.rotate_deg = function(deg){ + return this.rotate(deg * deg2rad); }; //linearly interpolate this vector towards the vector v by float factor alpha. // alpha == 0 : does nothing // alpha == 1 : sets this to v Vec2.prototype.lerp = function(v,alpha){ var inv_alpha = 1 - alpha; - this.x = this.x * inv_alpha + v.x * alpha; - this.y = this.y * inv_alpha + v.y * alpha; - }; - // returns this vector lerped to v by alpha as a new vector - Vec2.prototype.lerp_new = function(v,alpha){ - var inv_alpha = 1 - alpha; - var v2 = new Vec2( this.x * inv_alpha + v.x * alpha, + return new Vec2( this.x * inv_alpha + v.x * alpha, this.y * inv_alpha + v.y * alpha ); - return v2; - }; // returns the angle between this vector and the vector (1,0) in radians Vec2.prototype.angle = function(){ @@ -359,8 +238,8 @@ // make all computations in a space where the ellipse is a circle // centered on zero var c = new Vec2(this.cx,this.cy); - a = a.sub_new(c).mult_xy(1/this.hx,1/this.hy); - b = b.sub_new(c).mult_xy(1/this.hx,1/this.hy); + a = a.sub(c).mult_xy(1/this.hx,1/this.hy); + b = b.sub(c).mult_xy(1/this.hx,1/this.hy); if(a.len_sq() < 1 && b.len_sq() < 1){ //both points inside the ellipse @@ -368,7 +247,7 @@ } // compute the roots of the intersection - var ab = b.sub_new(a); + var ab = b.sub(a); var A = (ab.x*ab.x + ab.y*ab.y); var B = 2*( ab.x*a.x + ab.y*a.y); var C = a.x*a.x + a.y*a.y - 1; @@ -383,18 +262,16 @@ var u2 = (-B - u) / (2*A); if(u1 >= 0 && u1 <= 1){ - var pos = a.clone(); - pos.add(ab.scale_new(u1)); + var pos = a.add(ab.scale(u1)); collisions.push(pos); } if(u1 != u2 && u2 >= 0 && u2 <= 1){ - var pos = a.clone(); - pos.add(ab.scale_new(u2)); + var pos = a.add(ab.scale(u2)); collisions.push(pos); } for(var i = 0; i < collisions.length; i++){ - collisions[i].mult_xy(this.hx,this.hy); - collisions[i].add_xy(this.cx,this.cy); + collisions[i] = collisions[i].mult_xy(this.hx,this.hy); + collisions[i] = collisions[i].add_xy(this.cx,this.cy); } return collisions; }; @@ -470,7 +347,7 @@ }; // returns true if the ellipse contains the position defined by the vector 'vec' BEllipse.prototype.contains_vec = function(v){ - v = v.mult_new_xy(this.hx,this.hy); + v = v.mult_xy(this.hx,this.hy); return v.len_sq() <= 1; }; // returns true if the ellipse contains the position (x,y) From 041ed706a52684a2bb0a48983dc18027627f1898 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fr=C3=A9d=C3=A9ric=20van=20der=20Essen?= Date: Wed, 22 Feb 2012 18:12:10 +0100 Subject: [PATCH 004/196] Edge loops are now supported bzr revid: fva@openerp.com-20120222171210-lr1me6hsedl0tsoo --- addons/web_diagram/static/src/js/diagram.js | 2 +- addons/web_diagram/static/src/js/graph.js | 183 +++++++++++++----- .../web_diagram/static/src/js/vec2js/vec2.js | 3 +- 3 files changed, 139 insertions(+), 49 deletions(-) diff --git a/addons/web_diagram/static/src/js/diagram.js b/addons/web_diagram/static/src/js/diagram.js index 4e43960f206..c53a802e3af 100644 --- a/addons/web_diagram/static/src/js/diagram.js +++ b/addons/web_diagram/static/src/js/diagram.js @@ -152,7 +152,7 @@ openerp.web.DiagramView = openerp.web.View.extend({ var e = new CuteEdge( graph, CuteGraph.wordwrap(edge.signal, 32), id_to_node[edge.s_id], - id_to_node[edge.d_id] ); + id_to_node[edge.d_id] || id_to_node[edge.s_id] ); //WORKAROUND e.id = edge.id; }); diff --git a/addons/web_diagram/static/src/js/graph.js b/addons/web_diagram/static/src/js/graph.js index 77a4d6c8e38..1ff6e1466c1 100644 --- a/addons/web_diagram/static/src/js/graph.js +++ b/addons/web_diagram/static/src/js/graph.js @@ -1,7 +1,5 @@ (function(window){ - - // this serves as the end of an edge when creating a link function EdgeEnd(pos_x,pos_y){ @@ -119,7 +117,9 @@ graph[n1.uid][n2.uid].push(e); links[n1.uid].push(e); - links[n2.uid].push(e); + if(n1 != n2){ + links[n2.uid].push(e); + } }; //return the list of edges from n1 to n2 this.get_edge_list = function(n1,n2){ @@ -155,6 +155,59 @@ } } }; + // Returns the angle in degrees of the edge loop. We do not support more than 8 loops on one node + this.get_loop_angle = function(n,e){ + var loop_list = this.get_edge_list(n,n); + var lc = loop_list.length; + + var slots = []; // the 8 angles where we can put the loops + for(var angle = 0; angle < 360; angle += 45){ + slots.push(Vec2.new_polar_deg(1,angle)); + } + + //we assign to each slot a score. The higher the score, the closer it is to other edges. + var links = this.get_linked_edge_list(n); + for(var i = 0; i < links.length; i++){ + var edge = links[i]; + if(!edge.is_loop || edge.is_loop()){ + continue; + } + var end = edge.get_end(); + if (end == n){ + end = edge.get_start(); + } + var dir = end.get_pos().sub(n.get_pos()).normalize(); + for(var s = 0; s < slots.length; s++){ + var score = slots[s].dot(dir); + if(score < 0){ + score = -0.2*Math.pow(score,2); + }else{ + score = Math.pow(score,2); + } + if(!slots[s].score){ + slots[s].score = score; + }else{ + slots[s].score += score; + } + } + } + //we want the loops with lower uid to get the slots with the lower score + slots.sort(function(a,b){ return a.score < b.score ? -1: 1; }); + + var index = 0; + for(var i = 0; i < links.length; i++){ + var edge = links[i]; + if(!edge.is_loop || !edge.is_loop()){ + continue; + } + if(edge.uid < e.uid){ + index++; + } + } + index = index % slots.length; + + return slots[index].angle_deg(); + } } // creates a new Graph Node on Raphael document r, centered on [pos_x,pos_y], with label 'label', @@ -338,6 +391,7 @@ // if tmp is true, the edge is not added to the graph, used for drag edges. TODO pass graph in constructor, // replace tmp == false by graph == null function GraphEdge(graph,label,start,end,tmp){ + var self = this; var r = graph.r; var update_time = -1; var curvature = 0; // 0 = straight, != 0 curved @@ -347,12 +401,13 @@ var elfs = graph.style.edge_label_font_size || 10 ; var label_enabled = true; this.uid = 0; // unique id used to order the curved edges - var self = this; + var edge_path = ""; // svg definition of the edge vector path if(!tmp){ graph.add_edge(start,end,this); } + //Return the position of the label function get_label_pos(path){ var cpos = path.getTotalLength() * 0.5; var cindex = Math.abs(Math.floor(curvature)); @@ -363,53 +418,85 @@ var lpos = path.getPointAtLength(cpos + mod * verticality); return new Vec2(lpos.x,lpos.y - elfs *(1-verticality)); } - - //computes new start and end line coordinates - function update_start_end_pos(){ - if(!tmp){ - curvature = graph.get_edge_curvature(start,end,self); - }else{ - curvature = 0; - } - s = start.get_pos(); - e = end.get_pos(); - mc = s.lerp(e,0.5); //middle of the line s->e - var se = e.sub(s); - se = se.normalize(); - se = se.rotate_deg(-90); - se = se.scale(curvature * graph.style.edge_spacing); - mc = mc.add(se); - if(start.get_bound){ - var col = start.get_bound().collide_segment(s,mc); - if(col.length > 0){ - s = col[0]; - } - } - if(end.get_bound){ - var col = end.get_bound().collide_segment(mc,e); - if(col.length > 0){ - e = col[0]; - } - } - } - /* - function update_loop_pos(){ - s = start.get_pos(); - mc = s.add_new(Vec2.new_polar_deg(graph.style.edge_loop_radius,45*self.uid)); - var p = mc.normalize_new().rotate_deg(90); - mc1 = mc.add_new - */ - - + + //Straight line from s to e function make_line(){ return "M" + s.x + "," + s.y + "L" + e.x + "," + e.y ; } + //Curved line from s to e by mc function make_curve(){ return "M" + s.x + "," + s.y + "Q" + mc.x + "," + mc.y + " " + e.x + "," + e.y; } + //Curved line from s to e by mc1 mc2 + function make_loop(){ + return "M" + s.x + " " + s.y + + "C" + mc1.x + " " + mc1.y + " " + mc2.x + " " + mc2.y + " " + e.x + " " + e.y; + } + + //computes new start and end line coordinates + function update_curve(){ + if(start != end){ + if(!tmp){ + curvature = graph.get_edge_curvature(start,end,self); + }else{ + curvature = 0; + } + s = start.get_pos(); + e = end.get_pos(); + + mc = s.lerp(e,0.5); //middle of the line s->e + var se = e.sub(s); + se = se.normalize(); + se = se.rotate_deg(-90); + se = se.scale(curvature * graph.style.edge_spacing); + mc = mc.add(se); - update_start_end_pos(); - var edge = r.path(make_curve()).attr({'stroke':graph.style.edge, 'stroke-width':2, 'arrow-end':'block-wide-long', 'cursor':'pointer'}).insertBefore(graph.get_node_list()[0].get_fig()); + if(start.get_bound){ + var col = start.get_bound().collide_segment(s,mc); + if(col.length > 0){ + s = col[0]; + } + } + if(end.get_bound){ + var col = end.get_bound().collide_segment(mc,e); + if(col.length > 0){ + e = col[0]; + } + } + + if(curvature != 0){ + edge_path = make_curve(); + }else{ + edge_path = make_line(); + } + }else{ // start == end + console.log("loop!"); + var rad = graph.style.edge_loop_radius || 100; + s = start.get_pos(); + e = end.get_pos(); + + var r = Vec2.new_polar_deg(rad,graph.get_loop_angle(start,self)); + mc = s.add(r); + p = r.rotate_deg(90); + mc1 = mc.add(p.set_len(rad*0.5)); + mc2 = mc.add(p.set_len(-rad*0.5)); + + if(start.get_bound){ + var col = start.get_bound().collide_segment(s,mc1); + if(col.length > 0){ + s = col[0]; + } + var col = start.get_bound().collide_segment(e,mc2); + if(col.length > 0){ + e = col[0]; + } + } + edge_path = make_loop(); + } + } + + update_curve(); + var edge = r.path(edge_path).attr({'stroke':graph.style.edge, 'stroke-width':2, 'arrow-end':'block-wide-long', 'cursor':'pointer'}).insertBefore(graph.get_node_list()[0].get_fig()); var labelpos = get_label_pos(edge); var edge_label = r.text(labelpos.x, labelpos.y - elfs, label).attr({'fill':graph.style.edge_label, 'cursor':'pointer', 'font-size':elfs}); @@ -441,8 +528,8 @@ } //update the positions function update(){ - update_start_end_pos(); - edge.attr({'path':make_curve()}); + update_curve(); + edge.attr({'path':edge_path}); if(label_enabled){ var labelpos = get_label_pos(edge); edge_label.attr({'x':labelpos.x, 'y':labelpos.y - 14}); @@ -460,10 +547,14 @@ edge.dblclick(double_click); edge_label.dblclick(double_click); + this.label_enable = label_enable; this.label_disable = label_disable; this.update = update; this.remove = remove; + this.is_loop = function(){ return start == end; }; + this.get_start = function(){ return start; }; + this.get_end = function(){ return end; }; } GraphEdge.double_click_callback = function(edge){ diff --git a/addons/web_diagram/static/src/js/vec2js/vec2.js b/addons/web_diagram/static/src/js/vec2js/vec2.js index e7c0371605b..c37b9674425 100644 --- a/addons/web_diagram/static/src/js/vec2js/vec2.js +++ b/addons/web_diagram/static/src/js/vec2js/vec2.js @@ -41,8 +41,7 @@ // in degrees Vec2.new_polar_deg = function(len,angle){ var v = new Vec2(len,0); - v.rotate_deg(angle); - return v; + return v.rotate_deg(angle); }; // This static method creates a new vector from polar coordinates with the angle expressed in // radians From 187b0d3532a468637915f3a1aa60a14e1024b459 Mon Sep 17 00:00:00 2001 From: "Turkesh Patel (Open ERP)" Date: Thu, 23 Feb 2012 15:16:26 +0530 Subject: [PATCH 005/196] [IMP] changes for sale configuration view bzr revid: tpa@tinyerp.com-20120223094626-7vt2ufe2qjeoudc2 --- addons/delivery/delivery.py | 36 +++---- addons/delivery/delivery_view.xml | 4 +- addons/sale/sale.py | 163 +++++++++++++++--------------- addons/sale/sale_view.xml | 29 +++--- 4 files changed, 116 insertions(+), 116 deletions(-) diff --git a/addons/delivery/delivery.py b/addons/delivery/delivery.py index 9f95a430f4e..cc2b66dd9e7 100644 --- a/addons/delivery/delivery.py +++ b/addons/delivery/delivery.py @@ -106,7 +106,7 @@ class delivery_carrier(osv.osv): # if using advanced pricing per destination: do not change if record.use_detailed_pricelist: continue - + # not using advanced pricing per destination: override grid grid_id = grid_pool.search(cr, uid, [('carrier_id', '=', record.id)], context=context) @@ -250,23 +250,23 @@ class delivery_grid_line(osv.osv): delivery_grid_line() -class define_delivery_steps(osv.osv_memory): - _name = 'delivery.define.delivery.steps.wizard' - - _columns = { - 'picking_policy' : fields.selection([('direct', 'Deliver each product when available'), ('one', 'Deliver all products at once')], 'Picking Policy'), - } - _defaults = { - 'picking_policy': lambda s,c,u,ctx: s.pool.get('sale.order').default_get(c,u,['picking_policy'],context=ctx)['picking_policy'] - } - - def apply_cb(self, cr, uid, ids, context=None): - ir_values_obj = self.pool.get('ir.values') - wizard = self.browse(cr, uid, ids, context=context)[0] - ir_values_obj.set(cr, uid, 'default', False, 'picking_policy', ['sale.order'], wizard.picking_policy) - return {'type' : 'ir.actions.act_window_close'} - -define_delivery_steps() +#class define_delivery_steps(osv.osv_memory): +# _name = 'delivery.define.delivery.steps.wizard' +# +# _columns = { +# 'picking_policy' : fields.selection([('direct', 'Deliver each product when available'), ('one', 'Deliver all products at once')], 'Picking Policy'), +# } +# _defaults = { +# 'picking_policy': lambda s,c,u,ctx: s.pool.get('sale.order').default_get(c,u,['picking_policy'],context=ctx)['picking_policy'] +# } +# +# def apply_cb(self, cr, uid, ids, context=None): +# ir_values_obj = self.pool.get('ir.values') +# wizard = self.browse(cr, uid, ids, context=context)[0] +# ir_values_obj.set(cr, uid, 'default', False, 'picking_policy', ['sale.order'], wizard.picking_policy) +# return {'type' : 'ir.actions.act_window_close'} +# +#define_delivery_steps() # vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4: diff --git a/addons/delivery/delivery_view.xml b/addons/delivery/delivery_view.xml index 1e47d815084..4928f77bc3e 100644 --- a/addons/delivery/delivery_view.xml +++ b/addons/delivery/delivery_view.xml @@ -337,7 +337,7 @@ 10 - + diff --git a/addons/sale/sale.py b/addons/sale/sale.py index 82bfda7b580..95d4e9762af 100644 --- a/addons/sale/sale.py +++ b/addons/sale/sale.py @@ -789,7 +789,7 @@ class sale_order(osv.osv): return True def _get_date_planned(self, cr, uid, order, line, start_date, context=None): - date_planned = datetime.strptime(start_date, DEFAULT_SERVER_DATE_FORMAT) + relativedelta(days=line.delay or 0.0) + date_planned = datetime.strptime(start_date, DEFAULT_SERVER_DATE_FORMAT) + relativedelta(days=line.delay or 0.0) date_planned = (date_planned - timedelta(days=order.company_id.security_lead)).strftime(DEFAULT_SERVER_DATETIME_FORMAT) return date_planned @@ -1331,94 +1331,93 @@ class sale_order_line(osv.osv): sale_order_line() class sale_config_picking_policy(osv.osv_memory): - _name = 'sale.config.picking_policy' - _inherit = 'res.config' + _inherit = 'sale.config.picking_policy' _columns = { - 'name': fields.char('Name', size=64), - 'sale_orders': fields.boolean('Based on Sales Orders',), - 'deli_orders': fields.boolean('Based on Delivery Orders'), - 'task_work': fields.boolean('Based on Tasks\' Work'), - 'timesheet': fields.boolean('Based on Timesheet'), - 'order_policy': fields.selection([ - ('manual', 'Invoice Based on Sales Orders'), - ('picking', 'Invoice Based on Deliveries'), - ], 'Main Method Based On', required=True, help="You can generate invoices based on sales orders or based on shippings."), - 'charge_delivery': fields.boolean('Do you charge the delivery?'), +# 'name': fields.char('Name', size=64), +# 'sale_orders': fields.boolean('Based on Sales Orders',), +# 'deli_orders': fields.boolean('Based on Delivery Orders'), +# 'task_work': fields.boolean('Based on Tasks\' Work'), +# 'timesheet': fields.boolean('Based on Timesheet'), +# 'order_policy': fields.selection([ +# ('manual', 'Invoice Based on Sales Orders'), +# ('picking', 'Invoice Based on Deliveries'), +# ], 'Main Method Based On', required=True, help="You can generate invoices based on sales orders or based on shippings."), +# 'charge_delivery': fields.boolean('Do you charge the delivery?'), 'time_unit': fields.many2one('product.uom','Main Working Time Unit') } _defaults = { - 'order_policy': 'manual', +# 'order_policy': 'manual', 'time_unit': lambda self, cr, uid, c: self.pool.get('product.uom').search(cr, uid, [('name', '=', _('Hour'))], context=c) and self.pool.get('product.uom').search(cr, uid, [('name', '=', _('Hour'))], context=c)[0] or False, } - - def onchange_order(self, cr, uid, ids, sale, deli, context=None): - res = {} - if sale: - res.update({'order_policy': 'manual'}) - elif deli: - res.update({'order_policy': 'picking'}) - return {'value':res} - - def execute(self, cr, uid, ids, context=None): - ir_values_obj = self.pool.get('ir.values') - data_obj = self.pool.get('ir.model.data') - menu_obj = self.pool.get('ir.ui.menu') - module_obj = self.pool.get('ir.module.module') - module_upgrade_obj = self.pool.get('base.module.upgrade') - module_name = [] - - group_id = data_obj.get_object(cr, uid, 'base', 'group_sale_salesman').id - - wizard = self.browse(cr, uid, ids)[0] - - if wizard.sale_orders: - menu_id = data_obj.get_object(cr, uid, 'sale', 'menu_invoicing_sales_order_lines').id - menu_obj.write(cr, uid, menu_id, {'groups_id':[(4,group_id)]}) - - if wizard.deli_orders: - menu_id = data_obj.get_object(cr, uid, 'sale', 'menu_action_picking_list_to_invoice').id - menu_obj.write(cr, uid, menu_id, {'groups_id':[(4,group_id)]}) - - if wizard.task_work: - module_name.append('project_timesheet') - module_name.append('project_mrp') - module_name.append('account_analytic_analysis') - - if wizard.timesheet: - module_name.append('account_analytic_analysis') - - if wizard.charge_delivery: - module_name.append('delivery') - - if len(module_name): - module_ids = [] - need_install = False - module_ids = [] - for module in module_name: - data_id = module_obj.name_search(cr, uid , module, [], '=') - module_ids.append(data_id[0][0]) - - for module in module_obj.browse(cr, uid, module_ids): - if module.state == 'uninstalled': - module_obj.state_update(cr, uid, [module.id], 'to install', ['uninstalled'], context) - need_install = True - cr.commit() - if need_install: - pooler.restart_pool(cr.dbname, update_module=True)[1] - - if wizard.time_unit: - prod_id = data_obj.get_object(cr, uid, 'product', 'product_consultant').id - product_obj = self.pool.get('product.product') - product_obj.write(cr, uid, prod_id, {'uom_id':wizard.time_unit.id, 'uom_po_id': wizard.time_unit.id}) - - ir_values_obj.set(cr, uid, 'default', False, 'order_policy', ['sale.order'], wizard.order_policy) - if wizard.task_work and wizard.time_unit: - company_id = self.pool.get('res.users').browse(cr, uid, uid).company_id.id - self.pool.get('res.company').write(cr, uid, [company_id], { - 'project_time_mode_id': wizard.time_unit.id - }, context=context) - +# +# def onchange_order(self, cr, uid, ids, sale, deli, context=None): +# res = {} +# if sale: +# res.update({'order_policy': 'manual'}) +# elif deli: +# res.update({'order_policy': 'picking'}) +# return {'value':res} +# +# def execute(self, cr, uid, ids, context=None): +# ir_values_obj = self.pool.get('ir.values') +# data_obj = self.pool.get('ir.model.data') +# menu_obj = self.pool.get('ir.ui.menu') +# module_obj = self.pool.get('ir.module.module') +# module_upgrade_obj = self.pool.get('base.module.upgrade') +# module_name = [] +# +# group_id = data_obj.get_object(cr, uid, 'base', 'group_sale_salesman').id +# +# wizard = self.browse(cr, uid, ids)[0] +# +# if wizard.sale_orders: +# menu_id = data_obj.get_object(cr, uid, 'sale', 'menu_invoicing_sales_order_lines').id +# menu_obj.write(cr, uid, menu_id, {'groups_id':[(4,group_id)]}) +# +# if wizard.deli_orders: +# menu_id = data_obj.get_object(cr, uid, 'sale', 'menu_action_picking_list_to_invoice').id +# menu_obj.write(cr, uid, menu_id, {'groups_id':[(4,group_id)]}) +# +# if wizard.task_work: +# module_name.append('project_timesheet') +# module_name.append('project_mrp') +# module_name.append('account_analytic_analysis') +# +# if wizard.timesheet: +# module_name.append('account_analytic_analysis') +# +# if wizard.charge_delivery: +# module_name.append('delivery') +# +# if len(module_name): +# module_ids = [] +# need_install = False +# module_ids = [] +# for module in module_name: +# data_id = module_obj.name_search(cr, uid , module, [], '=') +# module_ids.append(data_id[0][0]) +# +# for module in module_obj.browse(cr, uid, module_ids): +# if module.state == 'uninstalled': +# module_obj.state_update(cr, uid, [module.id], 'to install', ['uninstalled'], context) +# need_install = True +# cr.commit() +# if need_install: +# pooler.restart_pool(cr.dbname, update_module=True)[1] +# +# if wizard.time_unit: +# prod_id = data_obj.get_object(cr, uid, 'product', 'product_consultant').id +# product_obj = self.pool.get('product.product') +# product_obj.write(cr, uid, prod_id, {'uom_id':wizard.time_unit.id, 'uom_po_id': wizard.time_unit.id}) +# +# ir_values_obj.set(cr, uid, 'default', False, 'order_policy', ['sale.order'], wizard.order_policy) +# if wizard.task_work and wizard.time_unit: +# company_id = self.pool.get('res.users').browse(cr, uid, uid).company_id.id +# self.pool.get('res.company').write(cr, uid, [company_id], { +# 'project_time_mode_id': wizard.time_unit.id +# }, context=context) +# sale_config_picking_policy() # vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4: diff --git a/addons/sale/sale_view.xml b/addons/sale/sale_view.xml index 90d3838f5a0..4c7cadd6cdb 100644 --- a/addons/sale/sale_view.xml +++ b/addons/sale/sale_view.xml @@ -503,14 +503,14 @@ - + Setup Your Invoicing Method sale.config.picking_policy form - + - -
+ + + + + + + - + + once - + From 0be2e5e274227ff82c3c460b10fb569f513a88f5 Mon Sep 17 00:00:00 2001 From: "Ujjvala Collins (OpenERP)" Date: Thu, 23 Feb 2012 18:05:56 +0530 Subject: [PATCH 006/196] [IMP]: Improved as per specifications. bzr revid: uco@tinyerp.com-20120223123556-gnpo1bu9bpnzs3jc --- addons/sale/sale.py | 186 ++++++++++++++++++++++---------------- addons/sale/sale_view.xml | 113 ++++++++++++----------- 2 files changed, 164 insertions(+), 135 deletions(-) diff --git a/addons/sale/sale.py b/addons/sale/sale.py index 95d4e9762af..a0fe02dbffe 100644 --- a/addons/sale/sale.py +++ b/addons/sale/sale.py @@ -1334,90 +1334,116 @@ class sale_config_picking_policy(osv.osv_memory): _inherit = 'sale.config.picking_policy' _columns = { -# 'name': fields.char('Name', size=64), -# 'sale_orders': fields.boolean('Based on Sales Orders',), -# 'deli_orders': fields.boolean('Based on Delivery Orders'), -# 'task_work': fields.boolean('Based on Tasks\' Work'), -# 'timesheet': fields.boolean('Based on Timesheet'), -# 'order_policy': fields.selection([ -# ('manual', 'Invoice Based on Sales Orders'), -# ('picking', 'Invoice Based on Deliveries'), -# ], 'Main Method Based On', required=True, help="You can generate invoices based on sales orders or based on shippings."), -# 'charge_delivery': fields.boolean('Do you charge the delivery?'), - 'time_unit': fields.many2one('product.uom','Main Working Time Unit') + 'sale_orders': fields.boolean('Based on Sales Orders',), + 'deli_orders': fields.boolean('Based on Delivery Orders'), + 'task_work': fields.boolean('Based on Tasks\' Work'), + 'timesheet': fields.boolean('Based on Timesheet'), + 'order_policy': fields.selection([ + ('manual', 'Invoice Based on Sales Orders'), + ('picking', 'Invoice Based on Deliveries'), + ], 'Main Method Based On', required=True, help="You can generate invoices based on sales orders or based on shippings."), + 'charge_delivery': fields.boolean('Do you charge the delivery?'), + 'time_unit': fields.many2one('product.uom','Main Working Time Unit'), + 'picking_policy' : fields.boolean("Deliver all products at once?"), + 'group_sale_pricelist_per_customer':fields.boolean("Activate pricelist to manage prices per customer "), + 'group_sale_uom_per_product':fields.boolean("Allow different unit of measure per product"), + 'group_sale_delivery_address':fields.boolean(" Allow delivery address different from invoice address"), + 'group_sale_disc_per_sale_order_line':fields.boolean("Allow to apply discounts per sale order lines "), + 'group_sale_notes_subtotal':fields.boolean("Allow notes and subtotals"), + 'group_sale_alerts_per_customer_products':fields.boolean("Allow to define alerts by products or customers"), + 'tax_value' : fields.float('Value'), + 'tax_policy': fields.selection([ + ('no_tax', 'No Tax'), + ('global_on_order', 'Global On Order'), + ('on_order_line', 'On Order Lines'), + ], 'Taxes'), + 'sale_margin' : fields.boolean("Display Margin For Users"), + 'sale_journal' : fields.boolean("Invoice_journal?"), } + + def default_module_get(self, cr, uid, ids, context=None): + #TODO: Need to be implemented + return {} + _defaults = { -# 'order_policy': 'manual', + 'order_policy': 'manual', + 'tax_policy': 'no_tax', 'time_unit': lambda self, cr, uid, c: self.pool.get('product.uom').search(cr, uid, [('name', '=', _('Hour'))], context=c) and self.pool.get('product.uom').search(cr, uid, [('name', '=', _('Hour'))], context=c)[0] or False, + 'task_work': default_module_get, + 'timesheet': default_module_get, } -# -# def onchange_order(self, cr, uid, ids, sale, deli, context=None): -# res = {} -# if sale: -# res.update({'order_policy': 'manual'}) -# elif deli: -# res.update({'order_policy': 'picking'}) -# return {'value':res} -# -# def execute(self, cr, uid, ids, context=None): -# ir_values_obj = self.pool.get('ir.values') -# data_obj = self.pool.get('ir.model.data') -# menu_obj = self.pool.get('ir.ui.menu') -# module_obj = self.pool.get('ir.module.module') -# module_upgrade_obj = self.pool.get('base.module.upgrade') -# module_name = [] -# -# group_id = data_obj.get_object(cr, uid, 'base', 'group_sale_salesman').id -# -# wizard = self.browse(cr, uid, ids)[0] -# -# if wizard.sale_orders: -# menu_id = data_obj.get_object(cr, uid, 'sale', 'menu_invoicing_sales_order_lines').id -# menu_obj.write(cr, uid, menu_id, {'groups_id':[(4,group_id)]}) -# -# if wizard.deli_orders: -# menu_id = data_obj.get_object(cr, uid, 'sale', 'menu_action_picking_list_to_invoice').id -# menu_obj.write(cr, uid, menu_id, {'groups_id':[(4,group_id)]}) -# -# if wizard.task_work: -# module_name.append('project_timesheet') -# module_name.append('project_mrp') -# module_name.append('account_analytic_analysis') -# -# if wizard.timesheet: -# module_name.append('account_analytic_analysis') -# -# if wizard.charge_delivery: -# module_name.append('delivery') -# -# if len(module_name): -# module_ids = [] -# need_install = False -# module_ids = [] -# for module in module_name: -# data_id = module_obj.name_search(cr, uid , module, [], '=') -# module_ids.append(data_id[0][0]) -# -# for module in module_obj.browse(cr, uid, module_ids): -# if module.state == 'uninstalled': -# module_obj.state_update(cr, uid, [module.id], 'to install', ['uninstalled'], context) -# need_install = True -# cr.commit() -# if need_install: -# pooler.restart_pool(cr.dbname, update_module=True)[1] -# -# if wizard.time_unit: -# prod_id = data_obj.get_object(cr, uid, 'product', 'product_consultant').id -# product_obj = self.pool.get('product.product') -# product_obj.write(cr, uid, prod_id, {'uom_id':wizard.time_unit.id, 'uom_po_id': wizard.time_unit.id}) -# -# ir_values_obj.set(cr, uid, 'default', False, 'order_policy', ['sale.order'], wizard.order_policy) -# if wizard.task_work and wizard.time_unit: -# company_id = self.pool.get('res.users').browse(cr, uid, uid).company_id.id -# self.pool.get('res.company').write(cr, uid, [company_id], { -# 'project_time_mode_id': wizard.time_unit.id -# }, context=context) -# + + def onchange_order(self, cr, uid, ids, sale, deli, context=None): + res = {} + if sale: + res.update({'order_policy': 'manual'}) + elif deli: + res.update({'order_policy': 'picking'}) + return {'value':res} + + def write(self, cr, uid, ids, vals, context=None): + self.execute(cr, uid, ids, context=context) + return super(sale_config_picking_policy, self).write(cr, uid, ids, vals, context=context) + + def execute(self, cr, uid, ids, context=None): + ir_values_obj = self.pool.get('ir.values') + data_obj = self.pool.get('ir.model.data') + menu_obj = self.pool.get('ir.ui.menu') + module_obj = self.pool.get('ir.module.module') + module_upgrade_obj = self.pool.get('base.module.upgrade') + module_name = [] + + group_id = data_obj.get_object(cr, uid, 'base', 'group_sale_salesman').id + + wizard = self.browse(cr, uid, ids)[0] + + if wizard.sale_orders: + menu_id = data_obj.get_object(cr, uid, 'sale', 'menu_invoicing_sales_order_lines').id + menu_obj.write(cr, uid, menu_id, {'groups_id':[(4,group_id)]}) + + if wizard.deli_orders: + menu_id = data_obj.get_object(cr, uid, 'sale', 'menu_action_picking_list_to_invoice').id + menu_obj.write(cr, uid, menu_id, {'groups_id':[(4,group_id)]}) + + if wizard.task_work: + module_name.append('project_timesheet') + module_name.append('project_mrp') + module_name.append('account_analytic_analysis') + + if wizard.timesheet: + module_name.append('account_analytic_analysis') + + if wizard.charge_delivery: + module_name.append('delivery') + + if len(module_name): + module_ids = [] + need_install = False + module_ids = [] + for module in module_name: + data_id = module_obj.name_search(cr, uid , module, [], '=') + module_ids.append(data_id[0][0]) + + for module in module_obj.browse(cr, uid, module_ids): + if module.state == 'uninstalled': + module_obj.state_update(cr, uid, [module.id], 'to install', ['uninstalled'], context) + need_install = True + cr.commit() + if need_install: + pooler.restart_pool(cr.dbname, update_module=True)[1] + + if wizard.time_unit: + prod_id = data_obj.get_object(cr, uid, 'product', 'product_consultant').id + product_obj = self.pool.get('product.product') + product_obj.write(cr, uid, prod_id, {'uom_id':wizard.time_unit.id, 'uom_po_id': wizard.time_unit.id}) + + ir_values_obj.set(cr, uid, 'default', False, 'order_policy', ['sale.order'], wizard.order_policy) + if wizard.task_work and wizard.time_unit: + company_id = self.pool.get('res.users').browse(cr, uid, uid).company_id.id + self.pool.get('res.company').write(cr, uid, [company_id], { + 'project_time_mode_id': wizard.time_unit.id + }, context=context) + sale_config_picking_policy() # vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4: diff --git a/addons/sale/sale_view.xml b/addons/sale/sale_view.xml index 4c7cadd6cdb..b6b08732c9d 100644 --- a/addons/sale/sale_view.xml +++ b/addons/sale/sale_view.xml @@ -501,68 +501,71 @@ - + - - Setup Your Invoicing Method + + Configure Sales Applications sale.config.picking_policy form - + - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - From a5fba77a0d0ccf1ffe499f88d4e127c30b6ebbe3 Mon Sep 17 00:00:00 2001 From: "Ujjvala Collins (OpenERP)" Date: Fri, 24 Feb 2012 12:27:20 +0530 Subject: [PATCH 007/196] [IMP]: Improved code. bzr revid: uco@tinyerp.com-20120224065720-loj9rahg5mc7gmxc --- addons/sale/sale.py | 29 ++++++++++++++++++++++------- addons/sale/sale_view.xml | 12 ++++++------ 2 files changed, 28 insertions(+), 13 deletions(-) diff --git a/addons/sale/sale.py b/addons/sale/sale.py index a0fe02dbffe..f5c39c6a15a 100644 --- a/addons/sale/sale.py +++ b/addons/sale/sale.py @@ -1330,8 +1330,8 @@ class sale_order_line(osv.osv): sale_order_line() -class sale_config_picking_policy(osv.osv_memory): - _inherit = 'sale.config.picking_policy' +class sale_configuration(osv.osv_memory): + _inherit = 'sale.configuration' _columns = { 'sale_orders': fields.boolean('Based on Sales Orders',), @@ -1360,10 +1360,21 @@ class sale_config_picking_policy(osv.osv_memory): 'sale_margin' : fields.boolean("Display Margin For Users"), 'sale_journal' : fields.boolean("Invoice_journal?"), } - - def default_module_get(self, cr, uid, ids, context=None): + + def default_module_get(self, cr, uid, ids, selectable=[], context=None): #TODO: Need to be implemented - return {} + selectable = ['project_timesheet','project_mrp','account_analytic_analysis','delivery','sale_margin','sale_journal'] + res = super(sale_configuration, self).default_module_get(cr, uid, ids, selectable=selectable, context=context) + for k in res.keys(): + if k in ['project_timesheet','project_mrp','account_analytic_analysis']: + res.update({'task_work': True}) + if k in ['account_analytic_analysis']: + res.update({'timesheet': True}) + if k == 'delivery': + res.update({'sale_orders': True, 'deli_orders': True}) + else: + res.update({k: False}) + return res _defaults = { 'order_policy': 'manual', @@ -1371,6 +1382,10 @@ class sale_config_picking_policy(osv.osv_memory): 'time_unit': lambda self, cr, uid, c: self.pool.get('product.uom').search(cr, uid, [('name', '=', _('Hour'))], context=c) and self.pool.get('product.uom').search(cr, uid, [('name', '=', _('Hour'))], context=c)[0] or False, 'task_work': default_module_get, 'timesheet': default_module_get, + 'sale_orders': default_module_get, + 'deli_orders': default_module_get, + 'sale_margin' : default_module_get, + 'sale_journal': default_module_get, } def onchange_order(self, cr, uid, ids, sale, deli, context=None): @@ -1383,7 +1398,7 @@ class sale_config_picking_policy(osv.osv_memory): def write(self, cr, uid, ids, vals, context=None): self.execute(cr, uid, ids, context=context) - return super(sale_config_picking_policy, self).write(cr, uid, ids, vals, context=context) + return super(sale_configuration, self).write(cr, uid, ids, vals, context=context) def execute(self, cr, uid, ids, context=None): ir_values_obj = self.pool.get('ir.values') @@ -1444,6 +1459,6 @@ class sale_config_picking_policy(osv.osv_memory): 'project_time_mode_id': wizard.time_unit.id }, context=context) -sale_config_picking_policy() +sale_configuration() # vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4: diff --git a/addons/sale/sale_view.xml b/addons/sale/sale_view.xml index b6b08732c9d..c87a3e38601 100644 --- a/addons/sale/sale_view.xml +++ b/addons/sale/sale_view.xml @@ -504,8 +504,8 @@ - Configure Sales Applications - sale.config.picking_policy + Configure Sales Application + sale.configuration form @@ -524,13 +524,13 @@ - + - + - + - + From c31cea585bce1965c04e45738fe949cb509b6452 Mon Sep 17 00:00:00 2001 From: "Turkesh Patel (Open ERP)" Date: Fri, 24 Feb 2012 14:38:47 +0530 Subject: [PATCH 008/196] [ADD] add the new usability groups in sales bzr revid: tpa@tinyerp.com-20120224090847-f8v7cg22xxmain4b --- addons/sale/sale.py | 6 ++-- addons/sale/sale_view.xml | 40 +++++++++++++------------- addons/sale/security/sale_security.xml | 30 +++++++++++++++++++ 3 files changed, 53 insertions(+), 23 deletions(-) diff --git a/addons/sale/sale.py b/addons/sale/sale.py index f5c39c6a15a..1036f383db0 100644 --- a/addons/sale/sale.py +++ b/addons/sale/sale.py @@ -1350,7 +1350,7 @@ class sale_configuration(osv.osv_memory): 'group_sale_delivery_address':fields.boolean(" Allow delivery address different from invoice address"), 'group_sale_disc_per_sale_order_line':fields.boolean("Allow to apply discounts per sale order lines "), 'group_sale_notes_subtotal':fields.boolean("Allow notes and subtotals"), - 'group_sale_alerts_per_customer_products':fields.boolean("Allow to define alerts by products or customers"), + 'warning':fields.boolean("Allow to define alerts by products or customers"), 'tax_value' : fields.float('Value'), 'tax_policy': fields.selection([ ('no_tax', 'No Tax'), @@ -1375,7 +1375,7 @@ class sale_configuration(osv.osv_memory): else: res.update({k: False}) return res - + _defaults = { 'order_policy': 'manual', 'tax_policy': 'no_tax', @@ -1395,7 +1395,7 @@ class sale_configuration(osv.osv_memory): elif deli: res.update({'order_policy': 'picking'}) return {'value':res} - + def write(self, cr, uid, ids, vals, context=None): self.execute(cr, uid, ids, context=context) return super(sale_configuration, self).write(cr, uid, ids, vals, context=context) diff --git a/addons/sale/sale_view.xml b/addons/sale/sale_view.xml index c87a3e38601..dee42ec3c93 100644 --- a/addons/sale/sale_view.xml +++ b/addons/sale/sale_view.xml @@ -117,9 +117,9 @@ - - - + + + @@ -139,7 +139,7 @@ on_change="product_id_change(parent.pricelist_id,product_id,product_uom_qty,product_uom,product_uos_qty,product_uos,name,parent.partner_id, False, False, parent.date_order, product_packaging, parent.fiscal_position, True, context)"/> + nolabel="1" groups="base.group_sale_uom_per_product"/> @@ -149,9 +149,9 @@ context="{'partner_id':parent.partner_id, 'quantity':product_uom_qty, 'pricelist':parent.pricelist_id, 'shop':parent.shop_id, 'uom':product_uom}" on_change="product_packaging_change(parent.pricelist_id, product_id, product_uom_qty, product_uom, parent.partner_id, product_packaging, True, context)" domain="[('product_id','=',product_id)]" groups="base.group_extended" colspan="3"/> - - - + + + @@ -183,12 +183,12 @@ - + - + - + @@ -240,8 +240,8 @@ - - + + @@ -361,9 +361,9 @@ - + - + @@ -382,7 +382,7 @@ - + @@ -390,11 +390,11 @@ - - + + - - + + @@ -533,7 +533,7 @@ - + diff --git a/addons/sale/security/sale_security.xml b/addons/sale/security/sale_security.xml index ae8c8bf62e3..8dbc9c1385b 100644 --- a/addons/sale/security/sale_security.xml +++ b/addons/sale/security/sale_security.xml @@ -20,6 +20,36 @@ + + Selse Pricelist + + + + + Product UOM + + + + + Addresses in sales order + + + + + Discounts per sale order lines + + + + + Notes and subtotals + + + + + Sales Taxes Global/on line + + + From 87f65775e00404063104486954eefe2b649e93f3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fr=C3=A9d=C3=A9ric=20van=20der=20Essen?= Date: Fri, 24 Feb 2012 10:53:10 +0100 Subject: [PATCH 009/196] Correct viewport integration, cosmetic changes, node loops bzr revid: fva@openerp.com-20120224095310-r3bdlx09n5eaxrvk --- addons/web/static/src/js/view_form.js | 4 + addons/web_diagram/__openerp__.py | 3 +- .../static/src/css/base_diagram.css | 46 +++++----- addons/web_diagram/static/src/js/diagram.js | 25 ++++-- addons/web_diagram/static/src/js/graph.js | 84 ++++++++++++++++--- .../static/src/js/jquery.mousewheel.js | 84 +++++++++++++++++++ .../web_diagram/static/src/js/vec2js/vec2.js | 2 - .../static/src/xml/base_diagram.xml | 4 +- 8 files changed, 205 insertions(+), 47 deletions(-) create mode 100644 addons/web_diagram/static/src/js/jquery.mousewheel.js diff --git a/addons/web/static/src/js/view_form.js b/addons/web/static/src/js/view_form.js index 6b7acd5a244..d98c597c8a6 100644 --- a/addons/web/static/src/js/view_form.js +++ b/addons/web/static/src/js/view_form.js @@ -2835,6 +2835,10 @@ openerp.web.form.SelectCreatePopup = openerp.web.OldWidget.extend(/** @lends ope this.new_object(); } }, + stop: function () { + this.$element.dialog('close'); + this._super(); + }, setup_search_view: function(search_defaults) { var self = this; if (this.searchview) { diff --git a/addons/web_diagram/__openerp__.py b/addons/web_diagram/__openerp__.py index 0aae81eb946..22f061c6475 100644 --- a/addons/web_diagram/__openerp__.py +++ b/addons/web_diagram/__openerp__.py @@ -9,9 +9,10 @@ 'static/lib/js/dracula_graffle.js', 'static/lib/js/dracula_graph.js', 'static/lib/js/dracula_algorithms.js', + 'static/src/js/jquery.mousewheel.js', 'static/src/js/vec2js/vec2.js', 'static/src/js/graph.js', - 'static/src/js/diagram.js' + 'static/src/js/diagram.js', ], 'css' : [ "static/src/css/base_diagram.css", diff --git a/addons/web_diagram/static/src/css/base_diagram.css b/addons/web_diagram/static/src/css/base_diagram.css index 6be8d4873d2..9604823d040 100644 --- a/addons/web_diagram/static/src/css/base_diagram.css +++ b/addons/web_diagram/static/src/css/base_diagram.css @@ -1,35 +1,33 @@ .openerp .oe_diagram_pager { - text-align: right; + float:right; + /*text-align: right;*/ white-space: nowrap; } .openerp .oe_diagram_buttons { float: left; } +.openerp .clear{ + clear:both; +} +.openerp .diagram{ + margin:0; + padding:0; + position:absolute; + top:178px; + bottom:26px; + left:201px; + right:0; + background-color:white; + border-style:none; + border-top-style:solid; + border-top-width:1px; + border-top-color:#DCDCDC; + overflow:hidden; -/*.openerp .dhx_canvas_text { - padding:30px 0 0 10px; - -webkit-transform: rotate(60deg); - -moz-transform: rotate(60deg); - -o-transform: rotate(60deg); - -ms-transform: rotate(60deg); - transform: rotate(60deg); +} +#widget-19_view_diagram { + position:relative; } -.openerp .dhx_canvas_text.dhx_axis_item_y, .openerp .dhx_canvas_text.dhx_axis_title_x { - padding: 0px; - -webkit-transform: rotate(0deg); - -moz-transform: rotate(0deg); - -o-transform: rotate(0deg); - -ms-transform: rotate(0deg); - transform: rotate(0deg); -} -.openerp .dhx_canvas_text.dhx_axis_title_y { - padding: 0; - -webkit-transform: rotate(270deg); - -moz-transform: rotate(270deg); - -o-transform: rotate(270deg); - -ms-transform: rotate(270deg); - transform: rotate(270deg); -} */ diff --git a/addons/web_diagram/static/src/js/diagram.js b/addons/web_diagram/static/src/js/diagram.js index c53a802e3af..eee6f23afe2 100644 --- a/addons/web_diagram/static/src/js/diagram.js +++ b/addons/web_diagram/static/src/js/diagram.js @@ -123,25 +123,27 @@ openerp.web.DiagramView = openerp.web.View.extend({ var style = { "edge" : "#A0A0A0", "edge_label" : "#555", "text" : "#333", - "outline" : "#000", + "outline" : "#333", "selected" : "#0097BE", "gray" : "#DCDCDC", "white" : "#FFF", - "node_size_x" : 90, - "node_size_y" : 60, + "node_size_x" : 100, + "node_size_y" : 70, "edge_spacing" : 100, "edge_label_font_size" : 10 }; $('#dia-canvas *').remove(); // remove previous diagram - var r = new Raphael(document.getElementById("dia-canvas"), '100%','500px'); + var r = new Raphael(document.getElementById("dia-canvas"), '100%','100%'); + $(r.node).css("border","none"); + $(r.node).css("padding",0); var graph = new CuteGraph(r,style); _.each(res_nodes, function(node) { var n = new CuteNode( graph, - node.x, - node.y, - CuteGraph.wordwrap(node.name, 17), + node.x + 50, + node.y + 50, + CuteGraph.wordwrap(node.name, 16), node.shape === 'rectangle' ? 'rect' : 'circle', node.color === 'white' ? style.white : style.gray ); n.id = node.id; @@ -168,7 +170,9 @@ openerp.web.DiagramView = openerp.web.View.extend({ console.log("creating edge from:",node_start," to:",node_end); self.add_edit_node(null, self.connector, { act_from: node_start.id, - act_to: node_end.id + act_to: node_end.id, + activity_from_id: node_start.id, + activity_to_id: node_end.id, }); return {label:""}; // TODO destroy edge on cancel } @@ -200,6 +204,10 @@ openerp.web.DiagramView = openerp.web.View.extend({ pop.on_select_elements.add_last(function(element_ids) { self.dataset.read_index(_.keys(self.fields_view.fields)).pipe(self.on_diagram_loaded); }); + pop.$element.bind("dialogbeforeclose",function(){ + console.log("HAHHAAH"); + console.log(self.connectors.attrs); + }); } else { pop = new openerp.web.form.FormOpenPopup(this); pop.show_element( @@ -213,6 +221,7 @@ openerp.web.DiagramView = openerp.web.View.extend({ pop.on_write.add(function() { self.dataset.read_index(_.keys(self.fields_view.fields)).pipe(self.on_diagram_loaded); }); + } var form_controller = pop.view_form; diff --git a/addons/web_diagram/static/src/js/graph.js b/addons/web_diagram/static/src/js/graph.js index 1ff6e1466c1..1bae1cd3b9e 100644 --- a/addons/web_diagram/static/src/js/graph.js +++ b/addons/web_diagram/static/src/js/graph.js @@ -16,6 +16,7 @@ var visible = false; var conn_circle = graph.r.circle(node.get_pos().x + pos_x, node.get_pos().y + pos_y,4); conn_circle.attr({'opacity':0, 'fill':graph.style.outline,'stroke':'none'}); + conn_circle.transform(graph.get_transform()); var self = this; this.update_pos = function(){ @@ -59,7 +60,7 @@ if(!visible){ return; } graph.creating_edge = false; self.edge_tmp.remove(); - if(graph.target_node && graph.target_node != node){ + if(graph.target_node){ edge_prop = GraphEdge.creation_callback(node,graph.target_node); if(edge_prop){ new GraphEdge(graph,edge_prop.label, node,graph.target_node); @@ -80,22 +81,65 @@ visible = false; } } - this.show = show; this.hide = hide; } function Graph(r,style){ + var self = this; var nodes = []; // list of all nodes in the graph var edges = []; // list of all edges in the graph var graph = {}; // graph[n1.uid][n2.uid] -> list of all edges from n1 to n2 var links = {} // links[n.uid] -> list of all edges from or to n var uid = 1; // all nodes and edges have an uid used to order their display when they are curved - this.creating_edge = false; // true if we are dragging a new edge onto a node - this.target_node = null; // this holds the target node when creating an edge and hovering a connector - this.r = r; // the raphael instance - this.style = style; // definition of the colors, spacing, fonts, ... used by the elements + self.creating_edge = false; // true if we are dragging a new edge onto a node + self.target_node = null; // this holds the target node when creating an edge and hovering a connector + self.r = r; // the raphael instance + self.style = style; // definition of the colors, spacing, fonts, ... used by the elements + var tr_x = 0, tr_y = 0; // global translation coordinate + var scale = 1; // global scale + + var background = r.rect(0,0,'100%','100%').attr({'fill':'white', 'stroke':'none', 'opacity':0}); + + // return the global transform of the scene + this.get_transform = function(){ + return "T"+tr_x+","+tr_y + } + + // translate every element of the graph except the background. + // elements inserted in the graph after a translate_all() must manually apply transformation + // via get_transform() + var translate_all = function(dx,dy){ + tr_x += dx; + tr_y += dy; + tstr = self.get_transform(); + + r.forEach(function(el){ + if(el != background){ + el.transform(tstr); + } + }); + } + + // Graph translation when background is dragged + var bg_drag_down = function(){ + px = py = 0; + } + var bg_drag_move = function(x,y){ + var dx = x - px; + var dy = y - py; + px = x; + py = y; + translate_all(dx,dy); + } + var bg_drag_up = function(){} + background.drag( bg_drag_move, bg_drag_down, bg_drag_up); + + $(background.node).bind('mousewheel',function(event,delta){ + translate_all(0,delta*20); + }); + //adds a node to the graph and sets its uid. this.add_node = function (n){ @@ -121,6 +165,15 @@ links[n2.uid].push(e); } }; + //removes an edge from the graph + this.remove_edge = function(edge){ + edges = _.without(edges,edge); + var n1 = edge.get_start(); + var n2 = edge.get_end(); + links[n1.uid] = _.without(links[n1.uid],edge); + links[n2.uid] = _.without(links[n2.uid],edge); + graph[n1.uid][n2.uid] = _without(graph[n1.uid][n2.uid],edge); + } //return the list of edges from n1 to n2 this.get_edge_list = function(n1,n2){ var list = []; @@ -212,14 +265,12 @@ // creates a new Graph Node on Raphael document r, centered on [pos_x,pos_y], with label 'label', // and of type 'circle' or 'rect', and of color 'color' - // TODO pass graph in constructor function GraphNode(graph,pos_x, pos_y,label,type,color){ + var self = this; var r = graph.r; var sy = graph.style.node_size_y; var sx = graph.style.node_size_x; var node_fig = null; - //var node_shadow = null; - var self = this; var selected = false; this.update_time = 0; this.connectors = []; @@ -233,9 +284,14 @@ node_fig = r.rect(pos_x-sx/2,pos_y-sy/2,sx,sy); } node_fig.attr({'fill':color, 'stroke':graph.style.outline,'stroke-width':1,'cursor':'pointer'}); + node_fig.transform(graph.get_transform()); + + $(node_fig.node).addClass('foobar'); var node_label = r.text(pos_x,pos_y,label); node_label.attr({'fill':graph.style.text,'cursor':'pointer'}); + node_label.transform(graph.get_transform()); + $(node_label.node).css('text-shadow',"1px 2px 3px rgba(0,0,0,0.3)"); // sets the center position of the node @@ -388,7 +444,7 @@ } // creates a new edge with label 'label' from start to end. start and end must implement get_pos_*, - // if tmp is true, the edge is not added to the graph, used for drag edges. TODO pass graph in constructor, + // if tmp is true, the edge is not added to the graph, used for drag edges. // replace tmp == false by graph == null function GraphEdge(graph,label,start,end,tmp){ var self = this; @@ -470,7 +526,6 @@ edge_path = make_line(); } }else{ // start == end - console.log("loop!"); var rad = graph.style.edge_loop_radius || 100; s = start.get_pos(); e = end.get_pos(); @@ -499,6 +554,10 @@ var edge = r.path(edge_path).attr({'stroke':graph.style.edge, 'stroke-width':2, 'arrow-end':'block-wide-long', 'cursor':'pointer'}).insertBefore(graph.get_node_list()[0].get_fig()); var labelpos = get_label_pos(edge); var edge_label = r.text(labelpos.x, labelpos.y - elfs, label).attr({'fill':graph.style.edge_label, 'cursor':'pointer', 'font-size':elfs}); + + edge.transform(graph.get_transform()); + edge_label.transform(graph.get_transform()); + $(edge_label.node).css('text-shadow',"1px 2px 3px rgba(0,0,0,0.3)"); //since we create an edge we need to recompute the edges that have the same start and end positions as this one @@ -539,6 +598,9 @@ function remove(){ edge.remove(); edge_label.remove(); + if(!tmp){ + graph.remove_edge(self); + } } function double_click(){ diff --git a/addons/web_diagram/static/src/js/jquery.mousewheel.js b/addons/web_diagram/static/src/js/jquery.mousewheel.js new file mode 100644 index 00000000000..38b60951b20 --- /dev/null +++ b/addons/web_diagram/static/src/js/jquery.mousewheel.js @@ -0,0 +1,84 @@ +/*! Copyright (c) 2011 Brandon Aaron (http://brandonaaron.net) + * Licensed under the MIT License (LICENSE.txt). + * + * Thanks to: http://adomas.org/javascript-mouse-wheel/ for some pointers. + * Thanks to: Mathias Bank(http://www.mathias-bank.de) for a scope bug fix. + * Thanks to: Seamus Leahy for adding deltaX and deltaY + * + * Version: 3.0.6 + * + * Requires: 1.2.2+ + */ + +(function($) { + +var types = ['DOMMouseScroll', 'mousewheel']; + +if ($.event.fixHooks) { + for ( var i=types.length; i; ) { + $.event.fixHooks[ types[--i] ] = $.event.mouseHooks; + } +} + +$.event.special.mousewheel = { + setup: function() { + if ( this.addEventListener ) { + for ( var i=types.length; i; ) { + this.addEventListener( types[--i], handler, false ); + } + } else { + this.onmousewheel = handler; + } + }, + + teardown: function() { + if ( this.removeEventListener ) { + for ( var i=types.length; i; ) { + this.removeEventListener( types[--i], handler, false ); + } + } else { + this.onmousewheel = null; + } + } +}; + +$.fn.extend({ + mousewheel: function(fn) { + return fn ? this.bind("mousewheel", fn) : this.trigger("mousewheel"); + }, + + unmousewheel: function(fn) { + return this.unbind("mousewheel", fn); + } +}); + + +function handler(event) { + var orgEvent = event || window.event, args = [].slice.call( arguments, 1 ), delta = 0, returnValue = true, deltaX = 0, deltaY = 0; + event = $.event.fix(orgEvent); + event.type = "mousewheel"; + + // Old school scrollwheel delta + if ( orgEvent.wheelDelta ) { delta = orgEvent.wheelDelta/120; } + if ( orgEvent.detail ) { delta = -orgEvent.detail/3; } + + // New school multidimensional scroll (touchpads) deltas + deltaY = delta; + + // Gecko + if ( orgEvent.axis !== undefined && orgEvent.axis === orgEvent.HORIZONTAL_AXIS ) { + deltaY = 0; + deltaX = -1*delta; + } + + // Webkit + if ( orgEvent.wheelDeltaY !== undefined ) { deltaY = orgEvent.wheelDeltaY/120; } + if ( orgEvent.wheelDeltaX !== undefined ) { deltaX = -1*orgEvent.wheelDeltaX/120; } + + // Add event and delta to the front of the arguments + args.unshift(event, delta, deltaX, deltaY); + + return ($.event.dispatch || $.event.handle).apply(this, args); +} + +})(jQuery); diff --git a/addons/web_diagram/static/src/js/vec2js/vec2.js b/addons/web_diagram/static/src/js/vec2js/vec2.js index c37b9674425..73b13d04125 100644 --- a/addons/web_diagram/static/src/js/vec2js/vec2.js +++ b/addons/web_diagram/static/src/js/vec2js/vec2.js @@ -1,6 +1,4 @@ - - (function(window){ // A Javascript 2D vector library diff --git a/addons/web_diagram/static/src/xml/base_diagram.xml b/addons/web_diagram/static/src/xml/base_diagram.xml index 6d0e36e2f17..e414cdcb13f 100644 --- a/addons/web_diagram/static/src/xml/base_diagram.xml +++ b/addons/web_diagram/static/src/xml/base_diagram.xml @@ -9,7 +9,9 @@ 0 / 0 +
-
+ +
From d27e795433a465d0207a9f02c1f0d279a5123f4c Mon Sep 17 00:00:00 2001 From: "Ujjvala Collins (OpenERP)" Date: Fri, 24 Feb 2012 15:38:11 +0530 Subject: [PATCH 010/196] [IMP]: Improved code. bzr revid: uco@tinyerp.com-20120224100811-me5r7269x5h7btmi --- addons/sale/sale.py | 47 ++++++++++++++++++++++++--------------------- 1 file changed, 25 insertions(+), 22 deletions(-) diff --git a/addons/sale/sale.py b/addons/sale/sale.py index 1036f383db0..dca0180ba8e 100644 --- a/addons/sale/sale.py +++ b/addons/sale/sale.py @@ -1357,35 +1357,38 @@ class sale_configuration(osv.osv_memory): ('global_on_order', 'Global On Order'), ('on_order_line', 'On Order Lines'), ], 'Taxes'), - 'sale_margin' : fields.boolean("Display Margin For Users"), - 'sale_journal' : fields.boolean("Invoice_journal?"), + 'sale_margin': fields.boolean("Display Margin For Users"), + 'sale_journal': fields.boolean("Invoice journal?"), } - def default_module_get(self, cr, uid, ids, selectable=[], context=None): - #TODO: Need to be implemented - selectable = ['project_timesheet','project_mrp','account_analytic_analysis','delivery','sale_margin','sale_journal'] - res = super(sale_configuration, self).default_module_get(cr, uid, ids, selectable=selectable, context=context) - for k in res.keys(): + def default_get(self, cr, uid, fields_list, context=None): + ir_values_obj = self.pool.get('ir.values') + res = super(sale_configuration, self).default_get( + cr, uid, fields_list, context=context) + defaults = {} + module_list = ['project_timesheet','project_mrp','account_analytic_analysis','delivery', + 'sale_margin', 'sale_journal'] + defaults.update(self.get_installed_modules(cr, uid, module_list, context=context)) + for val in ir_values_obj.get(cr, uid, 'default', False, ['sale.order']): + defaults.update({val[1]: val[2]}) + for k in defaults.keys(): if k in ['project_timesheet','project_mrp','account_analytic_analysis']: - res.update({'task_work': True}) + defaults.update({'task_work': True}) if k in ['account_analytic_analysis']: - res.update({'timesheet': True}) + defaults.update({'timesheet': True}) if k == 'delivery': - res.update({'sale_orders': True, 'deli_orders': True}) + defaults.update({'sale_orders': True, 'deli_orders': True, 'charge_delivery': True}) + if k == 'picking_policy' and defaults[k]=='one': + defaults.update({'picking_policy': True}) else: res.update({k: False}) + res.update(defaults) return res _defaults = { 'order_policy': 'manual', 'tax_policy': 'no_tax', 'time_unit': lambda self, cr, uid, c: self.pool.get('product.uom').search(cr, uid, [('name', '=', _('Hour'))], context=c) and self.pool.get('product.uom').search(cr, uid, [('name', '=', _('Hour'))], context=c)[0] or False, - 'task_work': default_module_get, - 'timesheet': default_module_get, - 'sale_orders': default_module_get, - 'deli_orders': default_module_get, - 'sale_margin' : default_module_get, - 'sale_journal': default_module_get, } def onchange_order(self, cr, uid, ids, sale, deli, context=None): @@ -1396,16 +1399,14 @@ class sale_configuration(osv.osv_memory): res.update({'order_policy': 'picking'}) return {'value':res} - def write(self, cr, uid, ids, vals, context=None): - self.execute(cr, uid, ids, context=context) - return super(sale_configuration, self).write(cr, uid, ids, vals, context=context) - def execute(self, cr, uid, ids, context=None): + #TODO: TO BE IMPLEMENTED ir_values_obj = self.pool.get('ir.values') data_obj = self.pool.get('ir.model.data') menu_obj = self.pool.get('ir.ui.menu') module_obj = self.pool.get('ir.module.module') - module_upgrade_obj = self.pool.get('base.module.upgrade') + + super(sale_configuration, self).execute(cr, uid, ids, context=context) module_name = [] group_id = data_obj.get_object(cr, uid, 'base', 'group_sale_salesman').id @@ -1431,8 +1432,10 @@ class sale_configuration(osv.osv_memory): if wizard.charge_delivery: module_name.append('delivery') + if wizard.picking_policy: + ir_values_obj.set(cr, uid, 'default', False, 'picking_policy', ['sale.order'], 'one') + if len(module_name): - module_ids = [] need_install = False module_ids = [] for module in module_name: From 650151e6fc520ce76ce3673049a7b2a16b2daa2c Mon Sep 17 00:00:00 2001 From: "Turkesh Patel (Open ERP)" Date: Fri, 24 Feb 2012 15:58:01 +0530 Subject: [PATCH 011/196] [IMP] change field name bzr revid: tpa@tinyerp.com-20120224102801-x7nfb4fgtvr5w0xi --- addons/sale/sale_view.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/addons/sale/sale_view.xml b/addons/sale/sale_view.xml index dee42ec3c93..31b8bb97f97 100644 --- a/addons/sale/sale_view.xml +++ b/addons/sale/sale_view.xml @@ -546,7 +546,7 @@ - + From ca974ab6c2e0bba619f38bbabdc420d0ea175a2d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fr=C3=A9d=C3=A9ric=20van=20der=20Essen?= Date: Fri, 24 Feb 2012 14:00:07 +0100 Subject: [PATCH 012/196] dummy edges are destroyed on cancel bzr revid: fva@openerp.com-20120224130007-9cdj749bpfrdc0ix --- addons/web_diagram/static/src/js/diagram.js | 222 +++++++++++--------- addons/web_diagram/static/src/js/graph.js | 35 ++- 2 files changed, 152 insertions(+), 105 deletions(-) diff --git a/addons/web_diagram/static/src/js/diagram.js b/addons/web_diagram/static/src/js/diagram.js index eee6f23afe2..d0efa41e595 100644 --- a/addons/web_diagram/static/src/js/diagram.js +++ b/addons/web_diagram/static/src/js/diagram.js @@ -55,7 +55,7 @@ openerp.web.DiagramView = openerp.web.View.extend({ this.do_update_pager(); // New Node,Edge - this.$element.find('#new_node.oe_diagram_button_new').click(function(){self.add_edit_node(null, self.node);}); + this.$element.find('#new_node.oe_diagram_button_new').click(function(){self.add_node();}); if(this.id) { self.get_diagram_info(); @@ -112,6 +112,7 @@ openerp.web.DiagramView = openerp.web.View.extend({ } }, + // Set-up the drawing elements of the diagram draw_diagram: function(result) { var self = this; console.log(result); @@ -135,13 +136,12 @@ openerp.web.DiagramView = openerp.web.View.extend({ $('#dia-canvas *').remove(); // remove previous diagram var r = new Raphael(document.getElementById("dia-canvas"), '100%','100%'); - $(r.node).css("border","none"); - $(r.node).css("padding",0); + var graph = new CuteGraph(r,style); _.each(res_nodes, function(node) { var n = new CuteNode( graph, - node.x + 50, + node.x + 50, //FIXME the +50 should be in the layout algorithm node.y + 50, CuteGraph.wordwrap(node.name, 16), node.shape === 'rectangle' ? 'rect' : 'circle', @@ -159,114 +159,144 @@ openerp.web.DiagramView = openerp.web.View.extend({ }); CuteNode.double_click_callback = function(cutenode){ - self.add_edit_node( cutenode.id, self.node ); - } + self.edit_node(cutenode.id); + }; CuteEdge.double_click_callback = function(cuteedge){ - self.add_edit_node(cuteedge.id,self.connector); - } + self.edit_connector(cuteedge.id); + }; CuteEdge.creation_callback = function(node_start, node_end){ - console.log("creating edge from:",node_start," to:",node_end); - self.add_edit_node(null, self.connector, { - act_from: node_start.id, - act_to: node_end.id, - activity_from_id: node_start.id, - activity_to_id: node_end.id, - }); - return {label:""}; // TODO destroy edge on cancel - } + return {label:_t("new transition")}; + }; + CuteEdge.new_edge_callback = function(cuteedge){ + self.add_connector( cuteedge.get_start().id, + cuteedge.get_end().id, + cuteedge); + }; + }, - add_edit_node: function(id, model, defaults) { - defaults = defaults || {}; + // Creates a popup to edit the content of the node with id node_id + edit_node: function(node_id){ var self = this; + var title = _t('Activity'); + var pop = new openerp.web.form.FormOpenPopup(self); - if(!model) - model = self.node; - if(id) - id = parseInt(id, 10); - - var pop, - title = model == self.node ? _t('Activity') : _t('Transition'); - if(!id) { - pop = new openerp.web.form.SelectCreatePopup(this); - pop.select_element( - model, - { - title: _t("Create:") + title, - initial_view: 'form', - disable_multiple_selection: true - }, - this.dataset.domain, - this.context || this.dataset.context - ); - pop.on_select_elements.add_last(function(element_ids) { - self.dataset.read_index(_.keys(self.fields_view.fields)).pipe(self.on_diagram_loaded); - }); - pop.$element.bind("dialogbeforeclose",function(){ - console.log("HAHHAAH"); - console.log(self.connectors.attrs); - }); - } else { - pop = new openerp.web.form.FormOpenPopup(this); - pop.show_element( - model, - id, - this.context || this.dataset.context, + pop.show_element( + self.node, + node_id, + self.context || self.dataset.context, { title: _t("Open: ") + title } ); - pop.on_write.add(function() { - self.dataset.read_index(_.keys(self.fields_view.fields)).pipe(self.on_diagram_loaded); + + pop.on_write.add(function() { + self.dataset.read_index(_.keys(self.fields_view.fields)).pipe(self.on_diagram_loaded); }); - - } + + var form_fields = [self.parent_field]; + var form_controller = pop.view_form; + + form_controller.on_record_loaded.add_first(function() { + _.each(form_fields, function(fld) { + if (!(fld in form_controller.fields)) { return; } + var field = form_controller.fields[fld]; + field.$input.prop('disabled', true); + field.$drop_down.unbind(); + field.$menu_btn.unbind(); + }); + }); + }, + + // Creates a popup to add a node to the diagram + add_node: function(){ + var self = this; + var title = _t('Activity'); + var pop = new openerp.web.form.SelectCreatePopup(self); + pop.select_element( + self.node, + { + title: _t("Create:") + title, + initial_view: 'form', + disable_multiple_selection: true + }, + self.dataset.domain, + self.context || self.dataset.context + ); + pop.on_select_elements.add_last(function(element_ids) { + self.dataset.read_index(_.keys(self.fields_view.fields)).pipe(self.on_diagram_loaded); + }); + + var form_controller = pop.view_form; + var form_fields = [this.parent_field]; + + form_controller.on_record_loaded.add_last(function() { + _.each(form_fields, function(fld) { + if (!(fld in form_controller.fields)) { return; } + var field = form_controller.fields[fld]; + field.set_value([self.id,self.active_model]); + field.dirty = true; + }); + }); + }, + + // Creates a popup to edit the connector of id connector_id + edit_connector: function(connector_id){ + var self = this; + var title = _t('Transition'); + var pop = new openerp.web.form.FormOpenPopup(self); + pop.show_element( + self.connector, + parseInt(connector_id,10), //FIXME Isn't connector_id supposed to be an int ? + self.context || self.dataset.context, + { + title: _t("Open: ") + title + } + ); + pop.on_write.add(function() { + self.dataset.read_index(_.keys(self.fields_view.fields)).pipe(self.on_diagram_loaded); + }); + }, + + // Creates a popup to add a connector from node_source_id to node_dest_id. + // dummy_cuteedge if not null, will be removed form the graph after the popup is closed. + add_connector: function(node_source_id, node_dest_id, dummy_cuteedge){ + var self = this; + var title = _t('Transition'); + var pop = new openerp.web.form.SelectCreatePopup(self); + + pop.select_element( + self.connector, + { + title: _t("Create:") + title, + initial_view: 'form', + disable_multiple_selection: true + }, + this.dataset.domain, + this.context || this.dataset.context + ); + + pop.on_select_elements.add_last(function(element_ids) { + self.dataset.read_index(_.keys(self.fields_view.fields)).pipe(self.on_diagram_loaded); + }); + // We want to destroy the dummy edge after a creation cancel. This destroys it even if we save the changes. + // This is not a problem since the diagram is completely redrawn on saved changes. + pop.$element.bind("dialogbeforeclose",function(){ + if(dummy_cuteedge){ + dummy_cuteedge.remove(); + } + }); var form_controller = pop.view_form; - var form_fields; - - if (model === self.node) { - form_fields = [this.parent_field]; - if (!id) { - form_controller.on_record_loaded.add_last(function() { - _.each(form_fields, function(fld) { - if (!(fld in form_controller.fields)) { return; } - var field = form_controller.fields[fld]; - field.set_value([self.id,self.active_model]); - field.dirty = true; - }); - }); - } else { - form_controller.on_record_loaded.add_first(function() { - _.each(form_fields, function(fld) { - if (!(fld in form_controller.fields)) { return; } - var field = form_controller.fields[fld]; - field.$input.prop('disabled', true); - field.$drop_down.unbind(); - field.$menu_btn.unbind(); - }); - }); - } - } else { - form_fields = [ - this.connectors.attrs.source, - this.connectors.attrs.destination]; - } - - if (!_.isEmpty(defaults)) { - form_controller.on_record_loaded.add_last(function () { - _(form_fields).each(function (field) { - if (!defaults[field]) { return; } - form_controller.fields[field].set_value(defaults[field]); - form_controller.fields[field].dirty = true; - }); - }); - } - - + form_controller.on_record_loaded.add_last(function () { + form_controller.fields[self.connectors.attrs.source].set_value(node_source_id); + form_controller.fields[self.connectors.attrs.source].dirty = true; + form_controller.fields[self.connectors.attrs.destination].set_value(node_dest_id); + form_controller.fields[self.connectors.attrs.destination].dirty = true; + }); }, on_pager_action: function(action) { diff --git a/addons/web_diagram/static/src/js/graph.js b/addons/web_diagram/static/src/js/graph.js index 1bae1cd3b9e..e3c1b6f76af 100644 --- a/addons/web_diagram/static/src/js/graph.js +++ b/addons/web_diagram/static/src/js/graph.js @@ -63,7 +63,8 @@ if(graph.target_node){ edge_prop = GraphEdge.creation_callback(node,graph.target_node); if(edge_prop){ - new GraphEdge(graph,edge_prop.label, node,graph.target_node); + var new_edge = new GraphEdge(graph,edge_prop.label, node,graph.target_node); + GraphEdge.new_edge_callback(new_edge); } } } @@ -172,7 +173,7 @@ var n2 = edge.get_end(); links[n1.uid] = _.without(links[n1.uid],edge); links[n2.uid] = _.without(links[n2.uid],edge); - graph[n1.uid][n2.uid] = _without(graph[n1.uid][n2.uid],edge); + graph[n1.uid][n2.uid] = _.without(graph[n1.uid][n2.uid],edge); } //return the list of edges from n1 to n2 this.get_edge_list = function(n1,n2){ @@ -293,7 +294,14 @@ node_label.transform(graph.get_transform()); $(node_label.node).css('text-shadow',"1px 2px 3px rgba(0,0,0,0.3)"); - + // redraws all edges linked to this node + var update_linked_edges = function(){ + var edges = graph.get_linked_edge_list(self); + for(var i = 0; i < edges.length; i++){ + edges[i].update(); + } + } + // sets the center position of the node var set_pos = function(pos){ if(type == 'circle'){ @@ -305,10 +313,7 @@ for(var i = 0; i < self.connectors.length; i++){ self.connectors[i].update_pos(); } - var edges = graph.get_linked_edge_list(self); - for(var i = 0; i < edges.length; i++){ - edges[i].update(); - } + update_linked_edges(); } // returns the figure used to draw the node var get_fig = function(){ @@ -372,6 +377,7 @@ this.get_fig = get_fig; this.set_selected = set_selected; this.set_not_selected = set_not_selected + this.update_linked_edges = update_linked_edges; //select the node and play an animation when clicked @@ -594,18 +600,26 @@ edge_label.attr({'x':labelpos.x, 'y':labelpos.y - 14}); } } - //TODO remove from graph + // removes the edge from the scene, disconnects it from linked + // nodes, destroy its drawable elements. function remove(){ edge.remove(); edge_label.remove(); if(!tmp){ graph.remove_edge(self); } + if(start.update_linked_edges){ + start.update_linked_edges(); + } + if(start != end && end.update_linked_edges){ + end.update_linked_edges(); + } } function double_click(){ GraphEdge.double_click_callback(self); } + edge.dblclick(double_click); edge_label.dblclick(double_click); @@ -630,7 +644,10 @@ var edge_prop = {}; edge_prop.label = 'new edge!'; return edge_prop; - } + }; + // This is is called after a new edge is created, with the new edge + // as parameter + GraphEdge.new_edge_callback = function(new_edge){}; // returns a new string with the same content as str, but with lines of maximum 'width' characters. // lines are broken on words, or into words if a word is longer than 'width' From 3d19a013e7305a1da95bb0cb2ba7645837eb45e8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fr=C3=A9d=C3=A9ric=20van=20der=20Essen?= Date: Fri, 24 Feb 2012 14:25:06 +0100 Subject: [PATCH 013/196] diagram viewport scrolling now works on all elements bzr revid: fva@openerp.com-20120224132506-ujvbwj0jj8a26zhp --- addons/web_diagram/static/src/js/diagram.js | 2 +- addons/web_diagram/static/src/js/graph.js | 22 ++++++++++++++++----- 2 files changed, 18 insertions(+), 6 deletions(-) diff --git a/addons/web_diagram/static/src/js/diagram.js b/addons/web_diagram/static/src/js/diagram.js index d0efa41e595..0731c3a991b 100644 --- a/addons/web_diagram/static/src/js/diagram.js +++ b/addons/web_diagram/static/src/js/diagram.js @@ -231,7 +231,7 @@ openerp.web.DiagramView = openerp.web.View.extend({ var form_controller = pop.view_form; var form_fields = [this.parent_field]; - + form_controller.on_record_loaded.add_last(function() { _.each(form_fields, function(fld) { if (!(fld in form_controller.fields)) { return; } diff --git a/addons/web_diagram/static/src/js/graph.js b/addons/web_diagram/static/src/js/graph.js index e3c1b6f76af..9f77b40303e 100644 --- a/addons/web_diagram/static/src/js/graph.js +++ b/addons/web_diagram/static/src/js/graph.js @@ -17,6 +17,8 @@ var conn_circle = graph.r.circle(node.get_pos().x + pos_x, node.get_pos().y + pos_y,4); conn_circle.attr({'opacity':0, 'fill':graph.style.outline,'stroke':'none'}); conn_circle.transform(graph.get_transform()); + graph.set_scrolling(conn_circle); + var self = this; this.update_pos = function(){ @@ -107,6 +109,7 @@ this.get_transform = function(){ return "T"+tr_x+","+tr_y } + // translate every element of the graph except the background. // elements inserted in the graph after a translate_all() must manually apply transformation @@ -123,6 +126,13 @@ }); } + //Adds a mousewheel event callback to raph_element that scrolls the viewport + this.set_scrolling = function(raph_element){ + $(raph_element.node).bind('mousewheel',function(event,delta){ + translate_all(0,delta*20); + }); + } + // Graph translation when background is dragged var bg_drag_down = function(){ px = py = 0; @@ -136,11 +146,8 @@ } var bg_drag_up = function(){} background.drag( bg_drag_move, bg_drag_down, bg_drag_up); - - $(background.node).bind('mousewheel',function(event,delta){ - translate_all(0,delta*20); - }); - + + this.set_scrolling(background); //adds a node to the graph and sets its uid. this.add_node = function (n){ @@ -286,12 +293,14 @@ } node_fig.attr({'fill':color, 'stroke':graph.style.outline,'stroke-width':1,'cursor':'pointer'}); node_fig.transform(graph.get_transform()); + graph.set_scrolling(node_fig); $(node_fig.node).addClass('foobar'); var node_label = r.text(pos_x,pos_y,label); node_label.attr({'fill':graph.style.text,'cursor':'pointer'}); node_label.transform(graph.get_transform()); + graph.set_scrolling(node_label); $(node_label.node).css('text-shadow',"1px 2px 3px rgba(0,0,0,0.3)"); // redraws all edges linked to this node @@ -562,7 +571,10 @@ var edge_label = r.text(labelpos.x, labelpos.y - elfs, label).attr({'fill':graph.style.edge_label, 'cursor':'pointer', 'font-size':elfs}); edge.transform(graph.get_transform()); + graph.set_scrolling(edge); + edge_label.transform(graph.get_transform()); + graph.set_scrolling(edge_label); $(edge_label.node).css('text-shadow',"1px 2px 3px rgba(0,0,0,0.3)"); From 49d9226a445cf34de3cf2821e8991ed6251f62ca Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fr=C3=A9d=C3=A9ric=20van=20der=20Essen?= Date: Fri, 24 Feb 2012 15:48:03 +0100 Subject: [PATCH 014/196] new viewport integration bzr revid: fva@openerp.com-20120224144803-c7iiafllsjnuwkkv --- .../static/src/css/base_diagram.css | 31 +++++++++++++++++-- addons/web_diagram/static/src/js/diagram.js | 6 ++-- 2 files changed, 33 insertions(+), 4 deletions(-) diff --git a/addons/web_diagram/static/src/css/base_diagram.css b/addons/web_diagram/static/src/css/base_diagram.css index 9604823d040..5fb883721be 100644 --- a/addons/web_diagram/static/src/css/base_diagram.css +++ b/addons/web_diagram/static/src/css/base_diagram.css @@ -10,6 +10,32 @@ .openerp .clear{ clear:both; } +.openerp .diagram{ + margin:0; + padding:0; + width:100%; + height:500px; + /* resize:vertical; doesn't work because raphael catches the resize event...*/ + min-height:100%; + background-color:white; + border-style:solid; + border-width:1px; + border-color:#DCDCDC; + overflow:hidden; +} + +/* prevent accidental selection of the text in the svg nodes */ +.openerp .diagram *{ + -webkit-touch-callout: none; + -webkit-user-select: none; + -khtml-user-select: none; + -moz-user-select: none; + -ms-user-select: none; + -o-user-select: none; + user-select: none; +}; + +/* .openerp .diagram{ margin:0; padding:0; @@ -25,9 +51,10 @@ border-top-color:#DCDCDC; overflow:hidden; -} +}*/ +/* #widget-19_view_diagram { position:relative; -} +}*/ diff --git a/addons/web_diagram/static/src/js/diagram.js b/addons/web_diagram/static/src/js/diagram.js index 0731c3a991b..2c6bb29d8ff 100644 --- a/addons/web_diagram/static/src/js/diagram.js +++ b/addons/web_diagram/static/src/js/diagram.js @@ -118,6 +118,8 @@ openerp.web.DiagramView = openerp.web.View.extend({ console.log(result); var res_nodes = result['nodes']; var res_edges = result['conn']; + this.parent_field = result.parent_field; + var id_to_node = {} @@ -133,7 +135,7 @@ openerp.web.DiagramView = openerp.web.View.extend({ "edge_spacing" : 100, "edge_label_font_size" : 10 }; - $('#dia-canvas *').remove(); // remove previous diagram + $('#dia-canvas').empty(); // remove previous diagram var r = new Raphael(document.getElementById("dia-canvas"), '100%','100%'); @@ -167,7 +169,7 @@ openerp.web.DiagramView = openerp.web.View.extend({ }; CuteEdge.creation_callback = function(node_start, node_end){ - return {label:_t("new transition")}; + return {label:_t("")}; }; CuteEdge.new_edge_callback = function(cuteedge){ self.add_connector( cuteedge.get_start().id, From 4c5a4a4230f55c28736b7f857a811dff2135e865 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fr=C3=A9d=C3=A9ric=20van=20der=20Essen?= Date: Fri, 24 Feb 2012 15:50:26 +0100 Subject: [PATCH 015/196] diagram : removing dracula bzr revid: fva@openerp.com-20120224145026-3drv72cejyej8ub6 --- addons/web_diagram/__openerp__.py | 3 - .../static/lib/js/dracula_algorithms.js | 599 ------------------ .../static/lib/js/dracula_graffle.js | 107 ---- .../static/lib/js/dracula_graph.coffee | 524 --------------- .../static/lib/js/dracula_graph.js | 527 --------------- 5 files changed, 1760 deletions(-) delete mode 100644 addons/web_diagram/static/lib/js/dracula_algorithms.js delete mode 100644 addons/web_diagram/static/lib/js/dracula_graffle.js delete mode 100644 addons/web_diagram/static/lib/js/dracula_graph.coffee delete mode 100644 addons/web_diagram/static/lib/js/dracula_graph.js diff --git a/addons/web_diagram/__openerp__.py b/addons/web_diagram/__openerp__.py index 22f061c6475..19cafe6808e 100644 --- a/addons/web_diagram/__openerp__.py +++ b/addons/web_diagram/__openerp__.py @@ -6,9 +6,6 @@ "depends" : ["web"], "js": [ 'static/lib/js/raphael-min.js', - 'static/lib/js/dracula_graffle.js', - 'static/lib/js/dracula_graph.js', - 'static/lib/js/dracula_algorithms.js', 'static/src/js/jquery.mousewheel.js', 'static/src/js/vec2js/vec2.js', 'static/src/js/graph.js', diff --git a/addons/web_diagram/static/lib/js/dracula_algorithms.js b/addons/web_diagram/static/lib/js/dracula_algorithms.js deleted file mode 100644 index 0fbb0857fc8..00000000000 --- a/addons/web_diagram/static/lib/js/dracula_algorithms.js +++ /dev/null @@ -1,599 +0,0 @@ -/* - * Various algorithms and data structures, licensed under the MIT-license. - * (c) 2010 by Johann Philipp Strathausen - * http://strathausen.eu - * - */ - - - -/* - Bellman-Ford - - Path-finding algorithm, finds the shortest paths from one node to all nodes. - - - Complexity - - O( |E| · |V| ), where E = edges and V = vertices (nodes) - - - Constraints - - Can run on graphs with negative edge weights as long as they do not have - any negative weight cycles. - - */ -function bellman_ford(g, source) { - - /* STEP 1: initialisation */ - for(var n in g.nodes) - g.nodes[n].distance = Infinity; - /* predecessors are implicitly null */ - source.distance = 0; - - step("Initially, all distances are infinite and all predecessors are null."); - - /* STEP 2: relax each edge (this is at the heart of Bellman-Ford) */ - /* repeat this for the number of nodes minus one */ - for(var i = 1; i < g.nodes.length; i++) - /* for each edge */ - for(var e in g.edges) { - var edge = g.edges[e]; - if(edge.source.distance + edge.weight < edge.target.distance) { - step("Relax edge between " + edge.source.id + " and " + edge.target.id + "."); - edge.target.distance = edge.source.distance + edge.weight; - edge.target.predecessor = edge.source; - } - //Added by Jake Stothard (Needs to be tested) - if(!edge.style.directed) { - if(edge.target.distance + edge.weight < edge.source.distance) { - g.snapShot("Relax edge between "+edge.target.id+" and "+edge.source.id+"."); - edge.source.distance = edge.target.distance + edge.weight; - edge.source.predecessor = edge.target; - } - } - } - step("Ready."); - - /* STEP 3: TODO Check for negative cycles */ - /* For now we assume here that the graph does not contain any negative - weights cycles. (this is left as an excercise to the reader[tm]) */ -} - - - -/* - Path-finding algorithm Dijkstra - - - worst-case running time is O((|E| + |V|) · log |V| ) thus better than - Bellman-Ford for sparse graphs (with less edges), but cannot handle - negative edge weights - */ -function dijkstra(g, source) { - - /* initially, all distances are infinite and all predecessors are null */ - for(var n in g.nodes) - g.nodes[n].distance = Infinity; - /* predecessors are implicitly null */ - - g.snapShot("Initially, all distances are infinite and all predecessors are null."); - - source.distance = 0; - /* set of unoptimized nodes, sorted by their distance (but a Fibonacci heap - would be better) */ - var q = new BinaryMinHeap(g.nodes, "distance"); - - /* pointer to the node in focus */ - var node; - - /* get the node with the smallest distance - as long as we have unoptimized nodes. q.min() can have O(log n). */ - while(q.min() != undefined) { - /* remove the latest */ - node = q.extractMin(); - node.optimized = true; - - /* no nodes accessible from this one, should not happen */ - if(node.distance == Infinity) - throw "Orphaned node!"; - - /* for each neighbour of node */ - for(e in node.edges) { - var other = (node == node.edges[e].target) ? node.edges[e].source : node.edges[e].target; - - if(other.optimized) - continue; - - /* look for an alternative route */ - var alt = node.distance + node.edges[e].weight; - - /* update distance and route if a better one has been found */ - if (alt < other.distance) { - - /* update distance of neighbour */ - other.distance = alt; - - /* update priority queue */ - q.heapify(); - - /* update path */ - other.predecessor = node; - g.snapShot("Enhancing node.") - } - } - } -} - - -/* All-Pairs-Shortest-Paths */ -/* Runs at worst in O(|V|³) and at best in Omega(|V|³) :-) - complexity Sigma(|V|²) */ -/* This implementation is not yet ready for general use, but works with the - Dracula graph library. */ -function floyd_warshall(g, source) { - - /* Step 1: initialising empty path matrix (second dimension is implicit) */ - var path = []; - var next = []; - var n = g.nodes.length; - - /* construct path matrix, initialize with Infinity */ - for(j in g.nodes) { - path[j] = []; - next[j] = []; - for(i in g.nodes) - path[j][i] = j == i ? 0 : Infinity; - } - - /* initialize path with edge weights */ - for(e in g.edges) - path[g.edges[e].source.id][g.edges[e].target.id] = g.edges[e].weight; - - /* Note: Usually, the initialisation is done by getting the edge weights - from a node matrix representation of the graph, not by iterating through - a list of edges as done here. */ - - /* Step 2: find best distances (the heart of Floyd-Warshall) */ - for(k in g.nodes){ - for(i in g.nodes) { - for(j in g.nodes) - if(path[i][j] > path[i][k] + path[k][j]) { - path[i][j] = path[i][k] + path[k][j]; - /* Step 2.b: remember the path */ - next[i][j] = k; - } - } - } - - /* Step 3: Path reconstruction, get shortest path */ - function getPath(i, j) { - if(path[i][j] == Infinity) - throw "There is no path."; - var intermediate = next[i][j]; - if(intermediate == undefined) - return null; - else - return getPath(i, intermediate) - .concat([intermediate]) - .concat(getPath(intermediate, j)); - } - - /* TODO use the knowledge, e.g. mark path in graph */ -} - -/* - Ford-Fulkerson - - Max-Flow-Min-Cut Algorithm finding the maximum flow through a directed - graph from source to sink. - - - Complexity - - O(E * max(f)), max(f) being the maximum flow - - - Description - - As long as there is an open path through the residual graph, send the - minimum of the residual capacities on the path. - - - Constraints - - The algorithm works only if all weights are integers. Otherwise it is - possible that the Ford–Fulkerson algorithm will not converge to the maximum - value. - - - Input - - g - Graph object - s - Source ID - t - Target (sink) ID - - - Output - - Maximum flow from Source s to Target t - - */ -/* - Edmonds-Karp - - Max-Flow-Min-Cut Algorithm finding the maximum flow through a directed - graph from source to sink. An implementation of the Ford-Fulkerson - algorithm. - - - Complexity - - O(|V|*|E|²) - - - Input - - g - Graph object (with node and edge lists, capacity is a property of edge) - s - source ID - t - sink ID - - */ -function edmonds_karp(g, s, t) { - -} - -/* - A simple binary min-heap serving as a priority queue - - takes an array as the input, with elements having a key property - - elements will look like this: - { - key: "... key property ...", - value: "... element content ..." - } - - provides insert(), min(), extractMin() and heapify() - - example usage (e.g. via the Firebug or Chromium console): - var x = {foo: 20, hui: "bla"}; - var a = new BinaryMinHeap([x,{foo:3},{foo:10},{foo:20},{foo:30},{foo:6},{foo:1},{foo:3}],"foo"); - console.log(a.extractMin()); - console.log(a.extractMin()); - x.foo = 0; // update key - a.heapify(); // call this always after having a key updated - console.log(a.extractMin()); - console.log(a.extractMin()); - - can also be used on a simple array, like [9,7,8,5] - */ -function BinaryMinHeap(array, key) { - - /* Binary tree stored in an array, no need for a complicated data structure */ - var tree = []; - - var key = key || 'key'; - - /* Calculate the index of the parent or a child */ - var parent = function(index) { return Math.floor((index - 1)/2); }; - var right = function(index) { return 2 * index + 2; }; - var left = function(index) { return 2 * index + 1; }; - - /* Helper function to swap elements with their parent - as long as the parent is bigger */ - function bubble_up(i) { - var p = parent(i); - while((p >= 0) && (tree[i][key] < tree[p][key])) { - /* swap with parent */ - tree[i] = tree.splice(p, 1, tree[i])[0]; - /* go up one level */ - i = p; - p = parent(i); - } - } - - /* Helper function to swap elements with the smaller of their children - as long as there is one */ - function bubble_down(i) { - var l = left(i); - var r = right(i); - - /* as long as there are smaller children */ - while(tree[l] && (tree[i][key] > tree[l][key]) || tree[r] && (tree[i][key] > tree[r][key])) { - - /* find smaller child */ - var child = tree[l] ? tree[r] ? tree[l][key] > tree[r][key] ? r : l : l : l; - - /* swap with smaller child with current element */ - tree[i] = tree.splice(child, 1, tree[i])[0]; - - /* go up one level */ - i = child; - l = left(i); - r = right(i); - } - } - - /* Insert a new element with respect to the heap property - 1. Insert the element at the end - 2. Bubble it up until it is smaller than its parent */ - this.insert = function(element) { - - /* make sure there's a key property */ - (element[key] == undefined) && (element = {key:element}); - - /* insert element at the end */ - tree.push(element); - - /* bubble up the element */ - bubble_up(tree.length - 1); - } - - /* Only show us the minimum */ - this.min = function() { - return tree.length == 1 ? undefined : tree[0]; - } - - /* Return and remove the minimum - 1. Take the root as the minimum that we are looking for - 2. Move the last element to the root (thereby deleting the root) - 3. Compare the new root with both of its children, swap it with the - smaller child and then check again from there (bubble down) - */ - this.extractMin = function() { - var result = this.min(); - - /* move the last element to the root or empty the tree completely */ - /* bubble down the new root if necessary */ - (tree.length == 1) && (tree = []) || (tree[0] = tree.pop()) && bubble_down(0); - - return result; - } - - /* currently unused, TODO implement */ - this.changeKey = function(index, key) { - throw "function not implemented"; - } - - this.heapify = function() { - for(var start = Math.floor((tree.length - 2) / 2); start >= 0; start--) { - bubble_down(start); - } - } - - /* insert the input elements one by one only when we don't have a key property (TODO can be done more elegant) */ - for(i in (array || [])) - this.insert(array[i]); -} - - - -/* - Quick Sort: - 1. Select some random value from the array, the median. - 2. Divide the array in three smaller arrays according to the elements - being less, equal or greater than the median. - 3. Recursively sort the array containg the elements less than the - median and the one containing elements greater than the median. - 4. Concatenate the three arrays (less, equal and greater). - 5. One or no element is always sorted. - TODO: This could be implemented more efficiently by using only one array object and several pointers. -*/ -function quickSort(arr) { - /* recursion anchor: one element is always sorted */ - if(arr.length <= 1) return arr; - /* randomly selecting some value */ - var median = arr[Math.floor(Math.random() * arr.length)]; - var arr1 = [], arr2 = [], arr3 = []; - for(var i in arr) { - arr[i] < median && arr1.push(arr[i]); - arr[i] == median && arr2.push(arr[i]); - arr[i] > median && arr3.push(arr[i]); - } - /* recursive sorting and assembling final result */ - return quickSort(arr1).concat(arr2).concat(quickSort(arr3)); -} - -/* - Selection Sort: - 1. Select the minimum and remove it from the array - 2. Sort the rest recursively - 3. Return the minimum plus the sorted rest - 4. An array with only one element is already sorted -*/ -function selectionSort(arr) { - /* recursion anchor: one element is always sorted */ - if(arr.length == 1) return arr; - var minimum = Infinity; - var index; - for(var i in arr) { - if(arr[i] < minimum) { - minimum = arr[i]; - index = i; /* remember the minimum index for later removal */ - } - } - /* remove the minimum */ - arr.splice(index, 1); - /* assemble result and sort recursively (could be easily done iteratively as well)*/ - return [minimum].concat(selectionSort(arr)); -} - -/* - Merge Sort: - 1. Cut the array in half - 2. Sort each of them recursively - 3. Merge the two sorted arrays - 4. An array with only one element is considered sorted - -*/ -function mergeSort(arr) { - /* merges two sorted arrays into one sorted array */ - function merge(a, b) { - /* result set */ - var c = []; - /* as long as there are elements in the arrays to be merged */ - while(a.length > 0 || b.length > 0){ - /* are there elements to be merged, if yes, compare them and merge */ - var n = a.length > 0 && b.length > 0 ? a[0] < b[0] ? a.shift() : b.shift() : b.length > 0 ? b.shift() : a.length > 0 ? a.shift() : null; - /* always push the smaller one onto the result set */ - n != null && c.push(n); - } - return c; - } - /* this mergeSort implementation cuts the array in half, wich should be fine with randomized arrays, but introduces the risk of a worst-case scenario */ - median = Math.floor(arr.length / 2); - var part1 = arr.slice(0, median); /* for some reason it doesn't work if inserted directly in the return statement (tried so with firefox) */ - var part2 = arr.slice(median - arr.length); - return arr.length <= 1 ? arr : merge( - mergeSort(part1), /* first half */ - mergeSort(part2) /* second half */ - ); -} - -/* Balanced Red-Black-Tree */ -function RedBlackTree(arr) { - -} - -function BTree(arr) { - -} - -function NaryTree(n, arr) { - -} - -/** - * Knuth-Morris-Pratt string matching algorithm - finds a pattern in a text. - * FIXME: Doesn't work correctly yet. - */ -function kmp(p, t) { - - /** - * PREFIX, OVERLAP or FALIURE function for KMP. Computes how many iterations - * the algorithm can skip after a mismatch. - * - * @input p - pattern (string) - * @result array of skippable iterations - */ - function prefix(p) { - /* pi contains the computed skip marks */ - var pi = [0], k = 0; - for(q = 1; q < p.length; q++) { - while(k > 0 && (p.charAt(k) != p.charAt(q))) - k = pi[k-1]; - - (p.charAt(k) == p.charAt(q)) && k++; - - pi[q] = k; - } - return pi; - } - - /* The actual KMP algorithm starts here. */ - - var pi = prefix(p), q = 0, result = []; - - for(var i = 0; i < t.length; i++) { - /* jump forward as long as the character doesn't match */ - while((q > 0) && (p.charAt(q) != t.charAt(i))) - q = pi[q]; - - (p.charAt(q) == t.charAt(i)) && q++; - - (q == p.length) && result.push(i - p.length) && (q = pi[q]); - } - - return result; -} - -/* step for algorithm visualisation */ -function step(comment, funct) { - //wait for input - //display comment (before or after waiting) -// next.wait(); - /* execute callback function */ - funct(); -} - -/** - * Curry - Function currying - * Copyright (c) 2008 Ariel Flesler - aflesler(at)gmail(dot)com | http://flesler.blogspot.com - * Licensed under BSD (http://www.opensource.org/licenses/bsd-license.php) - * Date: 10/4/2008 - * - * @author Ariel Flesler - * @version 1.0.1 - */ -function curry( fn ){ - return function(){ - var args = curry.args(arguments), - master = arguments.callee, - self = this; - - return args.length >= fn.length ? fn.apply(self,args) : function(){ - return master.apply( self, args.concat(curry.args(arguments)) ); - }; - }; -}; - -curry.args = function( args ){ - return Array.prototype.slice.call(args); -}; - -Function.prototype.curry = function(){ - return curry(this); -}; - -/** - * Topological Sort - * - * Sort a directed graph based on incoming edges - * - * Coded by Jake Stothard - */ -function topological_sort(g) { - //Mark nodes as "deleted" instead of actually deleting them - //That way we don't have to copy g - - for(i in g.nodes) - g.nodes[i].deleted = false; - - var ret = topological_sort_helper(g); - - //Cleanup: Remove the deleted property - for(i in g.nodes) - delete g.nodes[i].deleted - - return ret; -} -function topological_sort_helper(g) { - //Find node with no incoming edges - var node; - for(i in g.nodes) { - if(g.nodes[i].deleted) - continue; //Bad style, meh - - var incoming = false; - for(j in g.nodes[i].edges) { - if(g.nodes[i].edges[j].target == g.nodes[i] - && g.nodes[i].edges[j].source.deleted == false) { - incoming = true; - break; - } - } - if(!incoming) { - node = g.nodes[i]; - break; - } - } - - // Either unsortable or done. Either way, GTFO - if(node == undefined) - return []; - - //"Delete" node from g - node.deleted = true; - - var tail = topological_sort_helper(g); - - tail.unshift(node); - - return tail; -} diff --git a/addons/web_diagram/static/lib/js/dracula_graffle.js b/addons/web_diagram/static/lib/js/dracula_graffle.js deleted file mode 100644 index 2b03ad16c79..00000000000 --- a/addons/web_diagram/static/lib/js/dracula_graffle.js +++ /dev/null @@ -1,107 +0,0 @@ -/** - * Originally grabbed from the official RaphaelJS Documentation - * http://raphaeljs.com/graffle.html - * Adopted (arrows) and commented by Philipp Strathausen http://blog.ameisenbar.de - * Licenced under the MIT licence. - */ - -/** - * Usage: - * connect two shapes - * parameters: - * source shape [or connection for redrawing], - * target shape, - * style with { fg : linecolor, bg : background color, directed: boolean } - * returns: - * connection { draw = function() } - */ -Raphael.fn.connection = function (obj1, obj2, style) { - var selfRef = this; - /* create and return new connection */ - var edge = {/* - from : obj1, - to : obj2, - style : style,*/ - draw : function() { - /* get bounding boxes of target and source */ - var bb1 = obj1.getBBox(); - var bb2 = obj2.getBBox(); - var off1 = 0; - var off2 = 0; - /* coordinates for potential connection coordinates from/to the objects */ - var p = [ - {x: bb1.x + bb1.width / 2, y: bb1.y - off1}, /* NORTH 1 */ - {x: bb1.x + bb1.width / 2, y: bb1.y + bb1.height + off1}, /* SOUTH 1 */ - {x: bb1.x - off1, y: bb1.y + bb1.height / 2}, /* WEST 1 */ - {x: bb1.x + bb1.width + off1, y: bb1.y + bb1.height / 2}, /* EAST 1 */ - {x: bb2.x + bb2.width / 2, y: bb2.y - off2}, /* NORTH 2 */ - {x: bb2.x + bb2.width / 2, y: bb2.y + bb2.height + off2}, /* SOUTH 2 */ - {x: bb2.x - off2, y: bb2.y + bb2.height / 2}, /* WEST 2 */ - {x: bb2.x + bb2.width + off2, y: bb2.y + bb2.height / 2} /* EAST 2 */ - ]; - - /* distances between objects and according coordinates connection */ - var d = {}, dis = []; - - /* - * find out the best connection coordinates by trying all possible ways - */ - /* loop the first object's connection coordinates */ - for (var i = 0; i < 4; i++) { - /* loop the seond object's connection coordinates */ - for (var j = 4; j < 8; j++) { - var dx = Math.abs(p[i].x - p[j].x), - dy = Math.abs(p[i].y - p[j].y); - if ((i == j - 4) || (((i != 3 && j != 6) || p[i].x < p[j].x) && ((i != 2 && j != 7) || p[i].x > p[j].x) && ((i != 0 && j != 5) || p[i].y > p[j].y) && ((i != 1 && j != 4) || p[i].y < p[j].y))) { - dis.push(dx + dy); - d[dis[dis.length - 1].toFixed(3)] = [i, j]; - } - } - } - var res = dis.length == 0 ? [0, 4] : d[Math.min.apply(Math, dis).toFixed(3)]; - /* bezier path */ - var x1 = p[res[0]].x, - y1 = p[res[0]].y, - x4 = p[res[1]].x, - y4 = p[res[1]].y, - dx = Math.max(Math.abs(x1 - x4) / 2, 10), - dy = Math.max(Math.abs(y1 - y4) / 2, 10), - x2 = [x1, x1, x1 - dx, x1 + dx][res[0]].toFixed(3), - y2 = [y1 - dy, y1 + dy, y1, y1][res[0]].toFixed(3), - x3 = [0, 0, 0, 0, x4, x4, x4 - dx, x4 + dx][res[1]].toFixed(3), - y3 = [0, 0, 0, 0, y1 + dy, y1 - dy, y4, y4][res[1]].toFixed(3); - /* assemble path and arrow */ - var path = ["M", x1.toFixed(3), y1.toFixed(3), "C", x2, y2, x3, y3, x4.toFixed(3), y4.toFixed(3)]; - /* arrow */ - if(style && style.directed) { - /* magnitude, length of the last path vector */ - var mag = Math.sqrt((y4 - y3) * (y4 - y3) + (x4 - x3) * (x4 - x3)); - /* vector normalisation to specified length */ - var norm = function(x,l){return (-x*(l||5)/mag);}; - /* calculate array coordinates (two lines orthogonal to the path vector) */ - var arr = [ - {x:(norm(x4-x3)+norm(y4-y3)+x4).toFixed(3), y:(norm(y4-y3)+norm(x4-x3)+y4).toFixed(3)}, - {x:(norm(x4-x3)-norm(y4-y3)+x4).toFixed(3), y:(norm(y4-y3)-norm(x4-x3)+y4).toFixed(3)} - ]; - path.push("M", arr[0].x, arr[0].y, "L", x4, y4, "L", arr[1].x, arr[1].y, "L", arr[0].x, arr[0].y); - } - var svgpath = path.join(' '); - /* function to be used for moving existent path(s), e.g. animate() or attr() */ - var move = "attr"; - /* applying path(s) */ - edge.fg && edge.fg[move]({path:svgpath}) - || (edge.fg = selfRef.path(svgpath).attr({stroke: style && style.stroke || "#000", fill: "none"}).toBack()); - edge.bg && edge.bg[move]({path:svgpath}) - || style && style.fill && (edge.bg = style.fill.split && selfRef.path(svgpath).attr({stroke: style.fill.split("|")[0], fill: "none", "stroke-width": style.fill.split("|")[1] || 3}).toBack()); - /* setting label */ - style && style.label - && (edge.label && edge.label.attr({x:(x1+x4)/2, y:(y1+y4)/2}) - || (edge.label = selfRef.text((x1+x4)/2, (y1+y4)/2, style.label).attr({fill: "#000", "font-size": style["font-size"] || "12px"}))); -// && selfRef.text(x4, y4, style.label).attr({stroke: style && style.stroke || "#fff", "font-weight":"bold", "font-size":"20px"}) -// style && style.callback && style.callback(edge); - } - } - edge.draw(); - return edge; -}; -//Raphael.prototype.set.prototype.dodo=function(){console.log("works");}; diff --git a/addons/web_diagram/static/lib/js/dracula_graph.coffee b/addons/web_diagram/static/lib/js/dracula_graph.coffee deleted file mode 100644 index bb91945098d..00000000000 --- a/addons/web_diagram/static/lib/js/dracula_graph.coffee +++ /dev/null @@ -1,524 +0,0 @@ -### - * Dracula Graph Layout and Drawing Framework 0.0.3alpha - * (c) 2010 Philipp Strathausen , http://strathausen.eu - * - * Contributions by: - * Branched by Jake Stothard . - * - * based on the Graph JavaScript framework, version 0.0.1 - * (c) 2006 Aslak Hellesoy - * (c) 2006 Dave Hoover - * - * Ported from Graph::Layouter::Spring in - * http://search.cpan.org/~pasky/Graph-Layderer-0.02/ - * The algorithm is based on a spring-style layouter of a Java-based social - * network tracker PieSpy written by Paul Mutton Epaul@jibble.orgE. - * - * This code is freely distributable under the terms of an MIT-style license. - * For details, see the Graph web site: http://dev.buildpatternd.com/trac - * - * Links: - * - * Graph Dracula JavaScript Framework: - * http://graphdracula.net - * - * Demo of the original applet: - * http://redsquirrel.com/dave/work/webdep/ - * - * Mirrored original source code at snipplr: - * http://snipplr.com/view/1950/graph-javascript-framework-version-001/ - * - * Original usage example: - * http://ajaxian.com/archives/new-javascriptcanvas-graph-library - * -### - - -### - Edge Factory -### -AbstractEdge = -> - -AbstractEdge.prototype = - hide: -> - @connection.fg.hide() - @connection.bg && @bg.connection.hide() - -EdgeFactory = -> - @template = new AbstractEdge() - @template.style = new Object() - @template.style.directed = false - @template.weight = 1 - -EdgeFactory.prototype = - build: (source, target) -> - e = jQuery.extend true, {}, @template - e.source = source - e.target = target - e - -### - Graph -### -Graph = -> - @nodes = {} - @edges = [] - @snapshots = [] # previous graph states TODO to be implemented - @edgeFactory = new EdgeFactory() - -Graph.prototype = -### - add a node - @id the node's ID (string or number) - @content (optional, dictionary) can contain any information that is - being interpreted by the layout algorithm or the graph - representation -### - addNode: (id, content) -> - # testing if node is already existing in the graph - if @nodes[id] == undefined - @nodes[id] = new Graph.Node id, content - @nodes[id] - - addEdge: (source, target, style) -> - s = @addNode source - t = @addNode target - var edge = @edgeFactory.build s, t - jQuery.extend edge.style, style - s.edges.push edge - @edges.push edge - # NOTE: Even directed edges are added to both nodes. - t.edges.push edge - - # TODO to be implemented - # Preserve a copy of the graph state (nodes, positions, ...) - # @comment a comment describing the state - snapShot: (comment) -> - ###/* FIXME - var graph = new Graph() - graph.nodes = jQuery.extend(true, {}, @nodes) - graph.edges = jQuery.extend(true, {}, @edges) - @snapshots.push({comment: comment, graph: graph}) - */ - ### - - removeNode: (id) -> - delete @nodes[id] - for i = 0; i < @edges.length; i++ - if @edges[i].source.id == id || @edges[i].target.id == id - @edges.splice(i, 1) - i-- - -/* - * Node - */ -Graph.Node = (id, node) -> - node = node || {} - node.id = id - node.edges = [] - node.hide = -> - @hidden = true - @shape && @shape.hide() # FIXME this is representation specific code and should be elsewhere */ - for(i in @edges) - (@edges[i].source.id == id || @edges[i].target == id) && @edges[i].hide && @edges[i].hide() - - node.show = -> - @hidden = false - @shape && @shape.show() - for(i in @edges) - (@edges[i].source.id == id || @edges[i].target == id) && @edges[i].show && @edges[i].show() - - node - -Graph.Node.prototype = { } - -### - Renderer base class -### -Graph.Renderer = { } - -### - Renderer implementation using RaphaelJS -### -Graph.Renderer.Raphael = (element, graph, width, height) -> - @width = width || 400 - @height = height || 400 - var selfRef = this - @r = Raphael element, @width, @height - @radius = 40 # max dimension of a node - @graph = graph - @mouse_in = false - - # TODO default node rendering - if(!@graph.render) { - @graph.render = -> - return - } - } - - /* - * Dragging - */ - @isDrag = false - @dragger = (e) -> - @dx = e.clientX - @dy = e.clientY - selfRef.isDrag = this - @set && @set.animate "fill-opacity": .1, 200 && @set.toFront() - e.preventDefault && e.preventDefault() - - document.onmousemove = (e) { - e = e || window.event - if (selfRef.isDrag) { - var bBox = selfRef.isDrag.set.getBBox() - // TODO round the coordinates here (eg. for proper image representation) - var newX = e.clientX - selfRef.isDrag.dx + (bBox.x + bBox.width / 2) - var newY = e.clientY - selfRef.isDrag.dy + (bBox.y + bBox.height / 2) - /* prevent shapes from being dragged out of the canvas */ - var clientX = e.clientX - (newX < 20 ? newX - 20 : newX > selfRef.width - 20 ? newX - selfRef.width + 20 : 0) - var clientY = e.clientY - (newY < 20 ? newY - 20 : newY > selfRef.height - 20 ? newY - selfRef.height + 20 : 0) - selfRef.isDrag.set.translate(clientX - Math.round(selfRef.isDrag.dx), clientY - Math.round(selfRef.isDrag.dy)) - // console.log(clientX - Math.round(selfRef.isDrag.dx), clientY - Math.round(selfRef.isDrag.dy)) - for (var i in selfRef.graph.edges) { - selfRef.graph.edges[i].connection && selfRef.graph.edges[i].connection.draw() - } - //selfRef.r.safari() - selfRef.isDrag.dx = clientX - selfRef.isDrag.dy = clientY - } - } - document.onmouseup = -> - selfRef.isDrag && selfRef.isDrag.set.animate({"fill-opacity": .6}, 500) - selfRef.isDrag = false - } - @draw() -} -Graph.Renderer.Raphael.prototype = { - translate: (point) { - return [ - (point[0] - @graph.layoutMinX) * @factorX + @radius, - (point[1] - @graph.layoutMinY) * @factorY + @radius - ] - }, - - rotate: (point, length, angle) { - var dx = length * Math.cos(angle) - var dy = length * Math.sin(angle) - return [point[0]+dx, point[1]+dy] - }, - - draw: -> - @factorX = (@width - 2 * @radius) / (@graph.layoutMaxX - @graph.layoutMinX) - @factorY = (@height - 2 * @radius) / (@graph.layoutMaxY - @graph.layoutMinY) - for (i in @graph.nodes) { - @drawNode(@graph.nodes[i]) - } - for (var i = 0; i < @graph.edges.length; i++) { - @drawEdge(@graph.edges[i]) - } - }, - - drawNode: (node) { - var point = @translate([node.layoutPosX, node.layoutPosY]) - node.point = point - - /* if node has already been drawn, move the nodes */ - if(node.shape) { - var oBBox = node.shape.getBBox() - var opoint = { x: oBBox.x + oBBox.width / 2, y: oBBox.y + oBBox.height / 2} - node.shape.translate(Math.round(point[0] - opoint.x), Math.round(point[1] - opoint.y)) - @r.safari() - return node - }/* else, draw new nodes */ - - var shape - - /* if a node renderer is provided by the user, then use it - or the default render instead */ - if(!node.render) { - node.render = (r, node) { - /* the default node drawing */ - var color = Raphael.getColor() - var ellipse = r.ellipse(0, 0, 30, 20).attr({fill: color, stroke: color, "stroke-width": 2}) - /* set DOM node ID */ - ellipse.node.id = node.label || node.id - shape = r.set(). - push(ellipse). - push(r.text(0, 30, node.label || node.id)) - return shape - } - } - /* or check for an ajax representation of the nodes */ - if(node.shapes) { - // TODO ajax representation evaluation - } - - shape = node.render(@r, node).hide() - - shape.attr({"fill-opacity": .6}) - /* re-reference to the node an element belongs to, needed for dragging all elements of a node */ - shape.items.forEach((item){ item.set = shape; item.node.style.cursor = "move"; }) - shape.mousedown(@dragger) - - var box = shape.getBBox() - shape.translate(Math.round(point[0]-(box.x+box.width/2)),Math.round(point[1]-(box.y+box.height/2))) - //console.log(box,point) - node.hidden || shape.show() - node.shape = shape - }, - drawEdge: (edge) { - /* if this edge already exists the other way around and is undirected */ - if(edge.backedge) - return - if(edge.source.hidden || edge.target.hidden) { - edge.connection && edge.connection.fg.hide() | edge.connection.bg && edge.connection.bg.hide() - return - } - /* if edge already has been drawn, only refresh the edge */ - if(!edge.connection) { - edge.style && edge.style.callback && edge.style.callback(edge); // TODO move this somewhere else - edge.connection = @r.connection(edge.source.shape, edge.target.shape, edge.style) - return - } - //FIXME showing doesn't work well - edge.connection.fg.show() - edge.connection.bg && edge.connection.bg.show() - edge.connection.draw() - } -} -Graph.Layout = {} -Graph.Layout.Spring = (graph) { - @graph = graph - @iterations = 500 - @maxRepulsiveForceDistance = 6 - @k = 2 - @c = 0.01 - @maxVertexMovement = 0.5 - @layout() -} -Graph.Layout.Spring.prototype = { - layout: -> - @layoutPrepare() - for (var i = 0; i < @iterations; i++) { - @layoutIteration() - } - @layoutCalcBounds() - }, - - layoutPrepare: -> - for (i in @graph.nodes) { - var node = @graph.nodes[i] - node.layoutPosX = 0 - node.layoutPosY = 0 - node.layoutForceX = 0 - node.layoutForceY = 0 - } - - }, - - layoutCalcBounds: -> - var minx = Infinity, maxx = -Infinity, miny = Infinity, maxy = -Infinity - - for (i in @graph.nodes) { - var x = @graph.nodes[i].layoutPosX - var y = @graph.nodes[i].layoutPosY - - if(x > maxx) maxx = x - if(x < minx) minx = x - if(y > maxy) maxy = y - if(y < miny) miny = y - } - - @graph.layoutMinX = minx - @graph.layoutMaxX = maxx - @graph.layoutMinY = miny - @graph.layoutMaxY = maxy - }, - - layoutIteration: -> - // Forces on nodes due to node-node repulsions - - var prev = new Array() - for(var c in @graph.nodes) { - var node1 = @graph.nodes[c] - for (var d in prev) { - var node2 = @graph.nodes[prev[d]] - @layoutRepulsive(node1, node2) - - } - prev.push(c) - } - - // Forces on nodes due to edge attractions - for (var i = 0; i < @graph.edges.length; i++) { - var edge = @graph.edges[i] - @layoutAttractive(edge); - } - - // Move by the given force - for (i in @graph.nodes) { - var node = @graph.nodes[i] - var xmove = @c * node.layoutForceX - var ymove = @c * node.layoutForceY - - var max = @maxVertexMovement - if(xmove > max) xmove = max - if(xmove < -max) xmove = -max - if(ymove > max) ymove = max - if(ymove < -max) ymove = -max - - node.layoutPosX += xmove - node.layoutPosY += ymove - node.layoutForceX = 0 - node.layoutForceY = 0 - } - }, - - layoutRepulsive: (node1, node2) { - var dx = node2.layoutPosX - node1.layoutPosX - var dy = node2.layoutPosY - node1.layoutPosY - var d2 = dx * dx + dy * dy - if(d2 < 0.01) { - dx = 0.1 * Math.random() + 0.1 - dy = 0.1 * Math.random() + 0.1 - var d2 = dx * dx + dy * dy - } - var d = Math.sqrt(d2) - if(d < @maxRepulsiveForceDistance) { - var repulsiveForce = @k * @k / d - node2.layoutForceX += repulsiveForce * dx / d - node2.layoutForceY += repulsiveForce * dy / d - node1.layoutForceX -= repulsiveForce * dx / d - node1.layoutForceY -= repulsiveForce * dy / d - } - }, - - layoutAttractive: (edge) { - var node1 = edge.source - var node2 = edge.target - - var dx = node2.layoutPosX - node1.layoutPosX - var dy = node2.layoutPosY - node1.layoutPosY - var d2 = dx * dx + dy * dy - if(d2 < 0.01) { - dx = 0.1 * Math.random() + 0.1 - dy = 0.1 * Math.random() + 0.1 - var d2 = dx * dx + dy * dy - } - var d = Math.sqrt(d2) - if(d > @maxRepulsiveForceDistance) { - d = @maxRepulsiveForceDistance - d2 = d * d - } - var attractiveForce = (d2 - @k * @k) / @k - if(edge.attraction == undefined) edge.attraction = 1 - attractiveForce *= Math.log(edge.attraction) * 0.5 + 1 - - node2.layoutForceX -= attractiveForce * dx / d - node2.layoutForceY -= attractiveForce * dy / d - node1.layoutForceX += attractiveForce * dx / d - node1.layoutForceY += attractiveForce * dy / d - } -} - -Graph.Layout.Ordered = (graph, order) { - @graph = graph - @order = order - @layout() -} -Graph.Layout.Ordered.prototype = { - layout: -> - @layoutPrepare() - @layoutCalcBounds() - }, - - layoutPrepare: (order) { - for (i in @graph.nodes) { - var node = @graph.nodes[i] - node.layoutPosX = 0 - node.layoutPosY = 0 - } - var counter = 0 - for (i in @order) { - var node = @order[i] - node.layoutPosX = counter - node.layoutPosY = Math.random() - counter++ - } - }, - - layoutCalcBounds: -> - var minx = Infinity, maxx = -Infinity, miny = Infinity, maxy = -Infinity - - for (i in @graph.nodes) { - var x = @graph.nodes[i].layoutPosX - var y = @graph.nodes[i].layoutPosY - - if(x > maxx) maxx = x - if(x < minx) minx = x - if(y > maxy) maxy = y - if(y < miny) miny = y - } - - @graph.layoutMinX = minx - @graph.layoutMaxX = maxx - - @graph.layoutMinY = miny - @graph.layoutMaxY = maxy - } -} - -/* - * usefull JavaScript extensions, - */ - - log(a) {console.log&&console.log(a);} - -/* - * Raphael Tooltip Plugin - * - attaches an element as a tooltip to another element - * - * Usage example, adding a rectangle as a tooltip to a circle: - * - * paper.circle(100,100,10).tooltip(paper.rect(0,0,20,30)) - * - * If you want to use more shapes, you'll have to put them into a set. - * - */ -Raphael.el.tooltip = (tp) { - @tp = tp - @tp.o = {x: 0, y: 0} - @tp.hide() - @hover( - (event){ - @mousemove((event){ - @tp.translate(event.clientX - - @tp.o.x,event.clientY - @tp.o.y) - @tp.o = {x: event.clientX, y: event.clientY} - }) - @tp.show().toFront() - }, - (event){ - @tp.hide() - @unmousemove() - }) - return this -} - -/* For IE */ -if (!Array.prototype.forEach) -{ - Array.prototype.forEach = (fun /*, thisp*/) - { - var len = @length - if (typeof fun != "") - throw new TypeError() - - var thisp = arguments[1] - for (var i = 0; i < len; i++) - { - if (i in this) - fun.call(thisp, this[i], i, this) - } - } -} diff --git a/addons/web_diagram/static/lib/js/dracula_graph.js b/addons/web_diagram/static/lib/js/dracula_graph.js deleted file mode 100644 index 28269986e78..00000000000 --- a/addons/web_diagram/static/lib/js/dracula_graph.js +++ /dev/null @@ -1,527 +0,0 @@ -/* - * Dracula Graph Layout and Drawing Framework 0.0.3alpha - * (c) 2010 Philipp Strathausen , http://strathausen.eu - * Contributions by Jake Stothard . - * - * based on the Graph JavaScript framework, version 0.0.1 - * (c) 2006 Aslak Hellesoy - * (c) 2006 Dave Hoover - * - * Ported from Graph::Layouter::Spring in - * http://search.cpan.org/~pasky/Graph-Layderer-0.02/ - * The algorithm is based on a spring-style layouter of a Java-based social - * network tracker PieSpy written by Paul Mutton . - * - * This code is freely distributable under the MIT license. Commercial use is - * hereby granted without any cost or restriction. - * - * Links: - * - * Graph Dracula JavaScript Framework: - * http://graphdracula.net - * - /*--------------------------------------------------------------------------*/ - -/* - * Edge Factory - */ -var AbstractEdge = function() { -} -AbstractEdge.prototype = { - hide: function() { - this.connection.fg.hide(); - this.connection.bg && this.bg.connection.hide(); - } -}; -var EdgeFactory = function() { - this.template = new AbstractEdge(); - this.template.style = new Object(); - this.template.style.directed = false; - this.template.weight = 1; -}; -EdgeFactory.prototype = { - build: function(source, target) { - var e = jQuery.extend(true, {}, this.template); - e.source = source; - e.target = target; - return e; - } -}; - -/* - * Graph - */ -var Graph = function() { - this.nodes = {}; - this.edges = []; - this.snapshots = []; // previous graph states TODO to be implemented - this.edgeFactory = new EdgeFactory(); -}; -Graph.prototype = { - /* - * add a node - * @id the node's ID (string or number) - * @content (optional, dictionary) can contain any information that is - * being interpreted by the layout algorithm or the graph - * representation - */ - addNode: function(id, content) { - /* testing if node is already existing in the graph */ - if(this.nodes[id] == undefined) { - this.nodes[id] = new Graph.Node(id, content); - } - return this.nodes[id]; - }, - - addEdge: function(source, target, style) { - var s = this.addNode(source); - var t = this.addNode(target); - var edge = this.edgeFactory.build(s, t); - jQuery.extend(edge.style,style); - s.edges.push(edge); - this.edges.push(edge); - // NOTE: Even directed edges are added to both nodes. - t.edges.push(edge); - }, - - /* TODO to be implemented - * Preserve a copy of the graph state (nodes, positions, ...) - * @comment a comment describing the state - */ - snapShot: function(comment) { - /* FIXME - var graph = new Graph(); - graph.nodes = jQuery.extend(true, {}, this.nodes); - graph.edges = jQuery.extend(true, {}, this.edges); - this.snapshots.push({comment: comment, graph: graph}); - */ - }, - removeNode: function(id) { - delete this.nodes[id]; - for(var i = 0; i < this.edges.length; i++) { - if (this.edges[i].source.id == id || this.edges[i].target.id == id) { - this.edges.splice(i, 1); - i--; - } - } - } -}; - -/* - * Node - */ -Graph.Node = function(id, node){ - node = node || {}; - node.id = id; - node.edges = []; - node.hide = function() { - this.hidden = true; - this.shape && this.shape.hide(); /* FIXME this is representation specific code and should be elsewhere */ - for(i in this.edges) - (this.edges[i].source.id == id || this.edges[i].target == id) && this.edges[i].hide && this.edges[i].hide(); - }; - node.show = function() { - this.hidden = false; - this.shape && this.shape.show(); - for(i in this.edges) - (this.edges[i].source.id == id || this.edges[i].target == id) && this.edges[i].show && this.edges[i].show(); - }; - return node; -}; -Graph.Node.prototype = { -}; - -/* - * Renderer base class - */ -Graph.Renderer = {}; - -/* - * Renderer implementation using RaphaelJS - */ -Graph.Renderer.Raphael = function(element, graph, width, height) { - this.width = width || 800; - this.height = height || 800; - var selfRef = this; - this.r = Raphael(element, this.width, this.height); - this.radius = 40; /* max dimension of a node */ - this.graph = graph; - this.mouse_in = false; - - /* TODO default node rendering function */ - if(!this.graph.render) { - this.graph.render = function() { - return; - } - } - - /* - * Dragging - */ - this.isDrag = false; - this.dragger = function (e) { - this.dx = e.clientX; - this.dy = e.clientY; - selfRef.isDrag = this; - this.set && this.set.animate({"fill-opacity": .1}, 200); - e.preventDefault && e.preventDefault(); - }; - - var d = document.getElementById(element); - d.onmousemove = function (e) { - e = e || window.event; - if (selfRef.isDrag) { - var bBox = selfRef.isDrag.set.getBBox(); - // TODO round the coordinates here (eg. for proper image representation) - var newX = e.clientX - selfRef.isDrag.dx + (bBox.x + bBox.width / 2); - var newY = e.clientY - selfRef.isDrag.dy + (bBox.y + bBox.height / 2); - /* prevent shapes from being dragged out of the canvas */ - var clientX = e.clientX - (newX < 20 ? newX - 20 : newX > selfRef.width - 20 ? newX - selfRef.width + 20 : 0); - var clientY = e.clientY - (newY < 20 ? newY - 20 : newY > selfRef.height - 20 ? newY - selfRef.height + 20 : 0); - selfRef.isDrag.set.translate(clientX - Math.round(selfRef.isDrag.dx), clientY - Math.round(selfRef.isDrag.dy)); - // console.log(clientX - Math.round(selfRef.isDrag.dx), clientY - Math.round(selfRef.isDrag.dy)); - for (var i in selfRef.graph.edges) { - selfRef.graph.edges[i].connection && selfRef.graph.edges[i].connection.draw(); - } - //selfRef.r.safari(); - selfRef.isDrag.dx = clientX; - selfRef.isDrag.dy = clientY; - } - }; - d.onmouseup = function () { - selfRef.isDrag && selfRef.isDrag.set.animate({"fill-opacity": .6}, 500); - selfRef.isDrag = false; - }; - this.draw(); -}; -Graph.Renderer.Raphael.prototype = { - translate: function(point) { - return [ - (point[0] - this.graph.layoutMinX) * this.factorX + this.radius, - (point[1] - this.graph.layoutMinY) * this.factorY + this.radius - ]; - }, - - rotate: function(point, length, angle) { - var dx = length * Math.cos(angle); - var dy = length * Math.sin(angle); - return [point[0]+dx, point[1]+dy]; - }, - - draw: function() { - this.factorX = (this.width - 2 * this.radius) / (this.graph.layoutMaxX - this.graph.layoutMinX); - this.factorY = (this.height - 2 * this.radius) / (this.graph.layoutMaxY - this.graph.layoutMinY); - for (i in this.graph.nodes) { - this.drawNode(this.graph.nodes[i]); - } - for (var i = 0; i < this.graph.edges.length; i++) { - this.drawEdge(this.graph.edges[i]); - } - }, - - drawNode: function(node) { - var point = this.translate([node.layoutPosX, node.layoutPosY]); - node.point = point; - - /* if node has already been drawn, move the nodes */ - if(node.shape) { - var oBBox = node.shape.getBBox(); - var opoint = { x: oBBox.x + oBBox.width / 2, y: oBBox.y + oBBox.height / 2}; - node.shape.translate(Math.round(point[0] - opoint.x), Math.round(point[1] - opoint.y)); - this.r.safari(); - return node; - }/* else, draw new nodes */ - - var shape; - - /* if a node renderer function is provided by the user, then use it - or the default render function instead */ - if(!node.render) { - node.render = function(r, node) { - /* the default node drawing */ - var color = Raphael.getColor(); - var ellipse = r.ellipse(0, 0, 30, 20).attr({fill: color, stroke: color, "stroke-width": 2}); - /* set DOM node ID */ - ellipse.node.id = node.label || node.id; - shape = r.set(). - push(ellipse). - push(r.text(0, 30, node.label || node.id)); - return shape; - } - } - /* or check for an ajax representation of the nodes */ - if(node.shapes) { - // TODO ajax representation evaluation - } - - shape = node.render(this.r, node).hide(); - - shape.attr({"fill-opacity": .6}); - /* re-reference to the node an element belongs to, needed for dragging all elements of a node */ - shape.items.forEach(function(item){ item.set = shape; item.node.style.cursor = "move"; }); - shape.mousedown(this.dragger); - - var box = shape.getBBox(); - shape.translate(Math.round(point[0]-(box.x+box.width/2)),Math.round(point[1]-(box.y+box.height/2))) - //console.log(box,point); - node.hidden || shape.show(); - node.shape = shape; - }, - drawEdge: function(edge) { - /* if this edge already exists the other way around and is undirected */ - if(edge.backedge) - return; - if(edge.source.hidden || edge.target.hidden) { - edge.connection && edge.connection.fg.hide() | edge.connection.bg && edge.connection.bg.hide(); - return; - } - /* if edge already has been drawn, only refresh the edge */ - if(!edge.connection) { - edge.style && edge.style.callback && edge.style.callback(edge); // TODO move this somewhere else - edge.connection = this.r.connection(edge.source.shape, edge.target.shape, edge.style); - return; - } - //FIXME showing doesn't work well - edge.connection.fg.show(); - edge.connection.bg && edge.connection.bg.show(); - edge.connection.draw(); - } -}; -Graph.Layout = {}; -Graph.Layout.Spring = function(graph) { - this.graph = graph; - this.iterations = 500; - this.maxRepulsiveForceDistance = 6; - this.k = 2; - this.c = 0.01; - this.maxVertexMovement = 0.5; - this.layout(); -}; -Graph.Layout.Spring.prototype = { - layout: function() { - this.layoutPrepare(); - for (var i = 0; i < this.iterations; i++) { - this.layoutIteration(); - } - this.layoutCalcBounds(); - }, - - layoutPrepare: function() { - for (i in this.graph.nodes) { - var node = this.graph.nodes[i]; - node.layoutPosX = 0; - node.layoutPosY = 0; - node.layoutForceX = 0; - node.layoutForceY = 0; - } - - }, - - layoutCalcBounds: function() { - var minx = Infinity, maxx = -Infinity, miny = Infinity, maxy = -Infinity; - - for (i in this.graph.nodes) { - var x = this.graph.nodes[i].layoutPosX; - var y = this.graph.nodes[i].layoutPosY; - - if(x > maxx) maxx = x; - if(x < minx) minx = x; - if(y > maxy) maxy = y; - if(y < miny) miny = y; - } - - this.graph.layoutMinX = minx; - this.graph.layoutMaxX = maxx; - this.graph.layoutMinY = miny; - this.graph.layoutMaxY = maxy; - }, - - layoutIteration: function() { - // Forces on nodes due to node-node repulsions - - var prev = new Array(); - for(var c in this.graph.nodes) { - var node1 = this.graph.nodes[c]; - for (var d in prev) { - var node2 = this.graph.nodes[prev[d]]; - this.layoutRepulsive(node1, node2); - - } - prev.push(c); - } - - // Forces on nodes due to edge attractions - for (var i = 0; i < this.graph.edges.length; i++) { - var edge = this.graph.edges[i]; - this.layoutAttractive(edge); - } - - // Move by the given force - for (i in this.graph.nodes) { - var node = this.graph.nodes[i]; - var xmove = this.c * node.layoutForceX; - var ymove = this.c * node.layoutForceY; - - var max = this.maxVertexMovement; - if(xmove > max) xmove = max; - if(xmove < -max) xmove = -max; - if(ymove > max) ymove = max; - if(ymove < -max) ymove = -max; - - node.layoutPosX += xmove; - node.layoutPosY += ymove; - node.layoutForceX = 0; - node.layoutForceY = 0; - } - }, - - layoutRepulsive: function(node1, node2) { - if (typeof node1 == 'undefined' || typeof node2 == 'undefined') - return; - var dx = node2.layoutPosX - node1.layoutPosX; - var dy = node2.layoutPosY - node1.layoutPosY; - var d2 = dx * dx + dy * dy; - if(d2 < 0.01) { - dx = 0.1 * Math.random() + 0.1; - dy = 0.1 * Math.random() + 0.1; - var d2 = dx * dx + dy * dy; - } - var d = Math.sqrt(d2); - if(d < this.maxRepulsiveForceDistance) { - var repulsiveForce = this.k * this.k / d; - node2.layoutForceX += repulsiveForce * dx / d; - node2.layoutForceY += repulsiveForce * dy / d; - node1.layoutForceX -= repulsiveForce * dx / d; - node1.layoutForceY -= repulsiveForce * dy / d; - } - }, - - layoutAttractive: function(edge) { - var node1 = edge.source; - var node2 = edge.target; - - var dx = node2.layoutPosX - node1.layoutPosX; - var dy = node2.layoutPosY - node1.layoutPosY; - var d2 = dx * dx + dy * dy; - if(d2 < 0.01) { - dx = 0.1 * Math.random() + 0.1; - dy = 0.1 * Math.random() + 0.1; - var d2 = dx * dx + dy * dy; - } - var d = Math.sqrt(d2); - if(d > this.maxRepulsiveForceDistance) { - d = this.maxRepulsiveForceDistance; - d2 = d * d; - } - var attractiveForce = (d2 - this.k * this.k) / this.k; - if(edge.attraction == undefined) edge.attraction = 1; - attractiveForce *= Math.log(edge.attraction) * 0.5 + 1; - - node2.layoutForceX -= attractiveForce * dx / d; - node2.layoutForceY -= attractiveForce * dy / d; - node1.layoutForceX += attractiveForce * dx / d; - node1.layoutForceY += attractiveForce * dy / d; - } -}; - -Graph.Layout.Ordered = function(graph, order) { - this.graph = graph; - this.order = order; - this.layout(); -}; -Graph.Layout.Ordered.prototype = { - layout: function() { - this.layoutPrepare(); - this.layoutCalcBounds(); - }, - - layoutPrepare: function(order) { - for (i in this.graph.nodes) { - var node = this.graph.nodes[i]; - node.layoutPosX = 0; - node.layoutPosY = 0; - } - var counter = 0; - for (i in this.order) { - var node = this.order[i]; - node.layoutPosX = counter; - node.layoutPosY = Math.random(); - counter++; - } - }, - - layoutCalcBounds: function() { - var minx = Infinity, maxx = -Infinity, miny = Infinity, maxy = -Infinity; - - for (i in this.graph.nodes) { - var x = this.graph.nodes[i].layoutPosX; - var y = this.graph.nodes[i].layoutPosY; - - if(x > maxx) maxx = x; - if(x < minx) minx = x; - if(y > maxy) maxy = y; - if(y < miny) miny = y; - } - - this.graph.layoutMinX = minx; - this.graph.layoutMaxX = maxx; - - this.graph.layoutMinY = miny; - this.graph.layoutMaxY = maxy; - } -}; - -/* - * usefull JavaScript extensions, - */ - -function log(a) {console.log&&console.log(a);} - -/* - * Raphael Tooltip Plugin - * - attaches an element as a tooltip to another element - * - * Usage example, adding a rectangle as a tooltip to a circle: - * - * paper.circle(100,100,10).tooltip(paper.rect(0,0,20,30)); - * - * If you want to use more shapes, you'll have to put them into a set. - * - */ -Raphael.el.tooltip = function (tp) { - this.tp = tp; - this.tp.o = {x: 0, y: 0}; - this.tp.hide(); - this.hover( - function(event){ - this.mousemove(function(event){ - this.tp.translate(event.clientX - - this.tp.o.x,event.clientY - this.tp.o.y); - this.tp.o = {x: event.clientX, y: event.clientY}; - }); - this.tp.show().toFront(); - }, - function(event){ - this.tp.hide(); - this.unmousemove(); - }); - return this; -}; - -/* For IE */ -if (!Array.prototype.forEach) -{ - Array.prototype.forEach = function(fun /*, thisp*/) - { - var len = this.length; - if (typeof fun != "function") - throw new TypeError(); - - var thisp = arguments[1]; - for (var i = 0; i < len; i++) - { - if (i in this) - fun.call(thisp, this[i], i, this); - } - }; -} From d099b4b1bf690797ab3f65b2bd297a605524298e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fr=C3=A9d=C3=A9ric=20van=20der=20Essen?= Date: Fri, 24 Feb 2012 16:00:11 +0100 Subject: [PATCH 016/196] [IMP] Cleanup : removing unnecessary files, moving libs to /lib bzr revid: fva@openerp.com-20120224150011-v64qda7lfknso6cb --- addons/web_diagram/__openerp__.py | 4 +- .../{src => lib}/js/jquery.mousewheel.js | 0 addons/web_diagram/static/src/img/grid.jpg | Bin 4530 -> 0 bytes addons/web_diagram/static/src/js/raphael.js | 5462 ----------------- .../static/src/js/{vec2js => }/vec2.js | 0 5 files changed, 2 insertions(+), 5464 deletions(-) rename addons/web_diagram/static/{src => lib}/js/jquery.mousewheel.js (100%) delete mode 100644 addons/web_diagram/static/src/img/grid.jpg delete mode 100644 addons/web_diagram/static/src/js/raphael.js rename addons/web_diagram/static/src/js/{vec2js => }/vec2.js (100%) diff --git a/addons/web_diagram/__openerp__.py b/addons/web_diagram/__openerp__.py index 19cafe6808e..b56e74ecd61 100644 --- a/addons/web_diagram/__openerp__.py +++ b/addons/web_diagram/__openerp__.py @@ -6,8 +6,8 @@ "depends" : ["web"], "js": [ 'static/lib/js/raphael-min.js', - 'static/src/js/jquery.mousewheel.js', - 'static/src/js/vec2js/vec2.js', + 'static/lib/js/jquery.mousewheel.js', + 'static/src/js/vec2.js', 'static/src/js/graph.js', 'static/src/js/diagram.js', ], diff --git a/addons/web_diagram/static/src/js/jquery.mousewheel.js b/addons/web_diagram/static/lib/js/jquery.mousewheel.js similarity index 100% rename from addons/web_diagram/static/src/js/jquery.mousewheel.js rename to addons/web_diagram/static/lib/js/jquery.mousewheel.js diff --git a/addons/web_diagram/static/src/img/grid.jpg b/addons/web_diagram/static/src/img/grid.jpg deleted file mode 100644 index 5254207b96407a79195cd541dfb145417e8bdb30..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 4530 zcmd^?dpMM7AIG1G2{~*-GY+AQk&Ht%MkQgDnar?xnHi_h%AwHYoWsj&lUEvtG7O2R zF?Q#`$Z0mmEhQ1kAeutikVBNAmdd=dZ@cY|>#g_NKfCsRuIKsZzV7?}{hr_R{rtX< zXi)S7SdYizumA`I0_?;WAbJYGFfoAv0PxK>01^NIS@A6%qDR1f04yafEiDBWKfqw{ zS{Vgd8S(f^US3WC@|ChO;H}9O`EYJ1McGW z97ABJSl!_$v3ffi(ZJik_g92(gtjZSJWOyx1Fb(y@{DOymW(O^R7NB7kIFvyPIf7Ncx@P3~k z_PB*+pk+aFNZw=D41Fwld+|RA1B%S?`8yBa_v+o?{hx%)pS#d{+`GkW04a&R?*`1oE&^-0=@ajQbMbuRqUAXzkwqVek z@~Gjuf~WKe*+)UwSQ4?>?j5h6?DuZgK-HU=xq=jor*EYsaJh&7(%+l_O@q zYs2js(Fti%KUJH1{Lt4j4u^tRaH8`}IHKz7(Cl9INT|z!km#IqB>utWUFf$^R~qCJ z5_!ccr`?Y#_zrYr0?DgWnYthZTj>lU!fDTg7R{j)O(rYQ#@Ss4a?~tyiLQqk@N%i@ zN;?Kjrjbb=urbd8%kk6~v-4R~^`pT;i|!&bKVYQq3(Li&;oj1;2&h#HD=^+lvut#0 zA3In0OMi{O2(Zw`iND!iLphIasI~CdHICgetdnuF>BIF?kwsU@GVu*BTr&_7{9B*z zG2Ilg>n5ff!s`!n-sgX$t)VkJmE5mczizbLt2z03*Y_$@>*Ai)Y7V<^w65o|2VzBl zW#a3SRa)bv|1{y-ZcPiAS&-}iXxo6r0Rm(3^f8OEk)X!F&&i#0s3H0a+|+0AXWYzV z-T3Cw#=t$Mfyv8BMc2p&cI9I4%~DkiVV1*wh5Ju1$L_mA^|!b%R?bf1(k60)t%-pTkY#rdj;B8#P++EcL51VT{)&AkBxvywRVfVeQFfl~1*) z^k*G?#r#<6_Wn?f%`!4}} z;>JT#(h7CS?9uWQFNTv-yUzG#=vRkk%)h0)Vyvo=okN-1n^U=s|Wzr!RXUqg(CgGgm zEGyQz?JfcLqB*mNjc8fB#E_$NZOZRKyBBn1=h576FVOj z!rG#rkB9)LC89(WY{4@}wr?j?Eu3Cj3dZ?qVhSHvj92fBk^NjhB-%3Tr`ZqOE6IS? z4ltbLj}>NbSC60MF9R~^_e%= z1aO#hM7NsbY3Q>gLA4%CJ)tiPX>ih9*?seF++=$FI>w|ENp9hLdqi#@Ag^jpFg+3a zJ2QJp!HpuI=%=@<%$IMLB>A0IXF9H`#;Fj$1!+(kIiE2=-(Xpr}v(gj{W>BM_9l8Hag@c`|I9IMts`Hs77Boyxe~}>qunRbALQSMQ_yR+GHUMf0^Z+L#5$jl8kKJE4kCu z6_yCt&Zk)^{jt2)gT^40HH8};%x^MqT~J`zCiykm?b0%(L6Oc>XV$j$m{h}^=u&H$ zsP;sn2)Gb@mSzBNr@mBewnvvbo+`)lkq^A values - tolerance) { - return value - rem + values; - } - } - return value; - }; - - - var createUUID = R.createUUID = (function (uuidRegEx, uuidReplacer) { - return function () { - return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(uuidRegEx, uuidReplacer).toUpperCase(); - }; - })(/[xy]/g, function (c) { - var r = math.random() * 16 | 0, - v = c == "x" ? r : (r & 3 | 8); - return v.toString(16); - }); - - - R.setWindow = function (newwin) { - eve("setWindow", R, g.win, newwin); - g.win = newwin; - g.doc = g.win.document; - if (R._engine.initWin) { - R._engine.initWin(g.win); - } - }; - var toHex = function (color) { - if (R.vml) { - // http://dean.edwards.name/weblog/2009/10/convert-any-colour-value-to-hex-in-msie/ - var trim = /^\s+|\s+$/g; - var bod; - try { - var docum = new ActiveXObject("htmlfile"); - docum.write(""); - docum.close(); - bod = docum.body; - } catch(e) { - bod = createPopup().document.body; - } - var range = bod.createTextRange(); - toHex = cacher(function (color) { - try { - bod.style.color = Str(color).replace(trim, E); - var value = range.queryCommandValue("ForeColor"); - value = ((value & 255) << 16) | (value & 65280) | ((value & 16711680) >>> 16); - return "#" + ("000000" + value.toString(16)).slice(-6); - } catch(e) { - return "none"; - } - }); - } else { - var i = g.doc.createElement("i"); - i.title = "Rapha\xebl Colour Picker"; - i.style.display = "none"; - g.doc.body.appendChild(i); - toHex = cacher(function (color) { - i.style.color = color; - return g.doc.defaultView.getComputedStyle(i, E).getPropertyValue("color"); - }); - } - return toHex(color); - }, - hsbtoString = function () { - return "hsb(" + [this.h, this.s, this.b] + ")"; - }, - hsltoString = function () { - return "hsl(" + [this.h, this.s, this.l] + ")"; - }, - rgbtoString = function () { - return this.hex; - }, - prepareRGB = function (r, g, b) { - if (g == null && R.is(r, "object") && "r" in r && "g" in r && "b" in r) { - b = r.b; - g = r.g; - r = r.r; - } - if (g == null && R.is(r, string)) { - var clr = R.getRGB(r); - r = clr.r; - g = clr.g; - b = clr.b; - } - if (r > 1 || g > 1 || b > 1) { - r /= 255; - g /= 255; - b /= 255; - } - - return [r, g, b]; - }, - packageRGB = function (r, g, b, o) { - r *= 255; - g *= 255; - b *= 255; - var rgb = { - r: r, - g: g, - b: b, - hex: R.rgb(r, g, b), - toString: rgbtoString - }; - R.is(o, "finite") && (rgb.opacity = o); - return rgb; - }; - - - R.color = function (clr) { - var rgb; - if (R.is(clr, "object") && "h" in clr && "s" in clr && "b" in clr) { - rgb = R.hsb2rgb(clr); - clr.r = rgb.r; - clr.g = rgb.g; - clr.b = rgb.b; - clr.hex = rgb.hex; - } else if (R.is(clr, "object") && "h" in clr && "s" in clr && "l" in clr) { - rgb = R.hsl2rgb(clr); - clr.r = rgb.r; - clr.g = rgb.g; - clr.b = rgb.b; - clr.hex = rgb.hex; - } else { - if (R.is(clr, "string")) { - clr = R.getRGB(clr); - } - if (R.is(clr, "object") && "r" in clr && "g" in clr && "b" in clr) { - rgb = R.rgb2hsl(clr); - clr.h = rgb.h; - clr.s = rgb.s; - clr.l = rgb.l; - rgb = R.rgb2hsb(clr); - clr.v = rgb.b; - } else { - clr = {hex: "none"}; - clr.r = clr.g = clr.b = clr.h = clr.s = clr.v = clr.l = -1; - } - } - clr.toString = rgbtoString; - return clr; - }; - - R.hsb2rgb = function (h, s, v, o) { - if (this.is(h, "object") && "h" in h && "s" in h && "b" in h) { - v = h.b; - s = h.s; - h = h.h; - o = h.o; - } - h *= 360; - var R, G, B, X, C; - h = (h % 360) / 60; - C = v * s; - X = C * (1 - abs(h % 2 - 1)); - R = G = B = v - C; - - h = ~~h; - R += [C, X, 0, 0, X, C][h]; - G += [X, C, C, X, 0, 0][h]; - B += [0, 0, X, C, C, X][h]; - return packageRGB(R, G, B, o); - }; - - R.hsl2rgb = function (h, s, l, o) { - if (this.is(h, "object") && "h" in h && "s" in h && "l" in h) { - l = h.l; - s = h.s; - h = h.h; - } - if (h > 1 || s > 1 || l > 1) { - h /= 360; - s /= 100; - l /= 100; - } - h *= 360; - var R, G, B, X, C; - h = (h % 360) / 60; - C = 2 * s * (l < .5 ? l : 1 - l); - X = C * (1 - abs(h % 2 - 1)); - R = G = B = l - C / 2; - - h = ~~h; - R += [C, X, 0, 0, X, C][h]; - G += [X, C, C, X, 0, 0][h]; - B += [0, 0, X, C, C, X][h]; - return packageRGB(R, G, B, o); - }; - - R.rgb2hsb = function (r, g, b) { - b = prepareRGB(r, g, b); - r = b[0]; - g = b[1]; - b = b[2]; - - var H, S, V, C; - V = mmax(r, g, b); - C = V - mmin(r, g, b); - H = (C == 0 ? null : - V == r ? (g - b) / C : - V == g ? (b - r) / C + 2 : - (r - g) / C + 4 - ); - H = ((H + 360) % 6) * 60 / 360; - S = C == 0 ? 0 : C / V; - return {h: H, s: S, b: V, toString: hsbtoString}; - }; - - R.rgb2hsl = function (r, g, b) { - b = prepareRGB(r, g, b); - r = b[0]; - g = b[1]; - b = b[2]; - - var H, S, L, M, m, C; - M = mmax(r, g, b); - m = mmin(r, g, b); - C = M - m; - H = (C == 0 ? null : - M == r ? (g - b) / C : - M == g ? (b - r) / C + 2 : - (r - g) / C + 4); - H = ((H + 360) % 6) * 60 / 360; - L = (M + m) / 2; - S = (C == 0 ? 0 : - L < .5 ? C / (2 * L) : - C / (2 - 2 * L)); - return {h: H, s: S, l: L, toString: hsltoString}; - }; - R._path2string = function () { - return this.join(",").replace(p2s, "$1"); - }; - function repush(array, item) { - for (var i = 0, ii = array.length; i < ii; i++) if (array[i] === item) { - return array.push(array.splice(i, 1)[0]); - } - } - function cacher(f, scope, postprocessor) { - function newf() { - var arg = Array.prototype.slice.call(arguments, 0), - args = arg.join("\u2400"), - cache = newf.cache = newf.cache || {}, - count = newf.count = newf.count || []; - if (cache[has](args)) { - repush(count, args); - return postprocessor ? postprocessor(cache[args]) : cache[args]; - } - count.length >= 1e3 && delete cache[count.shift()]; - count.push(args); - cache[args] = f[apply](scope, arg); - return postprocessor ? postprocessor(cache[args]) : cache[args]; - } - return newf; - } - - var preload = R._preload = function (src, f) { - var img = g.doc.createElement("img"); - img.style.cssText = "position:absolute;left:-9999em;top:-9999em"; - img.onload = function () { - f.call(this); - this.onload = null; - g.doc.body.removeChild(this); - }; - img.onerror = function () { - g.doc.body.removeChild(this); - }; - g.doc.body.appendChild(img); - img.src = src; - }; - - function clrToString() { - return this.hex; - } - - - R.getRGB = cacher(function (colour) { - if (!colour || !!((colour = Str(colour)).indexOf("-") + 1)) { - return {r: -1, g: -1, b: -1, hex: "none", error: 1, toString: clrToString}; - } - if (colour == "none") { - return {r: -1, g: -1, b: -1, hex: "none", toString: clrToString}; - } - !(hsrg[has](colour.toLowerCase().substring(0, 2)) || colour.charAt() == "#") && (colour = toHex(colour)); - var res, - red, - green, - blue, - opacity, - t, - values, - rgb = colour.match(colourRegExp); - if (rgb) { - if (rgb[2]) { - blue = toInt(rgb[2].substring(5), 16); - green = toInt(rgb[2].substring(3, 5), 16); - red = toInt(rgb[2].substring(1, 3), 16); - } - if (rgb[3]) { - blue = toInt((t = rgb[3].charAt(3)) + t, 16); - green = toInt((t = rgb[3].charAt(2)) + t, 16); - red = toInt((t = rgb[3].charAt(1)) + t, 16); - } - if (rgb[4]) { - values = rgb[4][split](commaSpaces); - red = toFloat(values[0]); - values[0].slice(-1) == "%" && (red *= 2.55); - green = toFloat(values[1]); - values[1].slice(-1) == "%" && (green *= 2.55); - blue = toFloat(values[2]); - values[2].slice(-1) == "%" && (blue *= 2.55); - rgb[1].toLowerCase().slice(0, 4) == "rgba" && (opacity = toFloat(values[3])); - values[3] && values[3].slice(-1) == "%" && (opacity /= 100); - } - if (rgb[5]) { - values = rgb[5][split](commaSpaces); - red = toFloat(values[0]); - values[0].slice(-1) == "%" && (red *= 2.55); - green = toFloat(values[1]); - values[1].slice(-1) == "%" && (green *= 2.55); - blue = toFloat(values[2]); - values[2].slice(-1) == "%" && (blue *= 2.55); - (values[0].slice(-3) == "deg" || values[0].slice(-1) == "\xb0") && (red /= 360); - rgb[1].toLowerCase().slice(0, 4) == "hsba" && (opacity = toFloat(values[3])); - values[3] && values[3].slice(-1) == "%" && (opacity /= 100); - return R.hsb2rgb(red, green, blue, opacity); - } - if (rgb[6]) { - values = rgb[6][split](commaSpaces); - red = toFloat(values[0]); - values[0].slice(-1) == "%" && (red *= 2.55); - green = toFloat(values[1]); - values[1].slice(-1) == "%" && (green *= 2.55); - blue = toFloat(values[2]); - values[2].slice(-1) == "%" && (blue *= 2.55); - (values[0].slice(-3) == "deg" || values[0].slice(-1) == "\xb0") && (red /= 360); - rgb[1].toLowerCase().slice(0, 4) == "hsla" && (opacity = toFloat(values[3])); - values[3] && values[3].slice(-1) == "%" && (opacity /= 100); - return R.hsl2rgb(red, green, blue, opacity); - } - rgb = {r: red, g: green, b: blue, toString: clrToString}; - rgb.hex = "#" + (16777216 | blue | (green << 8) | (red << 16)).toString(16).slice(1); - R.is(opacity, "finite") && (rgb.opacity = opacity); - return rgb; - } - return {r: -1, g: -1, b: -1, hex: "none", error: 1, toString: clrToString}; - }, R); - - R.hsb = cacher(function (h, s, b) { - return R.hsb2rgb(h, s, b).hex; - }); - - R.hsl = cacher(function (h, s, l) { - return R.hsl2rgb(h, s, l).hex; - }); - - R.rgb = cacher(function (r, g, b) { - return "#" + (16777216 | b | (g << 8) | (r << 16)).toString(16).slice(1); - }); - - R.getColor = function (value) { - var start = this.getColor.start = this.getColor.start || {h: 0, s: 1, b: value || .75}, - rgb = this.hsb2rgb(start.h, start.s, start.b); - start.h += .075; - if (start.h > 1) { - start.h = 0; - start.s -= .2; - start.s <= 0 && (this.getColor.start = {h: 0, s: 1, b: start.b}); - } - return rgb.hex; - }; - - R.getColor.reset = function () { - delete this.start; - }; - - // http://schepers.cc/getting-to-the-point - function catmullRom2bezier(crp) { - var d = []; - for (var i = 0, iLen = crp.length; iLen - 2 > i; i += 2) { - var p = [{x: +crp[i], y: +crp[i + 1]}, - {x: +crp[i], y: +crp[i + 1]}, - {x: +crp[i + 2], y: +crp[i + 3]}, - {x: +crp[i + 4], y: +crp[i + 5]}]; - if (iLen - 4 == i) { - p[0] = {x: +crp[i - 2], y: +crp[i - 1]}; - p[3] = p[2]; - } else if (i) { - p[0] = {x: +crp[i - 2], y: +crp[i - 1]}; - } - d.push(["C", - (-p[0].x + 6 * p[1].x + p[2].x) / 6, - (-p[0].y + 6 * p[1].y + p[2].y) / 6, - (p[1].x + 6 * p[2].x - p[3].x) / 6, - (p[1].y + 6*p[2].y - p[3].y) / 6, - p[2].x, - p[2].y - ]); - } - - return d; - } - - R.parsePathString = cacher(function (pathString) { - if (!pathString) { - return null; - } - var paramCounts = {a: 7, c: 6, h: 1, l: 2, m: 2, r: 4, q: 4, s: 4, t: 2, v: 1, z: 0}, - data = []; - if (R.is(pathString, array) && R.is(pathString[0], array)) { // rough assumption - data = pathClone(pathString); - } - if (!data.length) { - Str(pathString).replace(pathCommand, function (a, b, c) { - var params = [], - name = b.toLowerCase(); - c.replace(pathValues, function (a, b) { - b && params.push(+b); - }); - if (name == "m" && params.length > 2) { - data.push([b][concat](params.splice(0, 2))); - name = "l"; - b = b == "m" ? "l" : "L"; - } - if (name == "r") { - data.push([b][concat](params)); - } else while (params.length >= paramCounts[name]) { - data.push([b][concat](params.splice(0, paramCounts[name]))); - if (!paramCounts[name]) { - break; - } - } - }); - } - data.toString = R._path2string; - return data; - }); - - R.parseTransformString = cacher(function (TString) { - if (!TString) { - return null; - } - var paramCounts = {r: 3, s: 4, t: 2, m: 6}, - data = []; - if (R.is(TString, array) && R.is(TString[0], array)) { // rough assumption - data = pathClone(TString); - } - if (!data.length) { - Str(TString).replace(tCommand, function (a, b, c) { - var params = [], - name = lowerCase.call(b); - c.replace(pathValues, function (a, b) { - b && params.push(+b); - }); - data.push([b][concat](params)); - }); - } - data.toString = R._path2string; - return data; - }); - - R.findDotsAtSegment = function (p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y, t) { - var t1 = 1 - t, - t13 = pow(t1, 3), - t12 = pow(t1, 2), - t2 = t * t, - t3 = t2 * t, - x = t13 * p1x + t12 * 3 * t * c1x + t1 * 3 * t * t * c2x + t3 * p2x, - y = t13 * p1y + t12 * 3 * t * c1y + t1 * 3 * t * t * c2y + t3 * p2y, - mx = p1x + 2 * t * (c1x - p1x) + t2 * (c2x - 2 * c1x + p1x), - my = p1y + 2 * t * (c1y - p1y) + t2 * (c2y - 2 * c1y + p1y), - nx = c1x + 2 * t * (c2x - c1x) + t2 * (p2x - 2 * c2x + c1x), - ny = c1y + 2 * t * (c2y - c1y) + t2 * (p2y - 2 * c2y + c1y), - ax = t1 * p1x + t * c1x, - ay = t1 * p1y + t * c1y, - cx = t1 * c2x + t * p2x, - cy = t1 * c2y + t * p2y, - alpha = (90 - math.atan2(mx - nx, my - ny) * 180 / PI); - (mx > nx || my < ny) && (alpha += 180); - 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}, - alpha: alpha - }; - }; - R._removedFactory = function (methodname) { - return function () { - throw new Error("Rapha\xebl: you are calling to method \u201c" + methodname + "\u201d of removed object"); - }; - }; - var pathDimensions = cacher(function (path) { - if (!path) { - return {x: 0, y: 0, width: 0, height: 0}; - } - path = path2curve(path); - var x = 0, - y = 0, - X = [], - Y = [], - p; - for (var i = 0, ii = path.length; i < ii; i++) { - p = path[i]; - if (p[0] == "M") { - x = p[1]; - y = p[2]; - X.push(x); - Y.push(y); - } else { - var dim = curveDim(x, y, p[1], p[2], p[3], p[4], p[5], p[6]); - X = X[concat](dim.min.x, dim.max.x); - Y = Y[concat](dim.min.y, dim.max.y); - x = p[5]; - y = p[6]; - } - } - var xmin = mmin[apply](0, X), - ymin = mmin[apply](0, Y); - return { - x: xmin, - y: ymin, - width: mmax[apply](0, X) - xmin, - height: mmax[apply](0, Y) - ymin - }; - }, null, function (o) { - return { - x: o.x, - y: o.y, - width: o.width, - height: o.height - }; - }), - pathClone = function (pathArray) { - var res = []; - if (!R.is(pathArray, array) || !R.is(pathArray && pathArray[0], array)) { // rough assumption - pathArray = R.parsePathString(pathArray); - } - for (var i = 0, ii = pathArray.length; i < ii; i++) { - res[i] = []; - for (var j = 0, jj = pathArray[i].length; j < jj; j++) { - res[i][j] = pathArray[i][j]; - } - } - res.toString = R._path2string; - return res; - }, - pathToRelative = R._pathToRelative = cacher(function (pathArray) { - if (!R.is(pathArray, array) || !R.is(pathArray && pathArray[0], array)) { // rough assumption - pathArray = R.parsePathString(pathArray); - } - var res = [], - x = 0, - y = 0, - mx = 0, - my = 0, - start = 0; - if (pathArray[0][0] == "M") { - x = pathArray[0][1]; - y = pathArray[0][2]; - mx = x; - my = y; - start++; - res.push(["M", x, y]); - } - for (var i = start, ii = pathArray.length; i < ii; i++) { - var r = res[i] = [], - pa = pathArray[i]; - if (pa[0] != lowerCase.call(pa[0])) { - r[0] = lowerCase.call(pa[0]); - switch (r[0]) { - case "a": - r[1] = pa[1]; - r[2] = pa[2]; - r[3] = pa[3]; - r[4] = pa[4]; - r[5] = pa[5]; - r[6] = +(pa[6] - x).toFixed(3); - r[7] = +(pa[7] - y).toFixed(3); - break; - case "v": - r[1] = +(pa[1] - y).toFixed(3); - break; - case "m": - mx = pa[1]; - my = pa[2]; - default: - for (var j = 1, jj = pa.length; j < jj; j++) { - r[j] = +(pa[j] - ((j % 2) ? x : y)).toFixed(3); - } - } - } else { - r = res[i] = []; - if (pa[0] == "m") { - mx = pa[1] + x; - my = pa[2] + y; - } - for (var k = 0, kk = pa.length; k < kk; k++) { - res[i][k] = pa[k]; - } - } - var len = res[i].length; - switch (res[i][0]) { - case "z": - x = mx; - y = my; - break; - case "h": - x += +res[i][len - 1]; - break; - case "v": - y += +res[i][len - 1]; - break; - default: - x += +res[i][len - 2]; - y += +res[i][len - 1]; - } - } - res.toString = R._path2string; - return res; - }, 0, pathClone), - pathToAbsolute = R._pathToAbsolute = cacher(function (pathArray) { - if (!R.is(pathArray, array) || !R.is(pathArray && pathArray[0], array)) { // rough assumption - pathArray = R.parsePathString(pathArray); - } - if (!pathArray || !pathArray.length) { - return [["M", 0, 0]]; - } - var res = [], - x = 0, - y = 0, - mx = 0, - my = 0, - start = 0; - if (pathArray[0][0] == "M") { - x = +pathArray[0][1]; - y = +pathArray[0][2]; - mx = x; - my = y; - start++; - res[0] = ["M", x, y]; - } - for (var r, pa, i = start, ii = pathArray.length; i < ii; i++) { - res.push(r = []); - pa = pathArray[i]; - if (pa[0] != upperCase.call(pa[0])) { - r[0] = upperCase.call(pa[0]); - switch (r[0]) { - case "A": - r[1] = pa[1]; - r[2] = pa[2]; - r[3] = pa[3]; - r[4] = pa[4]; - r[5] = pa[5]; - r[6] = +(pa[6] + x); - r[7] = +(pa[7] + y); - break; - case "V": - r[1] = +pa[1] + y; - break; - case "H": - r[1] = +pa[1] + x; - break; - case "R": - var dots = [x, y][concat](pa.slice(1)); - for (var j = 2, jj = dots.length; j < jj; j++) { - dots[j] = +dots[j] + x; - dots[++j] = +dots[j] + y; - } - res.pop(); - res = res[concat](catmullRom2bezier(dots)); - break; - case "M": - mx = +pa[1] + x; - my = +pa[2] + y; - default: - for (j = 1, jj = pa.length; j < jj; j++) { - r[j] = +pa[j] + ((j % 2) ? x : y); - } - } - } else if (pa[0] == "R") { - dots = [x, y][concat](pa.slice(1)); - res.pop(); - res = res[concat](catmullRom2bezier(dots)); - r = ["R"][concat](pa.slice(-2)); - } else { - for (var k = 0, kk = pa.length; k < kk; k++) { - r[k] = pa[k]; - } - } - switch (r[0]) { - case "Z": - x = mx; - y = my; - break; - case "H": - x = r[1]; - break; - case "V": - y = r[1]; - break; - case "M": - mx = r[r.length - 2]; - my = r[r.length - 1]; - default: - x = r[r.length - 2]; - y = r[r.length - 1]; - } - } - res.toString = R._path2string; - return res; - }, null, pathClone), - l2c = function (x1, y1, x2, y2) { - return [x1, y1, x2, y2, x2, y2]; - }, - q2c = function (x1, y1, ax, ay, x2, y2) { - var _13 = 1 / 3, - _23 = 2 / 3; - return [ - _13 * x1 + _23 * ax, - _13 * y1 + _23 * ay, - _13 * x2 + _23 * ax, - _13 * y2 + _23 * ay, - x2, - y2 - ]; - }, - a2c = function (x1, y1, rx, ry, angle, large_arc_flag, sweep_flag, x2, y2, recursive) { - // for more information of where this math came from visit: - // http://www.w3.org/TR/SVG11/implnote.html#ArcImplementationNotes - var _120 = PI * 120 / 180, - rad = PI / 180 * (+angle || 0), - res = [], - xy, - rotate = cacher(function (x, y, rad) { - var X = x * math.cos(rad) - y * math.sin(rad), - Y = x * math.sin(rad) + y * math.cos(rad); - return {x: X, y: Y}; - }); - if (!recursive) { - xy = rotate(x1, y1, -rad); - x1 = xy.x; - y1 = xy.y; - xy = rotate(x2, y2, -rad); - x2 = xy.x; - y2 = xy.y; - var cos = math.cos(PI / 180 * angle), - sin = math.sin(PI / 180 * angle), - x = (x1 - x2) / 2, - y = (y1 - y2) / 2; - var h = (x * x) / (rx * rx) + (y * y) / (ry * ry); - if (h > 1) { - h = math.sqrt(h); - rx = h * rx; - ry = h * ry; - } - var rx2 = rx * rx, - ry2 = ry * ry, - k = (large_arc_flag == sweep_flag ? -1 : 1) * - math.sqrt(abs((rx2 * ry2 - rx2 * y * y - ry2 * x * x) / (rx2 * y * y + ry2 * x * x))), - cx = k * rx * y / ry + (x1 + x2) / 2, - cy = k * -ry * x / rx + (y1 + y2) / 2, - f1 = math.asin(((y1 - cy) / ry).toFixed(9)), - f2 = math.asin(((y2 - cy) / ry).toFixed(9)); - - f1 = x1 < cx ? PI - f1 : f1; - f2 = x2 < cx ? PI - f2 : f2; - f1 < 0 && (f1 = PI * 2 + f1); - f2 < 0 && (f2 = PI * 2 + f2); - if (sweep_flag && f1 > f2) { - f1 = f1 - PI * 2; - } - if (!sweep_flag && f2 > f1) { - f2 = f2 - PI * 2; - } - } else { - f1 = recursive[0]; - f2 = recursive[1]; - cx = recursive[2]; - cy = recursive[3]; - } - var df = f2 - f1; - if (abs(df) > _120) { - var f2old = f2, - x2old = x2, - y2old = y2; - f2 = f1 + _120 * (sweep_flag && f2 > f1 ? 1 : -1); - x2 = cx + rx * math.cos(f2); - y2 = cy + ry * math.sin(f2); - res = a2c(x2, y2, rx, ry, angle, 0, sweep_flag, x2old, y2old, [f2, f2old, cx, cy]); - } - df = f2 - f1; - var c1 = math.cos(f1), - s1 = math.sin(f1), - c2 = math.cos(f2), - s2 = math.sin(f2), - t = math.tan(df / 4), - hx = 4 / 3 * rx * t, - hy = 4 / 3 * ry * t, - m1 = [x1, y1], - m2 = [x1 + hx * s1, y1 - hy * c1], - m3 = [x2 + hx * s2, y2 - hy * c2], - m4 = [x2, y2]; - m2[0] = 2 * m1[0] - m2[0]; - m2[1] = 2 * m1[1] - m2[1]; - if (recursive) { - return [m2, m3, m4][concat](res); - } else { - res = [m2, m3, m4][concat](res).join()[split](","); - var newres = []; - for (var i = 0, ii = res.length; i < ii; i++) { - newres[i] = i % 2 ? rotate(res[i - 1], res[i], rad).y : rotate(res[i], res[i + 1], rad).x; - } - return newres; - } - }, - findDotAtSegment = function (p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y, t) { - var t1 = 1 - t; - return { - x: pow(t1, 3) * p1x + pow(t1, 2) * 3 * t * c1x + t1 * 3 * t * t * c2x + pow(t, 3) * p2x, - y: pow(t1, 3) * p1y + pow(t1, 2) * 3 * t * c1y + t1 * 3 * t * t * c2y + pow(t, 3) * p2y - }; - }, - curveDim = cacher(function (p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y) { - var a = (c2x - 2 * c1x + p1x) - (p2x - 2 * c2x + c1x), - b = 2 * (c1x - p1x) - 2 * (c2x - c1x), - c = p1x - c1x, - t1 = (-b + math.sqrt(b * b - 4 * a * c)) / 2 / a, - t2 = (-b - math.sqrt(b * b - 4 * a * c)) / 2 / a, - y = [p1y, p2y], - x = [p1x, p2x], - dot; - abs(t1) > "1e12" && (t1 = .5); - abs(t2) > "1e12" && (t2 = .5); - if (t1 > 0 && t1 < 1) { - dot = findDotAtSegment(p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y, t1); - x.push(dot.x); - y.push(dot.y); - } - if (t2 > 0 && t2 < 1) { - dot = findDotAtSegment(p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y, t2); - x.push(dot.x); - y.push(dot.y); - } - a = (c2y - 2 * c1y + p1y) - (p2y - 2 * c2y + c1y); - b = 2 * (c1y - p1y) - 2 * (c2y - c1y); - c = p1y - c1y; - t1 = (-b + math.sqrt(b * b - 4 * a * c)) / 2 / a; - t2 = (-b - math.sqrt(b * b - 4 * a * c)) / 2 / a; - abs(t1) > "1e12" && (t1 = .5); - abs(t2) > "1e12" && (t2 = .5); - if (t1 > 0 && t1 < 1) { - dot = findDotAtSegment(p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y, t1); - x.push(dot.x); - y.push(dot.y); - } - if (t2 > 0 && t2 < 1) { - dot = findDotAtSegment(p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y, t2); - x.push(dot.x); - y.push(dot.y); - } - return { - min: {x: mmin[apply](0, x), y: mmin[apply](0, y)}, - max: {x: mmax[apply](0, x), y: mmax[apply](0, y)} - }; - }), - path2curve = R._path2curve = cacher(function (path, path2) { - var p = pathToAbsolute(path), - p2 = path2 && pathToAbsolute(path2), - attrs = {x: 0, y: 0, bx: 0, by: 0, X: 0, Y: 0, qx: null, qy: null}, - attrs2 = {x: 0, y: 0, bx: 0, by: 0, X: 0, Y: 0, qx: null, qy: null}, - processPath = function (path, d) { - var nx, ny; - if (!path) { - return ["C", d.x, d.y, d.x, d.y, d.x, d.y]; - } - !(path[0] in {T:1, Q:1}) && (d.qx = d.qy = null); - switch (path[0]) { - case "M": - d.X = path[1]; - d.Y = path[2]; - break; - case "A": - path = ["C"][concat](a2c[apply](0, [d.x, d.y][concat](path.slice(1)))); - break; - case "S": - nx = d.x + (d.x - (d.bx || d.x)); - ny = d.y + (d.y - (d.by || d.y)); - path = ["C", nx, ny][concat](path.slice(1)); - break; - case "T": - d.qx = d.x + (d.x - (d.qx || d.x)); - d.qy = d.y + (d.y - (d.qy || d.y)); - path = ["C"][concat](q2c(d.x, d.y, d.qx, d.qy, path[1], path[2])); - break; - case "Q": - d.qx = path[1]; - d.qy = path[2]; - path = ["C"][concat](q2c(d.x, d.y, path[1], path[2], path[3], path[4])); - break; - case "L": - path = ["C"][concat](l2c(d.x, d.y, path[1], path[2])); - break; - case "H": - path = ["C"][concat](l2c(d.x, d.y, path[1], d.y)); - break; - case "V": - path = ["C"][concat](l2c(d.x, d.y, d.x, path[1])); - break; - case "Z": - path = ["C"][concat](l2c(d.x, d.y, d.X, d.Y)); - break; - } - return path; - }, - fixArc = function (pp, i) { - if (pp[i].length > 7) { - pp[i].shift(); - var pi = pp[i]; - while (pi.length) { - pp.splice(i++, 0, ["C"][concat](pi.splice(0, 6))); - } - pp.splice(i, 1); - ii = mmax(p.length, p2 && p2.length || 0); - } - }, - fixM = function (path1, path2, a1, a2, i) { - if (path1 && path2 && path1[i][0] == "M" && path2[i][0] != "M") { - path2.splice(i, 0, ["M", a2.x, a2.y]); - a1.bx = 0; - a1.by = 0; - a1.x = path1[i][1]; - a1.y = path1[i][2]; - ii = mmax(p.length, p2 && p2.length || 0); - } - }; - for (var i = 0, ii = mmax(p.length, p2 && p2.length || 0); i < ii; i++) { - p[i] = processPath(p[i], attrs); - fixArc(p, i); - p2 && (p2[i] = processPath(p2[i], attrs2)); - p2 && fixArc(p2, i); - fixM(p, p2, attrs, attrs2, i); - fixM(p2, p, attrs2, attrs, i); - var seg = p[i], - seg2 = p2 && p2[i], - seglen = seg.length, - seg2len = p2 && seg2.length; - attrs.x = seg[seglen - 2]; - attrs.y = seg[seglen - 1]; - attrs.bx = toFloat(seg[seglen - 4]) || attrs.x; - attrs.by = toFloat(seg[seglen - 3]) || attrs.y; - attrs2.bx = p2 && (toFloat(seg2[seg2len - 4]) || attrs2.x); - attrs2.by = p2 && (toFloat(seg2[seg2len - 3]) || attrs2.y); - attrs2.x = p2 && seg2[seg2len - 2]; - attrs2.y = p2 && seg2[seg2len - 1]; - } - return p2 ? [p, p2] : p; - }, null, pathClone), - parseDots = R._parseDots = cacher(function (gradient) { - var dots = []; - for (var i = 0, ii = gradient.length; i < ii; i++) { - var dot = {}, - par = gradient[i].match(/^([^:]*):?([\d\.]*)/); - dot.color = R.getRGB(par[1]); - if (dot.color.error) { - return null; - } - dot.color = dot.color.hex; - par[2] && (dot.offset = par[2] + "%"); - dots.push(dot); - } - for (i = 1, ii = dots.length - 1; i < ii; i++) { - if (!dots[i].offset) { - var start = toFloat(dots[i - 1].offset || 0), - end = 0; - for (var j = i + 1; j < ii; j++) { - if (dots[j].offset) { - end = dots[j].offset; - break; - } - } - if (!end) { - end = 100; - j = ii; - } - end = toFloat(end); - var d = (end - start) / (j - i + 1); - for (; i < j; i++) { - start += d; - dots[i].offset = start + "%"; - } - } - } - return dots; - }), - tear = R._tear = function (el, paper) { - el == paper.top && (paper.top = el.prev); - el == paper.bottom && (paper.bottom = el.next); - el.next && (el.next.prev = el.prev); - el.prev && (el.prev.next = el.next); - }, - tofront = R._tofront = function (el, paper) { - if (paper.top === el) { - return; - } - tear(el, paper); - el.next = null; - el.prev = paper.top; - paper.top.next = el; - paper.top = el; - }, - toback = R._toback = function (el, paper) { - if (paper.bottom === el) { - return; - } - tear(el, paper); - el.next = paper.bottom; - el.prev = null; - paper.bottom.prev = el; - paper.bottom = el; - }, - insertafter = R._insertafter = function (el, el2, paper) { - tear(el, paper); - el2 == paper.top && (paper.top = el); - el2.next && (el2.next.prev = el); - el.next = el2.next; - el.prev = el2; - el2.next = el; - }, - insertbefore = R._insertbefore = function (el, el2, paper) { - tear(el, paper); - el2 == paper.bottom && (paper.bottom = el); - el2.prev && (el2.prev.next = el); - el.prev = el2.prev; - el2.prev = el; - el.next = el2; - }, - extractTransform = R._extractTransform = function (el, tstr) { - if (tstr == null) { - return el._.transform; - } - tstr = Str(tstr).replace(/\.{3}|\u2026/g, el._.transform || E); - var tdata = R.parseTransformString(tstr), - deg = 0, - dx = 0, - dy = 0, - sx = 1, - sy = 1, - _ = el._, - m = new Matrix; - _.transform = tdata || []; - if (tdata) { - for (var i = 0, ii = tdata.length; i < ii; i++) { - var t = tdata[i], - tlen = t.length, - command = Str(t[0]).toLowerCase(), - absolute = t[0] != command, - inver = absolute ? m.invert() : 0, - x1, - y1, - x2, - y2, - bb; - if (command == "t" && tlen == 3) { - if (absolute) { - x1 = inver.x(0, 0); - y1 = inver.y(0, 0); - x2 = inver.x(t[1], t[2]); - y2 = inver.y(t[1], t[2]); - m.translate(x2 - x1, y2 - y1); - } else { - m.translate(t[1], t[2]); - } - } else if (command == "r") { - if (tlen == 2) { - bb = bb || el.getBBox(1); - m.rotate(t[1], bb.x + bb.width / 2, bb.y + bb.height / 2); - deg += t[1]; - } else if (tlen == 4) { - if (absolute) { - x2 = inver.x(t[2], t[3]); - y2 = inver.y(t[2], t[3]); - m.rotate(t[1], x2, y2); - } else { - m.rotate(t[1], t[2], t[3]); - } - deg += t[1]; - } - } else if (command == "s") { - if (tlen == 2 || tlen == 3) { - bb = bb || el.getBBox(1); - m.scale(t[1], t[tlen - 1], bb.x + bb.width / 2, bb.y + bb.height / 2); - sx *= t[1]; - sy *= t[tlen - 1]; - } else if (tlen == 5) { - if (absolute) { - x2 = inver.x(t[3], t[4]); - y2 = inver.y(t[3], t[4]); - m.scale(t[1], t[2], x2, y2); - } else { - m.scale(t[1], t[2], t[3], t[4]); - } - sx *= t[1]; - sy *= t[2]; - } - } else if (command == "m" && tlen == 7) { - m.add(t[1], t[2], t[3], t[4], t[5], t[6]); - } - _.dirtyT = 1; - el.matrix = m; - } - } - - el.matrix = m; - - _.sx = sx; - _.sy = sy; - _.deg = deg; - _.dx = dx = m.e; - _.dy = dy = m.f; - - if (sx == 1 && sy == 1 && !deg && _.bbox) { - _.bbox.x += +dx; - _.bbox.y += +dy; - } else { - _.dirtyT = 1; - } - }, - getEmpty = function (item) { - var l = item[0]; - switch (l.toLowerCase()) { - case "t": return [l, 0, 0]; - case "m": return [l, 1, 0, 0, 1, 0, 0]; - case "r": if (item.length == 4) { - return [l, 0, item[2], item[3]]; - } else { - return [l, 0]; - } - case "s": if (item.length == 5) { - return [l, 1, 1, item[3], item[4]]; - } else if (item.length == 3) { - return [l, 1, 1]; - } else { - return [l, 1]; - } - } - }, - equaliseTransform = R._equaliseTransform = function (t1, t2) { - t2 = Str(t2).replace(/\.{3}|\u2026/g, t1); - t1 = R.parseTransformString(t1) || []; - t2 = R.parseTransformString(t2) || []; - var maxlength = mmax(t1.length, t2.length), - from = [], - to = [], - i = 0, j, jj, - tt1, tt2; - for (; i < maxlength; i++) { - tt1 = t1[i] || getEmpty(t2[i]); - tt2 = t2[i] || getEmpty(tt1); - if ((tt1[0] != tt2[0]) || - (tt1[0].toLowerCase() == "r" && (tt1[2] != tt2[2] || tt1[3] != tt2[3])) || - (tt1[0].toLowerCase() == "s" && (tt1[3] != tt2[3] || tt1[4] != tt2[4])) - ) { - return; - } - from[i] = []; - to[i] = []; - for (j = 0, jj = mmax(tt1.length, tt2.length); j < jj; j++) { - j in tt1 && (from[i][j] = tt1[j]); - j in tt2 && (to[i][j] = tt2[j]); - } - } - return { - from: from, - to: to - }; - }; - R._getContainer = function (x, y, w, h) { - var container; - container = h == null && !R.is(x, "object") ? g.doc.getElementById(x) : x; - if (container == null) { - return; - } - if (container.tagName) { - if (y == null) { - return { - container: container, - width: container.style.pixelWidth || container.offsetWidth, - height: container.style.pixelHeight || container.offsetHeight - }; - } else { - return { - container: container, - width: y, - height: w - }; - } - } - return { - container: 1, - x: x, - y: y, - width: w, - height: h - }; - }; - - R.pathToRelative = pathToRelative; - R._engine = {}; - - R.path2curve = path2curve; - - R.matrix = function (a, b, c, d, e, f) { - return new Matrix(a, b, c, d, e, f); - }; - function Matrix(a, b, c, d, e, f) { - if (a != null) { - this.a = +a; - this.b = +b; - this.c = +c; - this.d = +d; - this.e = +e; - this.f = +f; - } else { - this.a = 1; - this.b = 0; - this.c = 0; - this.d = 1; - this.e = 0; - this.f = 0; - } - } - (function (matrixproto) { - - matrixproto.add = function (a, b, c, d, e, f) { - var out = [[], [], []], - m = [[this.a, this.c, this.e], [this.b, this.d, this.f], [0, 0, 1]], - matrix = [[a, c, e], [b, d, f], [0, 0, 1]], - x, y, z, res; - - if (a && a instanceof Matrix) { - matrix = [[a.a, a.c, a.e], [a.b, a.d, a.f], [0, 0, 1]]; - } - - for (x = 0; x < 3; x++) { - for (y = 0; y < 3; y++) { - res = 0; - for (z = 0; z < 3; z++) { - res += m[x][z] * matrix[z][y]; - } - out[x][y] = res; - } - } - this.a = out[0][0]; - this.b = out[1][0]; - this.c = out[0][1]; - this.d = out[1][1]; - this.e = out[0][2]; - this.f = out[1][2]; - }; - - matrixproto.invert = function () { - var me = this, - x = me.a * me.d - me.b * me.c; - return new Matrix(me.d / x, -me.b / x, -me.c / x, me.a / x, (me.c * me.f - me.d * me.e) / x, (me.b * me.e - me.a * me.f) / x); - }; - - matrixproto.clone = function () { - return new Matrix(this.a, this.b, this.c, this.d, this.e, this.f); - }; - - matrixproto.translate = function (x, y) { - this.add(1, 0, 0, 1, x, y); - }; - - matrixproto.scale = function (x, y, cx, cy) { - y == null && (y = x); - (cx || cy) && this.add(1, 0, 0, 1, cx, cy); - this.add(x, 0, 0, y, 0, 0); - (cx || cy) && this.add(1, 0, 0, 1, -cx, -cy); - }; - - matrixproto.rotate = function (a, x, y) { - a = R.rad(a); - x = x || 0; - y = y || 0; - var cos = +math.cos(a).toFixed(9), - sin = +math.sin(a).toFixed(9); - this.add(cos, sin, -sin, cos, x, y); - this.add(1, 0, 0, 1, -x, -y); - }; - - matrixproto.x = function (x, y) { - return x * this.a + y * this.c + this.e; - }; - - matrixproto.y = function (x, y) { - return x * this.b + y * this.d + this.f; - }; - matrixproto.get = function (i) { - return +this[Str.fromCharCode(97 + i)].toFixed(4); - }; - matrixproto.toString = function () { - return R.svg ? - "matrix(" + [this.get(0), this.get(1), this.get(2), this.get(3), this.get(4), this.get(5)].join() + ")" : - [this.get(0), this.get(2), this.get(1), this.get(3), 0, 0].join(); - }; - matrixproto.toFilter = function () { - return "progid:DXImageTransform.Microsoft.Matrix(M11=" + this.get(0) + - ", M12=" + this.get(2) + ", M21=" + this.get(1) + ", M22=" + this.get(3) + - ", Dx=" + this.get(4) + ", Dy=" + this.get(5) + ", sizingmethod='auto expand')"; - }; - matrixproto.offset = function () { - return [this.e.toFixed(4), this.f.toFixed(4)]; - }; - function norm(a) { - return a[0] * a[0] + a[1] * a[1]; - } - function normalize(a) { - var mag = math.sqrt(norm(a)); - a[0] && (a[0] /= mag); - a[1] && (a[1] /= mag); - } - - matrixproto.split = function () { - var out = {}; - // translation - out.dx = this.e; - out.dy = this.f; - - // scale and shear - var row = [[this.a, this.c], [this.b, this.d]]; - out.scalex = math.sqrt(norm(row[0])); - normalize(row[0]); - - out.shear = row[0][0] * row[1][0] + row[0][1] * row[1][1]; - row[1] = [row[1][0] - row[0][0] * out.shear, row[1][1] - row[0][1] * out.shear]; - - out.scaley = math.sqrt(norm(row[1])); - normalize(row[1]); - out.shear /= out.scaley; - - // rotation - var sin = -row[0][1], - cos = row[1][1]; - if (cos < 0) { - out.rotate = R.deg(math.acos(cos)); - if (sin < 0) { - out.rotate = 360 - out.rotate; - } - } else { - out.rotate = R.deg(math.asin(sin)); - } - - out.isSimple = !+out.shear.toFixed(9) && (out.scalex.toFixed(9) == out.scaley.toFixed(9) || !out.rotate); - out.isSuperSimple = !+out.shear.toFixed(9) && out.scalex.toFixed(9) == out.scaley.toFixed(9) && !out.rotate; - out.noRotation = !+out.shear.toFixed(9) && !out.rotate; - return out; - }; - - matrixproto.toTransformString = function (shorter) { - var s = shorter || this[split](); - if (s.isSimple) { - s.scalex = +s.scalex.toFixed(4); - s.scaley = +s.scaley.toFixed(4); - s.rotate = +s.rotate.toFixed(4); - return (s.dx && s.dy ? "t" + [s.dx, s.dy] : E) + - (s.scalex != 1 || s.scaley != 1 ? "s" + [s.scalex, s.scaley, 0, 0] : E) + - (s.rotate ? "r" + [s.rotate, 0, 0] : E); - } else { - return "m" + [this.get(0), this.get(1), this.get(2), this.get(3), this.get(4), this.get(5)]; - } - }; - })(Matrix.prototype); - - // WebKit rendering bug workaround method - var version = navigator.userAgent.match(/Version\/(.*?)\s/) || navigator.userAgent.match(/Chrome\/(\d+)/); - if ((navigator.vendor == "Apple Computer, Inc.") && (version && version[1] < 4 || navigator.platform.slice(0, 2) == "iP") || - (navigator.vendor == "Google Inc." && version && version[1] < 8)) { - - paperproto.safari = function () { - var rect = this.rect(-99, -99, this.width + 99, this.height + 99).attr({stroke: "none"}); - setTimeout(function () {rect.remove();}); - }; - } else { - paperproto.safari = fun; - } - - var preventDefault = function () { - this.returnValue = false; - }, - preventTouch = function () { - return this.originalEvent.preventDefault(); - }, - stopPropagation = function () { - this.cancelBubble = true; - }, - stopTouch = function () { - return this.originalEvent.stopPropagation(); - }, - addEvent = (function () { - if (g.doc.addEventListener) { - return function (obj, type, fn, element) { - var realName = supportsTouch && touchMap[type] ? touchMap[type] : type, - f = function (e) { - var scrollY = g.doc.documentElement.scrollTop || g.doc.body.scrollTop, - scrollX = g.doc.documentElement.scrollLeft || g.doc.body.scrollLeft, - x = e.clientX + scrollX, - y = e.clientY + scrollY; - if (supportsTouch && touchMap[has](type)) { - for (var i = 0, ii = e.targetTouches && e.targetTouches.length; i < ii; i++) { - if (e.targetTouches[i].target == obj) { - var olde = e; - e = e.targetTouches[i]; - e.originalEvent = olde; - e.preventDefault = preventTouch; - e.stopPropagation = stopTouch; - break; - } - } - } - return fn.call(element, e, x, y); - }; - obj.addEventListener(realName, f, false); - return function () { - obj.removeEventListener(realName, f, false); - return true; - }; - }; - } else if (g.doc.attachEvent) { - return function (obj, type, fn, element) { - var f = function (e) { - e = e || g.win.event; - var scrollY = g.doc.documentElement.scrollTop || g.doc.body.scrollTop, - scrollX = g.doc.documentElement.scrollLeft || g.doc.body.scrollLeft, - x = e.clientX + scrollX, - y = e.clientY + scrollY; - e.preventDefault = e.preventDefault || preventDefault; - e.stopPropagation = e.stopPropagation || stopPropagation; - return fn.call(element, e, x, y); - }; - obj.attachEvent("on" + type, f); - var detacher = function () { - obj.detachEvent("on" + type, f); - return true; - }; - return detacher; - }; - } - })(), - drag = [], - dragMove = function (e) { - var x = e.clientX, - y = e.clientY, - scrollY = g.doc.documentElement.scrollTop || g.doc.body.scrollTop, - scrollX = g.doc.documentElement.scrollLeft || g.doc.body.scrollLeft, - dragi, - j = drag.length; - while (j--) { - dragi = drag[j]; - if (supportsTouch) { - var i = e.touches.length, - touch; - while (i--) { - touch = e.touches[i]; - if (touch.identifier == dragi.el._drag.id) { - x = touch.clientX; - y = touch.clientY; - (e.originalEvent ? e.originalEvent : e).preventDefault(); - break; - } - } - } else { - e.preventDefault(); - } - var node = dragi.el.node, - o, - next = node.nextSibling, - parent = node.parentNode, - display = node.style.display; - g.win.opera && parent.removeChild(node); - node.style.display = "none"; - o = dragi.el.paper.getElementByPoint(x, y); - node.style.display = display; - g.win.opera && (next ? parent.insertBefore(node, next) : parent.appendChild(node)); - o && eve("drag.over." + dragi.el.id, dragi.el, o); - x += scrollX; - y += scrollY; - eve("drag.move." + dragi.el.id, dragi.move_scope || dragi.el, x - dragi.el._drag.x, y - dragi.el._drag.y, x, y, e); - } - }, - dragUp = function (e) { - R.unmousemove(dragMove).unmouseup(dragUp); - var i = drag.length, - dragi; - while (i--) { - dragi = drag[i]; - dragi.el._drag = {}; - eve("drag.end." + dragi.el.id, dragi.end_scope || dragi.start_scope || dragi.move_scope || dragi.el, e); - } - drag = []; - }, - - elproto = R.el = {}; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - for (var i = events.length; i--;) { - (function (eventName) { - R[eventName] = elproto[eventName] = function (fn, scope) { - if (R.is(fn, "function")) { - this.events = this.events || []; - this.events.push({name: eventName, f: fn, unbind: addEvent(this.shape || this.node || g.doc, eventName, fn, scope || this)}); - } - return this; - }; - R["un" + eventName] = elproto["un" + eventName] = function (fn) { - var events = this.events, - l = events.length; - while (l--) if (events[l].name == eventName && events[l].f == fn) { - events[l].unbind(); - events.splice(l, 1); - !events.length && delete this.events; - return this; - } - return this; - }; - })(events[i]); - } - - - elproto.data = function (key, value) { - var data = eldata[this.id] = eldata[this.id] || {}; - if (arguments.length == 1) { - if (R.is(key, "object")) { - for (var i in key) if (key[has](i)) { - this.data(i, key[i]); - } - return this; - } - eve("data.get." + this.id, this, data[key], key); - return data[key]; - } - data[key] = value; - eve("data.set." + this.id, this, value, key); - return this; - }; - - elproto.removeData = function (key) { - if (key == null) { - eldata[this.id] = {}; - } else { - eldata[this.id] && delete eldata[this.id][key]; - } - return this; - }; - - elproto.hover = function (f_in, f_out, scope_in, scope_out) { - return this.mouseover(f_in, scope_in).mouseout(f_out, scope_out || scope_in); - }; - - elproto.unhover = function (f_in, f_out) { - return this.unmouseover(f_in).unmouseout(f_out); - }; - var draggable = []; - - elproto.drag = function (onmove, onstart, onend, move_scope, start_scope, end_scope) { - function start(e) { - (e.originalEvent || e).preventDefault(); - var scrollY = g.doc.documentElement.scrollTop || g.doc.body.scrollTop, - scrollX = g.doc.documentElement.scrollLeft || g.doc.body.scrollLeft; - this._drag.x = e.clientX + scrollX; - this._drag.y = e.clientY + scrollY; - this._drag.id = e.identifier; - !drag.length && R.mousemove(dragMove).mouseup(dragUp); - drag.push({el: this, move_scope: move_scope, start_scope: start_scope, end_scope: end_scope}); - onstart && eve.on("drag.start." + this.id, onstart); - onmove && eve.on("drag.move." + this.id, onmove); - onend && eve.on("drag.end." + this.id, onend); - eve("drag.start." + this.id, start_scope || move_scope || this, e.clientX + scrollX, e.clientY + scrollY, e); - } - this._drag = {}; - draggable.push({el: this, start: start}); - this.mousedown(start); - return this; - }; - - elproto.onDragOver = function (f) { - f ? eve.on("drag.over." + this.id, f) : eve.unbind("drag.over." + this.id); - }; - - elproto.undrag = function () { - var i = draggable.length; - while (i--) if (draggable[i].el == this) { - this.unmousedown(draggable[i].start); - draggable.splice(i, 1); - eve.unbind("drag.*." + this.id); - } - !draggable.length && R.unmousemove(dragMove).unmouseup(dragUp); - }; - - paperproto.circle = function (x, y, r) { - var out = R._engine.circle(this, x || 0, y || 0, r || 0); - this.__set__ && this.__set__.push(out); - return out; - }; - - paperproto.rect = function (x, y, w, h, r) { - var out = R._engine.rect(this, x || 0, y || 0, w || 0, h || 0, r || 0); - this.__set__ && this.__set__.push(out); - return out; - }; - - paperproto.ellipse = function (x, y, rx, ry) { - var out = R._engine.ellipse(this, x || 0, y || 0, rx || 0, ry || 0); - this.__set__ && this.__set__.push(out); - return out; - }; - - paperproto.path = function (pathString) { - pathString && !R.is(pathString, string) && !R.is(pathString[0], array) && (pathString += E); - var out = R._engine.path(R.format[apply](R, arguments), this); - this.__set__ && this.__set__.push(out); - return out; - }; - - paperproto.image = function (src, x, y, w, h) { - var out = R._engine.image(this, src || "about:blank", x || 0, y || 0, w || 0, h || 0); - this.__set__ && this.__set__.push(out); - return out; - }; - - paperproto.text = function (x, y, text) { - var out = R._engine.text(this, x || 0, y || 0, Str(text)); - this.__set__ && this.__set__.push(out); - return out; - }; - - paperproto.set = function (itemsArray) { - !R.is(itemsArray, "array") && (itemsArray = Array.prototype.splice.call(arguments, 0, arguments.length)); - var out = new Set(itemsArray); - this.__set__ && this.__set__.push(out); - return out; - }; - - paperproto.setStart = function (set) { - this.__set__ = set || this.set(); - }; - - paperproto.setFinish = function (set) { - var out = this.__set__; - delete this.__set__; - return out; - }; - - paperproto.setSize = function (width, height) { - return R._engine.setSize.call(this, width, height); - }; - - paperproto.setViewBox = function (x, y, w, h, fit) { - return R._engine.setViewBox.call(this, x, y, w, h, fit); - }; - - - paperproto.top = paperproto.bottom = null; - - paperproto.raphael = R; - var getOffset = function (elem) { - var box = elem.getBoundingClientRect(), - doc = elem.ownerDocument, - body = doc.body, - docElem = doc.documentElement, - clientTop = docElem.clientTop || body.clientTop || 0, clientLeft = docElem.clientLeft || body.clientLeft || 0, - top = box.top + (g.win.pageYOffset || docElem.scrollTop || body.scrollTop ) - clientTop, - left = box.left + (g.win.pageXOffset || docElem.scrollLeft || body.scrollLeft) - clientLeft; - return { - y: top, - x: left - }; - }; - - paperproto.getElementByPoint = function (x, y) { - var paper = this, - svg = paper.canvas, - target = g.doc.elementFromPoint(x, y); - if (g.win.opera && target.tagName == "svg") { - var so = getOffset(svg), - sr = svg.createSVGRect(); - sr.x = x - so.x; - sr.y = y - so.y; - sr.width = sr.height = 1; - var hits = svg.getIntersectionList(sr, null); - if (hits.length) { - target = hits[hits.length - 1]; - } - } - if (!target) { - return null; - } - while (target.parentNode && target != svg.parentNode && !target.raphael) { - target = target.parentNode; - } - target == paper.canvas.parentNode && (target = svg); - target = target && target.raphael ? paper.getById(target.raphaelid) : null; - return target; - }; - - paperproto.getById = function (id) { - var bot = this.bottom; - while (bot) { - if (bot.id == id) { - return bot; - } - bot = bot.next; - } - return null; - }; - - paperproto.forEach = function (callback, thisArg) { - var bot = this.bottom; - while (bot) { - if (callback.call(thisArg, bot) === false) { - return this; - } - bot = bot.next; - } - return this; - }; - function x_y() { - return this.x + S + this.y; - } - function x_y_w_h() { - return this.x + S + this.y + S + this.width + " \xd7 " + this.height; - } - - elproto.getBBox = function (isWithoutTransform) { - if (this.removed) { - return {}; - } - var _ = this._; - if (isWithoutTransform) { - if (_.dirty || !_.bboxwt) { - this.realPath = getPath[this.type](this); - _.bboxwt = pathDimensions(this.realPath); - _.bboxwt.toString = x_y_w_h; - _.dirty = 0; - } - return _.bboxwt; - } - if (_.dirty || _.dirtyT || !_.bbox) { - if (_.dirty || !this.realPath) { - _.bboxwt = 0; - this.realPath = getPath[this.type](this); - } - _.bbox = pathDimensions(mapPath(this.realPath, this.matrix)); - _.bbox.toString = x_y_w_h; - _.dirty = _.dirtyT = 0; - } - return _.bbox; - }; - - elproto.clone = function () { - if (this.removed) { - return null; - } - var out = this.paper[this.type]().attr(this.attr()); - this.__set__ && this.__set__.push(out); - return out; - }; - - elproto.glow = function (glow) { - if (this.type == "text") { - return null; - } - glow = glow || {}; - var s = { - width: (glow.width || 10) + (+this.attr("stroke-width") || 1), - fill: glow.fill || false, - opacity: glow.opacity || .5, - offsetx: glow.offsetx || 0, - offsety: glow.offsety || 0, - color: glow.color || "#000" - }, - c = s.width / 2, - r = this.paper, - out = r.set(), - path = this.realPath || getPath[this.type](this); - path = this.matrix ? mapPath(path, this.matrix) : path; - for (var i = 1; i < c + 1; i++) { - out.push(r.path(path).attr({ - stroke: s.color, - fill: s.fill ? s.color : "none", - "stroke-linejoin": "round", - "stroke-linecap": "round", - "stroke-width": +(s.width / c * i).toFixed(3), - opacity: +(s.opacity / c).toFixed(3) - })); - } - return out.insertBefore(this).translate(s.offsetx, s.offsety); - }; - var curveslengths = {}, - getPointAtSegmentLength = function (p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y, length) { - var len = 0, - precision = 100, - name = [p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y].join(), - cache = curveslengths[name], - old, dot; - !cache && (curveslengths[name] = cache = {data: []}); - cache.timer && clearTimeout(cache.timer); - cache.timer = setTimeout(function () {delete curveslengths[name];}, 2e3); - if (length != null && !cache.precision) { - var total = getPointAtSegmentLength(p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y); - cache.precision = ~~total * 10; - cache.data = []; - } - precision = cache.precision || precision; - for (var i = 0; i < precision + 1; i++) { - if (cache.data[i * precision]) { - dot = cache.data[i * precision]; - } else { - dot = R.findDotsAtSegment(p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y, i / precision); - cache.data[i * precision] = dot; - } - i && (len += pow(pow(old.x - dot.x, 2) + pow(old.y - dot.y, 2), .5)); - if (length != null && len >= length) { - return dot; - } - old = dot; - } - if (length == null) { - return len; - } - }, - getLengthFactory = function (istotal, subpath) { - return function (path, length, onlystart) { - path = path2curve(path); - var x, y, p, l, sp = "", subpaths = {}, point, - len = 0; - for (var i = 0, ii = path.length; i < ii; i++) { - p = path[i]; - if (p[0] == "M") { - x = +p[1]; - y = +p[2]; - } else { - l = getPointAtSegmentLength(x, y, p[1], p[2], p[3], p[4], p[5], p[6]); - if (len + l > length) { - if (subpath && !subpaths.start) { - point = getPointAtSegmentLength(x, y, p[1], p[2], p[3], p[4], p[5], p[6], length - len); - sp += ["C" + point.start.x, point.start.y, point.m.x, point.m.y, point.x, point.y]; - if (onlystart) {return sp;} - subpaths.start = sp; - sp = ["M" + point.x, point.y + "C" + point.n.x, point.n.y, point.end.x, point.end.y, p[5], p[6]].join(); - len += l; - x = +p[5]; - y = +p[6]; - continue; - } - if (!istotal && !subpath) { - point = getPointAtSegmentLength(x, y, p[1], p[2], p[3], p[4], p[5], p[6], length - len); - return {x: point.x, y: point.y, alpha: point.alpha}; - } - } - len += l; - x = +p[5]; - y = +p[6]; - } - sp += p.shift() + p; - } - subpaths.end = sp; - point = istotal ? len : subpath ? subpaths : R.findDotsAtSegment(x, y, p[0], p[1], p[2], p[3], p[4], p[5], 1); - point.alpha && (point = {x: point.x, y: point.y, alpha: point.alpha}); - return point; - }; - }; - var getTotalLength = getLengthFactory(1), - getPointAtLength = getLengthFactory(), - getSubpathsAtLength = getLengthFactory(0, 1); - - R.getTotalLength = getTotalLength; - - R.getPointAtLength = getPointAtLength; - - R.getSubpath = function (path, from, to) { - if (this.getTotalLength(path) - to < 1e-6) { - return getSubpathsAtLength(path, from).end; - } - var a = getSubpathsAtLength(path, to, 1); - return from ? getSubpathsAtLength(a, from).end : a; - }; - - elproto.getTotalLength = function () { - if (this.type != "path") {return;} - if (this.node.getTotalLength) { - return this.node.getTotalLength(); - } - return getTotalLength(this.attrs.path); - }; - - elproto.getPointAtLength = function (length) { - if (this.type != "path") {return;} - return getPointAtLength(this.attrs.path, length); - }; - - elproto.getSubpath = function (from, to) { - if (this.type != "path") {return;} - return R.getSubpath(this.attrs.path, from, to); - }; - - var ef = R.easing_formulas = { - linear: function (n) { - return n; - }, - "<": function (n) { - return pow(n, 1.7); - }, - ">": function (n) { - return pow(n, .48); - }, - "<>": function (n) { - var q = .48 - n / 1.04, - Q = math.sqrt(.1734 + q * q), - x = Q - q, - X = pow(abs(x), 1 / 3) * (x < 0 ? -1 : 1), - y = -Q - q, - Y = pow(abs(y), 1 / 3) * (y < 0 ? -1 : 1), - t = X + Y + .5; - return (1 - t) * 3 * t * t + t * t * t; - }, - backIn: function (n) { - var s = 1.70158; - return n * n * ((s + 1) * n - s); - }, - backOut: function (n) { - n = n - 1; - var s = 1.70158; - return n * n * ((s + 1) * n + s) + 1; - }, - elastic: function (n) { - if (n == !!n) { - return n; - } - return pow(2, -10 * n) * math.sin((n - .075) * (2 * PI) / .3) + 1; - }, - bounce: function (n) { - var s = 7.5625, - p = 2.75, - l; - if (n < (1 / p)) { - l = s * n * n; - } else { - if (n < (2 / p)) { - n -= (1.5 / p); - l = s * n * n + .75; - } else { - if (n < (2.5 / p)) { - n -= (2.25 / p); - l = s * n * n + .9375; - } else { - n -= (2.625 / p); - l = s * n * n + .984375; - } - } - } - return l; - } - }; - ef.easeIn = ef["ease-in"] = ef["<"]; - ef.easeOut = ef["ease-out"] = ef[">"]; - ef.easeInOut = ef["ease-in-out"] = ef["<>"]; - ef["back-in"] = ef.backIn; - ef["back-out"] = ef.backOut; - - var animationElements = [], - requestAnimFrame = window.requestAnimationFrame || - window.webkitRequestAnimationFrame || - window.mozRequestAnimationFrame || - window.oRequestAnimationFrame || - window.msRequestAnimationFrame || - function (callback) { - setTimeout(callback, 16); - }, - animation = function () { - var Now = +new Date, - l = 0; - for (; l < animationElements.length; l++) { - var e = animationElements[l]; - if (e.el.removed || e.paused) { - continue; - } - var time = Now - e.start, - ms = e.ms, - easing = e.easing, - from = e.from, - diff = e.diff, - to = e.to, - t = e.t, - that = e.el, - set = {}, - now, - init = {}, - key; - if (e.initstatus) { - time = (e.initstatus * e.anim.top - e.prev) / (e.percent - e.prev) * ms; - e.status = e.initstatus; - delete e.initstatus; - e.stop && animationElements.splice(l--, 1); - } else { - e.status = (e.prev + (e.percent - e.prev) * (time / ms)) / e.anim.top; - } - if (time < 0) { - continue; - } - if (time < ms) { - var pos = easing(time / ms); - for (var attr in from) if (from[has](attr)) { - switch (availableAnimAttrs[attr]) { - case nu: - now = +from[attr] + pos * ms * diff[attr]; - break; - case "colour": - now = "rgb(" + [ - upto255(round(from[attr].r + pos * ms * diff[attr].r)), - upto255(round(from[attr].g + pos * ms * diff[attr].g)), - upto255(round(from[attr].b + pos * ms * diff[attr].b)) - ].join(",") + ")"; - break; - case "path": - now = []; - for (var i = 0, ii = from[attr].length; i < ii; i++) { - now[i] = [from[attr][i][0]]; - for (var j = 1, jj = from[attr][i].length; j < jj; j++) { - now[i][j] = +from[attr][i][j] + pos * ms * diff[attr][i][j]; - } - now[i] = now[i].join(S); - } - now = now.join(S); - break; - case "transform": - if (diff[attr].real) { - now = []; - for (i = 0, ii = from[attr].length; i < ii; i++) { - now[i] = [from[attr][i][0]]; - for (j = 1, jj = from[attr][i].length; j < jj; j++) { - now[i][j] = from[attr][i][j] + pos * ms * diff[attr][i][j]; - } - } - } else { - var get = function (i) { - return +from[attr][i] + pos * ms * diff[attr][i]; - }; - // now = [["r", get(2), 0, 0], ["t", get(3), get(4)], ["s", get(0), get(1), 0, 0]]; - now = [["m", get(0), get(1), get(2), get(3), get(4), get(5)]]; - } - break; - case "csv": - if (attr == "clip-rect") { - now = []; - i = 4; - while (i--) { - now[i] = +from[attr][i] + pos * ms * diff[attr][i]; - } - } - break; - default: - var from2 = [][concat](from[attr]); - now = []; - i = that.paper.customAttributes[attr].length; - while (i--) { - now[i] = +from2[i] + pos * ms * diff[attr][i]; - } - break; - } - set[attr] = now; - } - that.attr(set); - (function (id, that, anim) { - setTimeout(function () { - eve("anim.frame." + id, that, anim); - }); - })(that.id, that, e.anim); - } else { - (function(f, el, a) { - setTimeout(function() { - eve("anim.frame." + el.id, el, a); - eve("anim.finish." + el.id, el, a); - R.is(f, "function") && f.call(el); - }); - })(e.callback, that, e.anim); - that.attr(to); - animationElements.splice(l--, 1); - if (e.repeat > 1 && !e.next) { - for (key in to) if (to[has](key)) { - init[key] = e.totalOrigin[key]; - } - e.el.attr(init); - runAnimation(e.anim, e.el, e.anim.percents[0], null, e.totalOrigin, e.repeat - 1); - } - if (e.next && !e.stop) { - runAnimation(e.anim, e.el, e.next, null, e.totalOrigin, e.repeat); - } - } - } - R.svg && that && that.paper && that.paper.safari(); - animationElements.length && requestAnimFrame(animation); - }, - upto255 = function (color) { - return color > 255 ? 255 : color < 0 ? 0 : color; - }; - - elproto.animateWith = function (element, anim, params, ms, easing, callback) { - var a = params ? R.animation(params, ms, easing, callback) : anim, - status = element.status(anim); - return this.animate(a).status(a, status * anim.ms / a.ms); - }; - function CubicBezierAtTime(t, p1x, p1y, p2x, p2y, duration) { - var cx = 3 * p1x, - bx = 3 * (p2x - p1x) - cx, - ax = 1 - cx - bx, - cy = 3 * p1y, - by = 3 * (p2y - p1y) - cy, - ay = 1 - cy - by; - function sampleCurveX(t) { - return ((ax * t + bx) * t + cx) * t; - } - function solve(x, epsilon) { - var t = solveCurveX(x, epsilon); - return ((ay * t + by) * t + cy) * t; - } - function solveCurveX(x, epsilon) { - var t0, t1, t2, x2, d2, i; - for(t2 = x, i = 0; i < 8; i++) { - x2 = sampleCurveX(t2) - x; - if (abs(x2) < epsilon) { - return t2; - } - d2 = (3 * ax * t2 + 2 * bx) * t2 + cx; - if (abs(d2) < 1e-6) { - break; - } - t2 = t2 - x2 / d2; - } - t0 = 0; - t1 = 1; - t2 = x; - if (t2 < t0) { - return t0; - } - if (t2 > t1) { - return t1; - } - while (t0 < t1) { - x2 = sampleCurveX(t2); - if (abs(x2 - x) < epsilon) { - return t2; - } - if (x > x2) { - t0 = t2; - } else { - t1 = t2; - } - t2 = (t1 - t0) / 2 + t0; - } - return t2; - } - return solve(t, 1 / (200 * duration)); - } - elproto.onAnimation = function (f) { - f ? eve.on("anim.frame." + this.id, f) : eve.unbind("anim.frame." + this.id); - return this; - }; - function Animation(anim, ms) { - var percents = [], - newAnim = {}; - this.ms = ms; - this.times = 1; - if (anim) { - for (var attr in anim) if (anim[has](attr)) { - newAnim[toFloat(attr)] = anim[attr]; - percents.push(toFloat(attr)); - } - percents.sort(sortByNumber); - } - this.anim = newAnim; - this.top = percents[percents.length - 1]; - this.percents = percents; - } - - Animation.prototype.delay = function (delay) { - var a = new Animation(this.anim, this.ms); - a.times = this.times; - a.del = +delay || 0; - return a; - }; - - Animation.prototype.repeat = function (times) { - var a = new Animation(this.anim, this.ms); - a.del = this.del; - a.times = math.floor(mmax(times, 0)) || 1; - return a; - }; - function runAnimation(anim, element, percent, status, totalOrigin, times) { - percent = toFloat(percent); - var params, - isInAnim, - isInAnimSet, - percents = [], - next, - prev, - timestamp, - ms = anim.ms, - from = {}, - to = {}, - diff = {}; - if (status) { - for (i = 0, ii = animationElements.length; i < ii; i++) { - var e = animationElements[i]; - if (e.el.id == element.id && e.anim == anim) { - if (e.percent != percent) { - animationElements.splice(i, 1); - isInAnimSet = 1; - } else { - isInAnim = e; - } - element.attr(e.totalOrigin); - break; - } - } - } else { - status = +to; // NaN - } - for (var i = 0, ii = anim.percents.length; i < ii; i++) { - if (anim.percents[i] == percent || anim.percents[i] > status * anim.top) { - percent = anim.percents[i]; - prev = anim.percents[i - 1] || 0; - ms = ms / anim.top * (percent - prev); - next = anim.percents[i + 1]; - params = anim.anim[percent]; - break; - } else if (status) { - element.attr(anim.anim[anim.percents[i]]); - } - } - if (!params) { - return; - } - if (!isInAnim) { - for (var attr in params) if (params[has](attr)) { - if (availableAnimAttrs[has](attr) || element.paper.customAttributes[has](attr)) { - from[attr] = element.attr(attr); - (from[attr] == null) && (from[attr] = availableAttrs[attr]); - to[attr] = params[attr]; - switch (availableAnimAttrs[attr]) { - case nu: - diff[attr] = (to[attr] - from[attr]) / ms; - break; - case "colour": - from[attr] = R.getRGB(from[attr]); - var toColour = R.getRGB(to[attr]); - diff[attr] = { - r: (toColour.r - from[attr].r) / ms, - g: (toColour.g - from[attr].g) / ms, - b: (toColour.b - from[attr].b) / ms - }; - break; - case "path": - var pathes = path2curve(from[attr], to[attr]), - toPath = pathes[1]; - from[attr] = pathes[0]; - diff[attr] = []; - for (i = 0, ii = from[attr].length; i < ii; i++) { - diff[attr][i] = [0]; - for (var j = 1, jj = from[attr][i].length; j < jj; j++) { - diff[attr][i][j] = (toPath[i][j] - from[attr][i][j]) / ms; - } - } - break; - case "transform": - var _ = element._, - eq = equaliseTransform(_[attr], to[attr]); - if (eq) { - from[attr] = eq.from; - to[attr] = eq.to; - diff[attr] = []; - diff[attr].real = true; - for (i = 0, ii = from[attr].length; i < ii; i++) { - diff[attr][i] = [from[attr][i][0]]; - for (j = 1, jj = from[attr][i].length; j < jj; j++) { - diff[attr][i][j] = (to[attr][i][j] - from[attr][i][j]) / ms; - } - } - } else { - var m = (element.matrix || new Matrix), - to2 = { - _: {transform: _.transform}, - getBBox: function () { - return element.getBBox(1); - } - }; - from[attr] = [ - m.a, - m.b, - m.c, - m.d, - m.e, - m.f - ]; - extractTransform(to2, to[attr]); - to[attr] = to2._.transform; - diff[attr] = [ - (to2.matrix.a - m.a) / ms, - (to2.matrix.b - m.b) / ms, - (to2.matrix.c - m.c) / ms, - (to2.matrix.d - m.d) / ms, - (to2.matrix.e - m.e) / ms, - (to2.matrix.e - m.f) / ms - ]; - // from[attr] = [_.sx, _.sy, _.deg, _.dx, _.dy]; - // var to2 = {_:{}, getBBox: function () { return element.getBBox(); }}; - // extractTransform(to2, to[attr]); - // diff[attr] = [ - // (to2._.sx - _.sx) / ms, - // (to2._.sy - _.sy) / ms, - // (to2._.deg - _.deg) / ms, - // (to2._.dx - _.dx) / ms, - // (to2._.dy - _.dy) / ms - // ]; - } - break; - case "csv": - var values = Str(params[attr])[split](separator), - from2 = Str(from[attr])[split](separator); - if (attr == "clip-rect") { - from[attr] = from2; - diff[attr] = []; - i = from2.length; - while (i--) { - diff[attr][i] = (values[i] - from[attr][i]) / ms; - } - } - to[attr] = values; - break; - default: - values = [][concat](params[attr]); - from2 = [][concat](from[attr]); - diff[attr] = []; - i = element.paper.customAttributes[attr].length; - while (i--) { - diff[attr][i] = ((values[i] || 0) - (from2[i] || 0)) / ms; - } - break; - } - } - } - var easing = params.easing, - easyeasy = R.easing_formulas[easing]; - if (!easyeasy) { - easyeasy = Str(easing).match(bezierrg); - if (easyeasy && easyeasy.length == 5) { - var curve = easyeasy; - easyeasy = function (t) { - return CubicBezierAtTime(t, +curve[1], +curve[2], +curve[3], +curve[4], ms); - }; - } else { - easyeasy = pipe; - } - } - timestamp = params.start || anim.start || +new Date; - e = { - anim: anim, - percent: percent, - timestamp: timestamp, - start: timestamp + (anim.del || 0), - status: 0, - initstatus: status || 0, - stop: false, - ms: ms, - easing: easyeasy, - from: from, - diff: diff, - to: to, - el: element, - callback: params.callback, - prev: prev, - next: next, - repeat: times || anim.times, - origin: element.attr(), - totalOrigin: totalOrigin - }; - animationElements.push(e); - if (status && !isInAnim && !isInAnimSet) { - e.stop = true; - e.start = new Date - ms * status; - if (animationElements.length == 1) { - return animation(); - } - } - if (isInAnimSet) { - e.start = new Date - e.ms * status; - } - animationElements.length == 1 && requestAnimFrame(animation); - } else { - isInAnim.initstatus = status; - isInAnim.start = new Date - isInAnim.ms * status; - } - eve("anim.start." + element.id, element, anim); - } - - R.animation = function (params, ms, easing, callback) { - if (params instanceof Animation) { - return params; - } - if (R.is(easing, "function") || !easing) { - callback = callback || easing || null; - easing = null; - } - params = Object(params); - ms = +ms || 0; - var p = {}, - json, - attr; - for (attr in params) if (params[has](attr) && toFloat(attr) != attr && toFloat(attr) + "%" != attr) { - json = true; - p[attr] = params[attr]; - } - if (!json) { - return new Animation(params, ms); - } else { - easing && (p.easing = easing); - callback && (p.callback = callback); - return new Animation({100: p}, ms); - } - }; - - elproto.animate = function (params, ms, easing, callback) { - var element = this; - if (element.removed) { - callback && callback.call(element); - return element; - } - var anim = params instanceof Animation ? params : R.animation(params, ms, easing, callback); - runAnimation(anim, element, anim.percents[0], null, element.attr()); - return element; - }; - - elproto.setTime = function (anim, value) { - if (anim && value != null) { - this.status(anim, mmin(value, anim.ms) / anim.ms); - } - return this; - }; - - elproto.status = function (anim, value) { - var out = [], - i = 0, - len, - e; - if (value != null) { - runAnimation(anim, this, -1, mmin(value, 1)); - return this; - } else { - len = animationElements.length; - for (; i < len; i++) { - e = animationElements[i]; - if (e.el.id == this.id && (!anim || e.anim == anim)) { - if (anim) { - return e.status; - } - out.push({ - anim: e.anim, - status: e.status - }); - } - } - if (anim) { - return 0; - } - return out; - } - }; - - elproto.pause = function (anim) { - for (var i = 0; i < animationElements.length; i++) if (animationElements[i].el.id == this.id && (!anim || animationElements[i].anim == anim)) { - if (eve("anim.pause." + this.id, this, animationElements[i].anim) !== false) { - animationElements[i].paused = true; - } - } - return this; - }; - - elproto.resume = function (anim) { - for (var i = 0; i < animationElements.length; i++) if (animationElements[i].el.id == this.id && (!anim || animationElements[i].anim == anim)) { - var e = animationElements[i]; - if (eve("anim.resume." + this.id, this, e.anim) !== false) { - delete e.paused; - this.status(e.anim, e.status); - } - } - return this; - }; - - elproto.stop = function (anim) { - for (var i = 0; i < animationElements.length; i++) if (animationElements[i].el.id == this.id && (!anim || animationElements[i].anim == anim)) { - if (eve("anim.stop." + this.id, this, animationElements[i].anim) !== false) { - animationElements.splice(i--, 1); - } - } - return this; - }; - elproto.toString = function () { - return "Rapha\xebl\u2019s object"; - }; - - // Set - var Set = function (items) { - this.items = []; - this.length = 0; - this.type = "set"; - if (items) { - for (var i = 0, ii = items.length; i < ii; i++) { - if (items[i] && (items[i].constructor == elproto.constructor || items[i].constructor == Set)) { - this[this.items.length] = this.items[this.items.length] = items[i]; - this.length++; - } - } - } - }, - setproto = Set.prototype; - - setproto.push = function () { - var item, - len; - for (var i = 0, ii = arguments.length; i < ii; i++) { - item = arguments[i]; - if (item && (item.constructor == elproto.constructor || item.constructor == Set)) { - len = this.items.length; - this[len] = this.items[len] = item; - this.length++; - } - } - return this; - }; - - setproto.pop = function () { - this.length && delete this[this.length--]; - return this.items.pop(); - }; - - setproto.forEach = function (callback, thisArg) { - for (var i = 0, ii = this.items.length; i < ii; i++) { - if (callback.call(thisArg, this.items[i], i) === false) { - return this; - } - } - return this; - }; - for (var method in elproto) if (elproto[has](method)) { - setproto[method] = (function (methodname) { - return function () { - var arg = arguments; - return this.forEach(function (el) { - el[methodname][apply](el, arg); - }); - }; - })(method); - } - setproto.attr = function (name, value) { - if (name && R.is(name, array) && R.is(name[0], "object")) { - for (var j = 0, jj = name.length; j < jj; j++) { - this.items[j].attr(name[j]); - } - } else { - for (var i = 0, ii = this.items.length; i < ii; i++) { - this.items[i].attr(name, value); - } - } - return this; - }; - - setproto.clear = function () { - while (this.length) { - this.pop(); - } - }; - - setproto.splice = function (index, count, insertion) { - index = index < 0 ? mmax(this.length + index, 0) : index; - count = mmax(0, mmin(this.length - index, count)); - var tail = [], - todel = [], - args = [], - i; - for (i = 2; i < arguments.length; i++) { - args.push(arguments[i]); - } - for (i = 0; i < count; i++) { - todel.push(this[index + i]); - } - for (; i < this.length - index; i++) { - tail.push(this[index + i]); - } - var arglen = args.length; - for (i = 0; i < arglen + tail.length; i++) { - this.items[index + i] = this[index + i] = i < arglen ? args[i] : tail[i - arglen]; - } - i = this.items.length = this.length -= count - arglen; - while (this[i]) { - delete this[i++]; - } - return new Set(todel); - }; - - setproto.exclude = function (el) { - for (var i = 0, ii = this.length; i < ii; i++) if (this[i] == el) { - this.splice(i, 1); - return true; - } - }; - setproto.animate = function (params, ms, easing, callback) { - (R.is(easing, "function") || !easing) && (callback = easing || null); - var len = this.items.length, - i = len, - item, - set = this, - collector; - if (!len) { - return this; - } - callback && (collector = function () { - !--len && callback.call(set); - }); - easing = R.is(easing, string) ? easing : collector; - var anim = R.animation(params, ms, easing, collector); - item = this.items[--i].animate(anim); - while (i--) { - this.items[i] && !this.items[i].removed && this.items[i].animateWith(item, anim); - } - return this; - }; - setproto.insertAfter = function (el) { - var i = this.items.length; - while (i--) { - this.items[i].insertAfter(el); - } - return this; - }; - setproto.getBBox = function () { - var x = [], - y = [], - w = [], - h = []; - for (var i = this.items.length; i--;) if (!this.items[i].removed) { - var box = this.items[i].getBBox(); - x.push(box.x); - y.push(box.y); - w.push(box.x + box.width); - h.push(box.y + box.height); - } - x = mmin[apply](0, x); - y = mmin[apply](0, y); - return { - x: x, - y: y, - width: mmax[apply](0, w) - x, - height: mmax[apply](0, h) - y - }; - }; - setproto.clone = function (s) { - s = new Set; - for (var i = 0, ii = this.items.length; i < ii; i++) { - s.push(this.items[i].clone()); - } - return s; - }; - setproto.toString = function () { - return "Rapha\xebl\u2018s set"; - }; - - - R.registerFont = function (font) { - if (!font.face) { - return font; - } - this.fonts = this.fonts || {}; - var fontcopy = { - w: font.w, - face: {}, - glyphs: {} - }, - family = font.face["font-family"]; - for (var prop in font.face) if (font.face[has](prop)) { - fontcopy.face[prop] = font.face[prop]; - } - if (this.fonts[family]) { - this.fonts[family].push(fontcopy); - } else { - this.fonts[family] = [fontcopy]; - } - if (!font.svg) { - fontcopy.face["units-per-em"] = toInt(font.face["units-per-em"], 10); - for (var glyph in font.glyphs) if (font.glyphs[has](glyph)) { - var path = font.glyphs[glyph]; - fontcopy.glyphs[glyph] = { - w: path.w, - k: {}, - d: path.d && "M" + path.d.replace(/[mlcxtrv]/g, function (command) { - return {l: "L", c: "C", x: "z", t: "m", r: "l", v: "c"}[command] || "M"; - }) + "z" - }; - if (path.k) { - for (var k in path.k) if (path[has](k)) { - fontcopy.glyphs[glyph].k[k] = path.k[k]; - } - } - } - } - return font; - }; - - paperproto.getFont = function (family, weight, style, stretch) { - stretch = stretch || "normal"; - style = style || "normal"; - weight = +weight || {normal: 400, bold: 700, lighter: 300, bolder: 800}[weight] || 400; - if (!R.fonts) { - return; - } - var font = R.fonts[family]; - if (!font) { - var name = new RegExp("(^|\\s)" + family.replace(/[^\w\d\s+!~.:_-]/g, E) + "(\\s|$)", "i"); - for (var fontName in R.fonts) if (R.fonts[has](fontName)) { - if (name.test(fontName)) { - font = R.fonts[fontName]; - break; - } - } - } - var thefont; - if (font) { - for (var i = 0, ii = font.length; i < ii; i++) { - thefont = font[i]; - if (thefont.face["font-weight"] == weight && (thefont.face["font-style"] == style || !thefont.face["font-style"]) && thefont.face["font-stretch"] == stretch) { - break; - } - } - } - return thefont; - }; - - paperproto.print = function (x, y, string, font, size, origin, letter_spacing) { - origin = origin || "middle"; // baseline|middle - letter_spacing = mmax(mmin(letter_spacing || 0, 1), -1); - var out = this.set(), - letters = Str(string)[split](E), - shift = 0, - path = E, - scale; - R.is(font, string) && (font = this.getFont(font)); - if (font) { - scale = (size || 16) / font.face["units-per-em"]; - var bb = font.face.bbox[split](separator), - top = +bb[0], - height = +bb[1] + (origin == "baseline" ? bb[3] - bb[1] + (+font.face.descent) : (bb[3] - bb[1]) / 2); - for (var i = 0, ii = letters.length; i < ii; i++) { - var prev = i && font.glyphs[letters[i - 1]] || {}, - curr = font.glyphs[letters[i]]; - shift += i ? (prev.w || font.w) + (prev.k && prev.k[letters[i]] || 0) + (font.w * letter_spacing) : 0; - curr && curr.d && out.push(this.path(curr.d).attr({ - fill: "#000", - stroke: "none", - transform: [["t", shift * scale, 0]] - })); - } - out.transform(["...s", scale, scale, top, height, "t", (x - top) / scale, (y - height) / scale]); - } - return out; - }; - - - paperproto.add = function (json) { - if (R.is(json, "array")) { - var res = this.set(), - i = 0, - ii = json.length, - j; - for (; i < ii; i++) { - j = json[i] || {}; - elements[has](j.type) && res.push(this[j.type]().attr(j)); - } - } - return res; - }; - - - R.format = function (token, params) { - var args = R.is(params, array) ? [0][concat](params) : arguments; - token && R.is(token, string) && args.length - 1 && (token = token.replace(formatrg, function (str, i) { - return args[++i] == null ? E : args[i]; - })); - return token || E; - }; - - R.fullfill = (function () { - var tokenRegex = /\{([^\}]+)\}/g, - objNotationRegex = /(?:(?:^|\.)(.+?)(?=\[|\.|$|\()|\[('|")(.+?)\2\])(\(\))?/g, // matches .xxxxx or ["xxxxx"] to run over object properties - replacer = function (all, key, obj) { - var res = obj; - key.replace(objNotationRegex, function (all, name, quote, quotedName, isFunc) { - name = name || quotedName; - if (res) { - if (name in res) { - res = res[name]; - } - typeof res == "function" && isFunc && (res = res()); - } - }); - res = (res == null || res == obj ? all : res) + ""; - return res; - }; - return function (str, obj) { - return String(str).replace(tokenRegex, function (all, key) { - return replacer(all, key, obj); - }); - }; - })(); - - R.ninja = function () { - oldRaphael.was ? (g.win.Raphael = oldRaphael.is) : delete Raphael; - return R; - }; - - R.st = setproto; - // Firefox <3.6 fix: http://webreflection.blogspot.com/2009/11/195-chars-to-help-lazy-loading.html - (function (doc, loaded, f) { - if (doc.readyState == null && doc.addEventListener){ - doc.addEventListener(loaded, f = function () { - doc.removeEventListener(loaded, f, false); - doc.readyState = "complete"; - }, false); - doc.readyState = "loading"; - } - function isLoaded() { - (/in/).test(doc.readyState) ? setTimeout(isLoaded, 9) : R.eve("DOMload"); - } - isLoaded(); - })(document, "DOMContentLoaded"); - - oldRaphael.was ? (g.win.Raphael = R) : (Raphael = R); - - eve.on("DOMload", function () { - loaded = true; - }); -})(); - - -// ┌─────────────────────────────────────────────────────────────────────┐ \\ -// │ Raphaël - JavaScript Vector Library │ \\ -// ├─────────────────────────────────────────────────────────────────────┤ \\ -// │ SVG Module │ \\ -// ├─────────────────────────────────────────────────────────────────────┤ \\ -// │ Copyright (c) 2008-2011 Dmitry Baranovskiy (http://raphaeljs.com) │ \\ -// │ Copyright (c) 2008-2011 Sencha Labs (http://sencha.com) │ \\ -// │ Licensed under the MIT (http://raphaeljs.com/license.html) license. │ \\ -// └─────────────────────────────────────────────────────────────────────┘ \\ -window.Raphael.svg && function (R) { - var has = "hasOwnProperty", - Str = String, - toFloat = parseFloat, - toInt = parseInt, - math = Math, - mmax = math.max, - abs = math.abs, - pow = math.pow, - separator = /[, ]+/, - eve = R.eve, - E = "", - S = " "; - var xlink = "http://www.w3.org/1999/xlink", - markers = { - block: "M5,0 0,2.5 5,5z", - classic: "M5,0 0,2.5 5,5 3.5,3 3.5,2z", - diamond: "M2.5,0 5,2.5 2.5,5 0,2.5z", - open: "M6,1 1,3.5 6,6", - oval: "M2.5,0A2.5,2.5,0,0,1,2.5,5 2.5,2.5,0,0,1,2.5,0z" - }, - markerCounter = {}; - R.toString = function () { - return "Your browser supports SVG.\nYou are running Rapha\xebl " + this.version; - }; - var $ = function (el, attr) { - if (attr) { - if (typeof el == "string") { - el = $(el); - } - for (var key in attr) if (attr[has](key)) { - if (key.substring(0, 6) == "xlink:") { - el.setAttributeNS(xlink, key.substring(6), Str(attr[key])); - } else { - el.setAttribute(key, Str(attr[key])); - } - } - } else { - el = R._g.doc.createElementNS("http://www.w3.org/2000/svg", el); - el.style && (el.style.webkitTapHighlightColor = "rgba(0,0,0,0)"); - } - return el; - }, - addGradientFill = function (element, gradient) { - var type = "linear", - id = element.id + gradient, - fx = .5, fy = .5, - o = element.node, - SVG = element.paper, - s = o.style, - el = R._g.doc.getElementById(id); - if (!el) { - gradient = Str(gradient).replace(R._radial_gradient, function (all, _fx, _fy) { - type = "radial"; - if (_fx && _fy) { - fx = toFloat(_fx); - fy = toFloat(_fy); - var dir = ((fy > .5) * 2 - 1); - pow(fx - .5, 2) + pow(fy - .5, 2) > .25 && - (fy = math.sqrt(.25 - pow(fx - .5, 2)) * dir + .5) && - fy != .5 && - (fy = fy.toFixed(5) - 1e-5 * dir); - } - return E; - }); - gradient = gradient.split(/\s*\-\s*/); - if (type == "linear") { - var angle = gradient.shift(); - angle = -toFloat(angle); - if (isNaN(angle)) { - return null; - } - var vector = [0, 0, math.cos(R.rad(angle)), math.sin(R.rad(angle))], - max = 1 / (mmax(abs(vector[2]), abs(vector[3])) || 1); - vector[2] *= max; - vector[3] *= max; - if (vector[2] < 0) { - vector[0] = -vector[2]; - vector[2] = 0; - } - if (vector[3] < 0) { - vector[1] = -vector[3]; - vector[3] = 0; - } - } - var dots = R._parseDots(gradient); - if (!dots) { - return null; - } - id = id.replace(/[\(\)\s,\xb0#]/g, "_"); - - if (element.gradient && id != element.gradient.id) { - SVG.defs.removeChild(element.gradient); - delete element.gradient; - } - - if (!element.gradient) { - el = $(type + "Gradient", {id: id}); - element.gradient = el; - $(el, type == "radial" ? { - fx: fx, - fy: fy - } : { - x1: vector[0], - y1: vector[1], - x2: vector[2], - y2: vector[3], - gradientTransform: element.matrix.invert() - }); - SVG.defs.appendChild(el); - for (var i = 0, ii = dots.length; i < ii; i++) { - el.appendChild($("stop", { - offset: dots[i].offset ? dots[i].offset : i ? "100%" : "0%", - "stop-color": dots[i].color || "#fff" - })); - } - } - } - $(o, { - fill: "url(#" + id + ")", - opacity: 1, - "fill-opacity": 1 - }); - s.fill = E; - s.opacity = 1; - s.fillOpacity = 1; - return 1; - }, - updatePosition = function (o) { - var bbox = o.getBBox(1); - $(o.pattern, {patternTransform: o.matrix.invert() + " translate(" + bbox.x + "," + bbox.y + ")"}); - }, - addArrow = function (o, value, isEnd) { - if (o.type == "path") { - var values = Str(value).toLowerCase().split("-"), - p = o.paper, - se = isEnd ? "end" : "start", - node = o.node, - attrs = o.attrs, - stroke = attrs["stroke-width"], - i = values.length, - type = "classic", - from, - to, - dx, - refX, - attr, - w = 3, - h = 3, - t = 5; - while (i--) { - switch (values[i]) { - case "block": - case "classic": - case "oval": - case "diamond": - case "open": - case "none": - type = values[i]; - break; - case "wide": h = 5; break; - case "narrow": h = 2; break; - case "long": w = 5; break; - case "short": w = 2; break; - } - } - if (type == "open") { - w += 2; - h += 2; - t += 2; - dx = 1; - refX = isEnd ? 4 : 1; - attr = { - fill: "none", - stroke: attrs.stroke - }; - } else { - refX = dx = w / 2; - attr = { - fill: attrs.stroke, - stroke: "none" - }; - } - if (o._.arrows) { - if (isEnd) { - o._.arrows.endPath && markerCounter[o._.arrows.endPath]--; - o._.arrows.endMarker && markerCounter[o._.arrows.endMarker]--; - } else { - o._.arrows.startPath && markerCounter[o._.arrows.startPath]--; - o._.arrows.startMarker && markerCounter[o._.arrows.startMarker]--; - } - } else { - o._.arrows = {}; - } - if (type != "none") { - var pathId = "raphael-marker-" + type, - markerId = "raphael-marker-" + se + type + w + h; - if (!R._g.doc.getElementById(pathId)) { - p.defs.appendChild($($("path"), { - "stroke-linecap": "round", - d: markers[type], - id: pathId - })); - markerCounter[pathId] = 1; - } else { - markerCounter[pathId]++; - } - var marker = R._g.doc.getElementById(markerId), - use; - if (!marker) { - marker = $($("marker"), { - id: markerId, - markerHeight: h, - markerWidth: w, - orient: "auto", - refX: refX, - refY: h / 2 - }); - use = $($("use"), { - "xlink:href": "#" + pathId, - transform: (isEnd ? " rotate(180 " + w / 2 + " " + h / 2 + ") " : S) + "scale(" + w / t + "," + h / t + ")", - "stroke-width": 1 / ((w / t + h / t) / 2) - }); - marker.appendChild(use); - p.defs.appendChild(marker); - markerCounter[markerId] = 1; - } else { - markerCounter[markerId]++; - use = marker.getElementsByTagName("use")[0]; - } - $(use, attr); - var delta = dx * (type != "diamond" && type != "oval"); - if (isEnd) { - from = o._.arrows.startdx * stroke || 0; - to = R.getTotalLength(attrs.path) - delta * stroke; - } else { - from = delta * stroke; - to = R.getTotalLength(attrs.path) - (o._.arrows.enddx * stroke || 0); - } - attr = {}; - attr["marker-" + se] = "url(#" + markerId + ")"; - if (to || from) { - attr.d = Raphael.getSubpath(attrs.path, from, to); - } - $(node, attr); - o._.arrows[se + "Path"] = pathId; - o._.arrows[se + "Marker"] = markerId; - o._.arrows[se + "dx"] = delta; - o._.arrows[se + "Type"] = type; - o._.arrows[se + "String"] = value; - } else { - if (isEnd) { - from = o._.arrows.startdx * stroke || 0; - to = R.getTotalLength(attrs.path) - from; - } else { - from = 0; - to = R.getTotalLength(attrs.path) - (o._.arrows.enddx * stroke || 0); - } - o._.arrows[se + "Path"] && $(node, {d: Raphael.getSubpath(attrs.path, from, to)}); - delete o._.arrows[se + "Path"]; - delete o._.arrows[se + "Marker"]; - delete o._.arrows[se + "dx"]; - delete o._.arrows[se + "Type"]; - delete o._.arrows[se + "String"]; - } - for (attr in markerCounter) if (markerCounter[has](attr) && !markerCounter[attr]) { - var item = R._g.doc.getElementById(attr); - item && item.parentNode.removeChild(item); - } - } - }, - dasharray = { - "": [0], - "none": [0], - "-": [3, 1], - ".": [1, 1], - "-.": [3, 1, 1, 1], - "-..": [3, 1, 1, 1, 1, 1], - ". ": [1, 3], - "- ": [4, 3], - "--": [8, 3], - "- .": [4, 3, 1, 3], - "--.": [8, 3, 1, 3], - "--..": [8, 3, 1, 3, 1, 3] - }, - addDashes = function (o, value, params) { - value = dasharray[Str(value).toLowerCase()]; - if (value) { - var width = o.attrs["stroke-width"] || "1", - butt = {round: width, square: width, butt: 0}[o.attrs["stroke-linecap"] || params["stroke-linecap"]] || 0, - dashes = [], - i = value.length; - while (i--) { - dashes[i] = value[i] * width + ((i % 2) ? 1 : -1) * butt; - } - $(o.node, {"stroke-dasharray": dashes.join(",")}); - } - }, - setFillAndStroke = function (o, params) { - var node = o.node, - attrs = o.attrs, - vis = node.style.visibility; - node.style.visibility = "hidden"; - for (var att in params) { - if (params[has](att)) { - if (!R._availableAttrs[has](att)) { - continue; - } - var value = params[att]; - attrs[att] = value; - switch (att) { - case "blur": - o.blur(value); - break; - case "href": - case "title": - case "target": - var pn = node.parentNode; - if (pn.tagName.toLowerCase() != "a") { - var hl = $("a"); - pn.insertBefore(hl, node); - hl.appendChild(node); - pn = hl; - } - if (att == "target" && value == "blank") { - pn.setAttributeNS(xlink, "show", "new"); - } else { - pn.setAttributeNS(xlink, att, value); - } - break; - case "cursor": - node.style.cursor = value; - break; - case "transform": - o.transform(value); - break; - case "arrow-start": - addArrow(o, value); - break; - case "arrow-end": - addArrow(o, value, 1); - break; - case "clip-rect": - var rect = Str(value).split(separator); - if (rect.length == 4) { - o.clip && o.clip.parentNode.parentNode.removeChild(o.clip.parentNode); - var el = $("clipPath"), - rc = $("rect"); - el.id = R.createUUID(); - $(rc, { - x: rect[0], - y: rect[1], - width: rect[2], - height: rect[3] - }); - el.appendChild(rc); - o.paper.defs.appendChild(el); - $(node, {"clip-path": "url(#" + el.id + ")"}); - o.clip = rc; - } - if (!value) { - var path = node.getAttribute("clip-path"); - if (path) { - var clip = R._g.doc.getElementById(path.replace(/(^url\(#|\)$)/g, E)); - clip && clip.parentNode.removeChild(clip); - $(node, {"clip-path": E}); - delete o.clip; - } - } - break; - case "path": - if (o.type == "path") { - $(node, {d: value ? attrs.path = R._pathToAbsolute(value) : "M0,0"}); - o._.dirty = 1; - if (o._.arrows) { - "startString" in o._.arrows && addArrow(o, o._.arrows.startString); - "endString" in o._.arrows && addArrow(o, o._.arrows.endString, 1); - } - } - break; - case "width": - node.setAttribute(att, value); - o._.dirty = 1; - if (attrs.fx) { - att = "x"; - value = attrs.x; - } else { - break; - } - case "x": - if (attrs.fx) { - value = -attrs.x - (attrs.width || 0); - } - case "rx": - if (att == "rx" && o.type == "rect") { - break; - } - case "cx": - node.setAttribute(att, value); - o.pattern && updatePosition(o); - o._.dirty = 1; - break; - case "height": - node.setAttribute(att, value); - o._.dirty = 1; - if (attrs.fy) { - att = "y"; - value = attrs.y; - } else { - break; - } - case "y": - if (attrs.fy) { - value = -attrs.y - (attrs.height || 0); - } - case "ry": - if (att == "ry" && o.type == "rect") { - break; - } - case "cy": - node.setAttribute(att, value); - o.pattern && updatePosition(o); - o._.dirty = 1; - break; - case "r": - if (o.type == "rect") { - $(node, {rx: value, ry: value}); - } else { - node.setAttribute(att, value); - } - o._.dirty = 1; - break; - case "src": - if (o.type == "image") { - node.setAttributeNS(xlink, "href", value); - } - break; - case "stroke-width": - if (o._.sx != 1 || o._.sy != 1) { - value /= mmax(abs(o._.sx), abs(o._.sy)) || 1; - } - if (o.paper._vbSize) { - value *= o.paper._vbSize; - } - node.setAttribute(att, value); - if (attrs["stroke-dasharray"]) { - addDashes(o, attrs["stroke-dasharray"], params); - } - if (o._.arrows) { - "startString" in o._.arrows && addArrow(o, o._.arrows.startString); - "endString" in o._.arrows && addArrow(o, o._.arrows.endString, 1); - } - break; - case "stroke-dasharray": - addDashes(o, value, params); - break; - case "fill": - var isURL = Str(value).match(R._ISURL); - if (isURL) { - el = $("pattern"); - var ig = $("image"); - el.id = R.createUUID(); - $(el, {x: 0, y: 0, patternUnits: "userSpaceOnUse", height: 1, width: 1}); - $(ig, {x: 0, y: 0, "xlink:href": isURL[1]}); - el.appendChild(ig); - - (function (el) { - R._preload(isURL[1], function () { - var w = this.offsetWidth, - h = this.offsetHeight; - $(el, {width: w, height: h}); - $(ig, {width: w, height: h}); - o.paper.safari(); - }); - })(el); - o.paper.defs.appendChild(el); - node.style.fill = "url(#" + el.id + ")"; - $(node, {fill: "url(#" + el.id + ")"}); - o.pattern = el; - o.pattern && updatePosition(o); - break; - } - var clr = R.getRGB(value); - if (!clr.error) { - delete params.gradient; - delete attrs.gradient; - !R.is(attrs.opacity, "undefined") && - R.is(params.opacity, "undefined") && - $(node, {opacity: attrs.opacity}); - !R.is(attrs["fill-opacity"], "undefined") && - R.is(params["fill-opacity"], "undefined") && - $(node, {"fill-opacity": attrs["fill-opacity"]}); - } else if ((o.type == "circle" || o.type == "ellipse" || Str(value).charAt() != "r") && addGradientFill(o, value)) { - if ("opacity" in attrs || "fill-opacity" in attrs) { - var gradient = R._g.doc.getElementById(node.getAttribute("fill").replace(/^url\(#|\)$/g, E)); - if (gradient) { - var stops = gradient.getElementsByTagName("stop"); - $(stops[stops.length - 1], {"stop-opacity": ("opacity" in attrs ? attrs.opacity : 1) * ("fill-opacity" in attrs ? attrs["fill-opacity"] : 1)}); - } - } - attrs.gradient = value; - attrs.fill = "none"; - break; - } - clr[has]("opacity") && $(node, {"fill-opacity": clr.opacity > 1 ? clr.opacity / 100 : clr.opacity}); - case "stroke": - clr = R.getRGB(value); - node.setAttribute(att, clr.hex); - att == "stroke" && clr[has]("opacity") && $(node, {"stroke-opacity": clr.opacity > 1 ? clr.opacity / 100 : clr.opacity}); - if (att == "stroke" && o._.arrows) { - "startString" in o._.arrows && addArrow(o, o._.arrows.startString); - "endString" in o._.arrows && addArrow(o, o._.arrows.endString, 1); - } - break; - case "gradient": - (o.type == "circle" || o.type == "ellipse" || Str(value).charAt() != "r") && addGradientFill(o, value); - break; - case "opacity": - if (attrs.gradient && !attrs[has]("stroke-opacity")) { - $(node, {"stroke-opacity": value > 1 ? value / 100 : value}); - } - // fall - case "fill-opacity": - if (attrs.gradient) { - gradient = R._g.doc.getElementById(node.getAttribute("fill").replace(/^url\(#|\)$/g, E)); - if (gradient) { - stops = gradient.getElementsByTagName("stop"); - $(stops[stops.length - 1], {"stop-opacity": value}); - } - break; - } - default: - att == "font-size" && (value = toInt(value, 10) + "px"); - var cssrule = att.replace(/(\-.)/g, function (w) { - return w.substring(1).toUpperCase(); - }); - node.style[cssrule] = value; - o._.dirty = 1; - node.setAttribute(att, value); - break; - } - } - } - - tuneText(o, params); - node.style.visibility = vis; - }, - leading = 1.2, - tuneText = function (el, params) { - if (el.type != "text" || !(params[has]("text") || params[has]("font") || params[has]("font-size") || params[has]("x") || params[has]("y"))) { - return; - } - var a = el.attrs, - node = el.node, - fontSize = node.firstChild ? toInt(R._g.doc.defaultView.getComputedStyle(node.firstChild, E).getPropertyValue("font-size"), 10) : 10; - - if (params[has]("text")) { - a.text = params.text; - while (node.firstChild) { - node.removeChild(node.firstChild); - } - var texts = Str(params.text).split("\n"), - tspans = [], - tspan; - for (var i = 0, ii = texts.length; i < ii; i++) { - tspan = $("tspan"); - i && $(tspan, {dy: fontSize * leading, x: a.x}); - tspan.appendChild(R._g.doc.createTextNode(texts[i])); - node.appendChild(tspan); - tspans[i] = tspan; - } - } else { - tspans = node.getElementsByTagName("tspan"); - for (i = 0, ii = tspans.length; i < ii; i++) if (i) { - $(tspans[i], {dy: fontSize * leading, x: a.x}); - } else { - $(tspans[0], {dy: 0}); - } - } - $(node, {x: a.x, y: a.y}); - el._.dirty = 1; - var bb = el._getBBox(), - dif = a.y - (bb.y + bb.height / 2); - dif && R.is(dif, "finite") && $(tspans[0], {dy: dif}); - }, - Element = function (node, svg) { - var X = 0, - Y = 0; - - this[0] = this.node = node; - - node.raphael = true; - - this.id = R._oid++; - node.raphaelid = this.id; - this.matrix = R.matrix(); - this.realPath = null; - - this.paper = svg; - this.attrs = this.attrs || {}; - this._ = { - transform: [], - sx: 1, - sy: 1, - deg: 0, - dx: 0, - dy: 0, - dirty: 1 - }; - !svg.bottom && (svg.bottom = this); - - this.prev = svg.top; - svg.top && (svg.top.next = this); - svg.top = this; - - this.next = null; - }, - elproto = R.el; - - Element.prototype = elproto; - elproto.constructor = Element; - - R._engine.path = function (pathString, SVG) { - var el = $("path"); - SVG.canvas && SVG.canvas.appendChild(el); - var p = new Element(el, SVG); - p.type = "path"; - setFillAndStroke(p, { - fill: "none", - stroke: "#000", - path: pathString - }); - return p; - }; - - elproto.rotate = function (deg, cx, cy) { - if (this.removed) { - return this; - } - deg = Str(deg).split(separator); - if (deg.length - 1) { - cx = toFloat(deg[1]); - cy = toFloat(deg[2]); - } - deg = toFloat(deg[0]); - (cy == null) && (cx = cy); - if (cx == null || cy == null) { - var bbox = this.getBBox(1); - cx = bbox.x + bbox.width / 2; - cy = bbox.y + bbox.height / 2; - } - this.transform(this._.transform.concat([["r", deg, cx, cy]])); - return this; - }; - - elproto.scale = function (sx, sy, cx, cy) { - if (this.removed) { - return this; - } - sx = Str(sx).split(separator); - if (sx.length - 1) { - sy = toFloat(sx[1]); - cx = toFloat(sx[2]); - cy = toFloat(sx[3]); - } - sx = toFloat(sx[0]); - (sy == null) && (sy = sx); - (cy == null) && (cx = cy); - if (cx == null || cy == null) { - var bbox = this.getBBox(1); - } - cx = cx == null ? bbox.x + bbox.width / 2 : cx; - cy = cy == null ? bbox.y + bbox.height / 2 : cy; - this.transform(this._.transform.concat([["s", sx, sy, cx, cy]])); - return this; - }; - - elproto.translate = function (dx, dy) { - if (this.removed) { - return this; - } - dx = Str(dx).split(separator); - if (dx.length - 1) { - dy = toFloat(dx[1]); - } - dx = toFloat(dx[0]) || 0; - dy = +dy || 0; - this.transform(this._.transform.concat([["t", dx, dy]])); - return this; - }; - - elproto.transform = function (tstr) { - var _ = this._; - if (tstr == null) { - return _.transform; - } - R._extractTransform(this, tstr); - - this.clip && $(this.clip, {transform: this.matrix.invert()}); - this.pattern && updatePosition(this); - this.node && $(this.node, {transform: this.matrix}); - - if (_.sx != 1 || _.sy != 1) { - var sw = this.attrs[has]("stroke-width") ? this.attrs["stroke-width"] : 1; - this.attr({"stroke-width": sw}); - } - - return this; - }; - - elproto.hide = function () { - !this.removed && this.paper.safari(this.node.style.display = "none"); - return this; - }; - - elproto.show = function () { - !this.removed && this.paper.safari(this.node.style.display = ""); - return this; - }; - - elproto.remove = function () { - if (this.removed) { - return; - } - var paper = this.paper; - paper.__set__ && paper.__set__.exclude(this); - eve.unbind("*.*." + this.id); - if (this.gradient) { - paper.defs.removeChild(this.gradient); - } - R._tear(this, paper); - this.node.parentNode.removeChild(this.node); - for (var i in this) { - this[i] = typeof this[i] == "function" ? R._removedFactory(i) : null; - } - this.removed = true; - }; - elproto._getBBox = function () { - if (this.node.style.display == "none") { - this.show(); - var hide = true; - } - var bbox = {}; - try { - bbox = this.node.getBBox(); - } catch(e) { - // Firefox 3.0.x plays badly here - } finally { - bbox = bbox || {}; - } - hide && this.hide(); - return bbox; - }; - - elproto.attr = function (name, value) { - if (this.removed) { - return this; - } - if (name == null) { - var res = {}; - for (var a in this.attrs) if (this.attrs[has](a)) { - res[a] = this.attrs[a]; - } - res.gradient && res.fill == "none" && (res.fill = res.gradient) && delete res.gradient; - res.transform = this._.transform; - return res; - } - if (value == null && R.is(name, "string")) { - if (name == "fill" && this.attrs.fill == "none" && this.attrs.gradient) { - return this.attrs.gradient; - } - if (name == "transform") { - return this._.transform; - } - var names = name.split(separator), - out = {}; - for (var i = 0, ii = names.length; i < ii; i++) { - name = names[i]; - if (name in this.attrs) { - out[name] = this.attrs[name]; - } else if (R.is(this.paper.customAttributes[name], "function")) { - out[name] = this.paper.customAttributes[name].def; - } else { - out[name] = R._availableAttrs[name]; - } - } - return ii - 1 ? out : out[names[0]]; - } - if (value == null && R.is(name, "array")) { - out = {}; - for (i = 0, ii = name.length; i < ii; i++) { - out[name[i]] = this.attr(name[i]); - } - return out; - } - if (value != null) { - var params = {}; - params[name] = value; - } else if (name != null && R.is(name, "object")) { - params = name; - } - for (var key in params) { - eve("attr." + key + "." + this.id, this, params[key]); - } - for (key in this.paper.customAttributes) if (this.paper.customAttributes[has](key) && params[has](key) && R.is(this.paper.customAttributes[key], "function")) { - var par = this.paper.customAttributes[key].apply(this, [].concat(params[key])); - this.attrs[key] = params[key]; - for (var subkey in par) if (par[has](subkey)) { - params[subkey] = par[subkey]; - } - } - setFillAndStroke(this, params); - return this; - }; - - elproto.toFront = function () { - if (this.removed) { - return this; - } - if (this.node.parentNode.tagName.toLowerCase() == "a") { - this.node.parentNode.parentNode.appendChild(this.node.parentNode); - } else { - this.node.parentNode.appendChild(this.node); - } - var svg = this.paper; - svg.top != this && R._tofront(this, svg); - return this; - }; - - elproto.toBack = function () { - if (this.removed) { - return this; - } - var parent = this.node.parentNode; - if (parent.tagName.toLowerCase() == "a") { - parent.parentNode.insertBefore(this.node.parentNode, this.node.parentNode.parentNode.firstChild); - } else if (parent.firstChild != this.node) { - parent.insertBefore(this.node, this.node.parentNode.firstChild); - } - R._toback(this, this.paper); - var svg = this.paper; - return this; - }; - - elproto.insertAfter = function (element) { - if (this.removed) { - return this; - } - var node = element.node || element[element.length - 1].node; - if (node.nextSibling) { - node.parentNode.insertBefore(this.node, node.nextSibling); - } else { - node.parentNode.appendChild(this.node); - } - R._insertafter(this, element, this.paper); - return this; - }; - - elproto.insertBefore = function (element) { - if (this.removed) { - return this; - } - var node = element.node || element[0].node; - node.parentNode.insertBefore(this.node, node); - R._insertbefore(this, element, this.paper); - return this; - }; - elproto.blur = function (size) { - // Experimental. No Safari support. Use it on your own risk. - var t = this; - if (+size !== 0) { - var fltr = $("filter"), - blur = $("feGaussianBlur"); - t.attrs.blur = size; - fltr.id = R.createUUID(); - $(blur, {stdDeviation: +size || 1.5}); - fltr.appendChild(blur); - t.paper.defs.appendChild(fltr); - t._blur = fltr; - $(t.node, {filter: "url(#" + fltr.id + ")"}); - } else { - if (t._blur) { - t._blur.parentNode.removeChild(t._blur); - delete t._blur; - delete t.attrs.blur; - } - t.node.removeAttribute("filter"); - } - }; - R._engine.circle = function (svg, x, y, r) { - var el = $("circle"); - svg.canvas && svg.canvas.appendChild(el); - var res = new Element(el, svg); - res.attrs = {cx: x, cy: y, r: r, fill: "none", stroke: "#000"}; - res.type = "circle"; - $(el, res.attrs); - return res; - }; - R._engine.rect = function (svg, x, y, w, h, r) { - var el = $("rect"); - svg.canvas && svg.canvas.appendChild(el); - var res = new Element(el, svg); - res.attrs = {x: x, y: y, width: w, height: h, r: r || 0, rx: r || 0, ry: r || 0, fill: "none", stroke: "#000"}; - res.type = "rect"; - $(el, res.attrs); - return res; - }; - R._engine.ellipse = function (svg, x, y, rx, ry) { - var el = $("ellipse"); - svg.canvas && svg.canvas.appendChild(el); - var res = new Element(el, svg); - res.attrs = {cx: x, cy: y, rx: rx, ry: ry, fill: "none", stroke: "#000"}; - res.type = "ellipse"; - $(el, res.attrs); - return res; - }; - R._engine.image = function (svg, src, x, y, w, h) { - var el = $("image"); - $(el, {x: x, y: y, width: w, height: h, preserveAspectRatio: "none"}); - el.setAttributeNS(xlink, "href", src); - svg.canvas && svg.canvas.appendChild(el); - var res = new Element(el, svg); - res.attrs = {x: x, y: y, width: w, height: h, src: src}; - res.type = "image"; - return res; - }; - R._engine.text = function (svg, x, y, text) { - var el = $("text"); - // $(el, {x: x, y: y, "text-anchor": "middle"}); - svg.canvas && svg.canvas.appendChild(el); - var res = new Element(el, svg); - res.attrs = { - x: x, - y: y, - "text-anchor": "middle", - text: text, - font: R._availableAttrs.font, - stroke: "none", - fill: "#000" - }; - res.type = "text"; - setFillAndStroke(res, res.attrs); - return res; - }; - R._engine.setSize = function (width, height) { - this.width = width || this.width; - this.height = height || this.height; - this.canvas.setAttribute("width", this.width); - this.canvas.setAttribute("height", this.height); - if (this._viewBox) { - this.setViewBox.apply(this, this._viewBox); - } - return this; - }; - R._engine.create = function () { - var con = R._getContainer.apply(0, arguments), - container = con && con.container, - x = con.x, - y = con.y, - width = con.width, - height = con.height; - if (!container) { - throw new Error("SVG container not found."); - } - var cnvs = $("svg"), - css = "overflow:hidden;", - isFloating; - x = x || 0; - y = y || 0; - width = width || 512; - height = height || 342; - $(cnvs, { - height: height, - version: 1.1, - width: width, - xmlns: "http://www.w3.org/2000/svg" - }); - if (container == 1) { - cnvs.style.cssText = css + "position:absolute;left:" + x + "px;top:" + y + "px"; - R._g.doc.body.appendChild(cnvs); - isFloating = 1; - } else { - cnvs.style.cssText = css + "position:relative"; - if (container.firstChild) { - container.insertBefore(cnvs, container.firstChild); - } else { - container.appendChild(cnvs); - } - } - container = new R._Paper; - container.width = width; - container.height = height; - container.canvas = cnvs; - // plugins.call(container, container, R.fn); - container.clear(); - container._left = container._top = 0; - isFloating && (container.renderfix = function () {}); - container.renderfix(); - return container; - }; - R._engine.setViewBox = function (x, y, w, h, fit) { - eve("setViewBox", this, this._viewBox, [x, y, w, h, fit]); - var size = mmax(w / this.width, h / this.height), - top = this.top, - aspectRatio = fit ? "meet" : "xMinYMin", - vb, - sw; - if (x == null) { - if (this._vbSize) { - size = 1; - } - delete this._vbSize; - vb = "0 0 " + this.width + S + this.height; - } else { - this._vbSize = size; - vb = x + S + y + S + w + S + h; - } - $(this.canvas, { - viewBox: vb, - preserveAspectRatio: aspectRatio - }); - while (size && top) { - sw = "stroke-width" in top.attrs ? top.attrs["stroke-width"] : 1; - top.attr({"stroke-width": sw}); - top._.dirty = 1; - top._.dirtyT = 1; - top = top.prev; - } - this._viewBox = [x, y, w, h, !!fit]; - return this; - }; - - R.prototype.renderfix = function () { - var cnvs = this.canvas, - s = cnvs.style, - pos = cnvs.getScreenCTM() || cnvs.createSVGMatrix(), - left = -pos.e % 1, - top = -pos.f % 1; - if (left || top) { - if (left) { - this._left = (this._left + left) % 1; - s.left = this._left + "px"; - } - if (top) { - this._top = (this._top + top) % 1; - s.top = this._top + "px"; - } - } - }; - - R.prototype.clear = function () { - R.eve("clear", this); - var c = this.canvas; - while (c.firstChild) { - c.removeChild(c.firstChild); - } - this.bottom = this.top = null; - (this.desc = $("desc")).appendChild(R._g.doc.createTextNode("Created with Rapha\xebl " + R.version)); - c.appendChild(this.desc); - c.appendChild(this.defs = $("defs")); - }; - - R.prototype.remove = function () { - eve("remove", this); - this.canvas.parentNode && this.canvas.parentNode.removeChild(this.canvas); - for (var i in this) { - this[i] = typeof this[i] == "function" ? R._removedFactory(i) : null; - } - }; - var setproto = R.st; - for (var method in elproto) if (elproto[has](method) && !setproto[has](method)) { - setproto[method] = (function (methodname) { - return function () { - var arg = arguments; - return this.forEach(function (el) { - el[methodname].apply(el, arg); - }); - }; - })(method); - } -}(window.Raphael); - -// ┌─────────────────────────────────────────────────────────────────────┐ \\ -// │ Raphaël - JavaScript Vector Library │ \\ -// ├─────────────────────────────────────────────────────────────────────┤ \\ -// │ VML Module │ \\ -// ├─────────────────────────────────────────────────────────────────────┤ \\ -// │ Copyright (c) 2008-2011 Dmitry Baranovskiy (http://raphaeljs.com) │ \\ -// │ Copyright (c) 2008-2011 Sencha Labs (http://sencha.com) │ \\ -// │ Licensed under the MIT (http://raphaeljs.com/license.html) license. │ \\ -// └─────────────────────────────────────────────────────────────────────┘ \\ -window.Raphael.vml && function (R) { - var has = "hasOwnProperty", - Str = String, - toFloat = parseFloat, - math = Math, - round = math.round, - mmax = math.max, - mmin = math.min, - abs = math.abs, - fillString = "fill", - separator = /[, ]+/, - eve = R.eve, - ms = " progid:DXImageTransform.Microsoft", - S = " ", - E = "", - map = {M: "m", L: "l", C: "c", Z: "x", m: "t", l: "r", c: "v", z: "x"}, - bites = /([clmz]),?([^clmz]*)/gi, - blurregexp = / progid:\S+Blur\([^\)]+\)/g, - val = /-?[^,\s-]+/g, - cssDot = "position:absolute;left:0;top:0;width:1px;height:1px", - zoom = 21600, - pathTypes = {path: 1, rect: 1, image: 1}, - ovalTypes = {circle: 1, ellipse: 1}, - path2vml = function (path) { - var total = /[ahqstv]/ig, - command = R._pathToAbsolute; - Str(path).match(total) && (command = R._path2curve); - total = /[clmz]/g; - if (command == R._pathToAbsolute && !Str(path).match(total)) { - var res = Str(path).replace(bites, function (all, command, args) { - var vals = [], - isMove = command.toLowerCase() == "m", - res = map[command]; - args.replace(val, function (value) { - if (isMove && vals.length == 2) { - res += vals + map[command == "m" ? "l" : "L"]; - vals = []; - } - vals.push(round(value * zoom)); - }); - return res + vals; - }); - return res; - } - var pa = command(path), p, r; - res = []; - for (var i = 0, ii = pa.length; i < ii; i++) { - p = pa[i]; - r = pa[i][0].toLowerCase(); - r == "z" && (r = "x"); - for (var j = 1, jj = p.length; j < jj; j++) { - r += round(p[j] * zoom) + (j != jj - 1 ? "," : E); - } - res.push(r); - } - return res.join(S); - }, - compensation = function (deg, dx, dy) { - var m = R.matrix(); - m.rotate(-deg, .5, .5); - return { - dx: m.x(dx, dy), - dy: m.y(dx, dy) - }; - }, - setCoords = function (p, sx, sy, dx, dy, deg) { - var _ = p._, - m = p.matrix, - fillpos = _.fillpos, - o = p.node, - s = o.style, - y = 1, - flip = "", - dxdy, - kx = zoom / sx, - ky = zoom / sy; - s.visibility = "hidden"; - if (!sx || !sy) { - return; - } - o.coordsize = abs(kx) + S + abs(ky); - s.rotation = deg * (sx * sy < 0 ? -1 : 1); - if (deg) { - var c = compensation(deg, dx, dy); - dx = c.dx; - dy = c.dy; - } - sx < 0 && (flip += "x"); - sy < 0 && (flip += " y") && (y = -1); - s.flip = flip; - o.coordorigin = (dx * -kx) + S + (dy * -ky); - if (fillpos || _.fillsize) { - var fill = o.getElementsByTagName(fillString); - fill = fill && fill[0]; - o.removeChild(fill); - if (fillpos) { - c = compensation(deg, m.x(fillpos[0], fillpos[1]), m.y(fillpos[0], fillpos[1])); - fill.position = c.dx * y + S + c.dy * y; - } - if (_.fillsize) { - fill.size = _.fillsize[0] * abs(sx) + S + _.fillsize[1] * abs(sy); - } - o.appendChild(fill); - } - s.visibility = "visible"; - }; - R.toString = function () { - return "Your browser doesn\u2019t support SVG. Falling down to VML.\nYou are running Rapha\xebl " + this.version; - }; - var addArrow = function (o, value, isEnd) { - var values = Str(value).toLowerCase().split("-"), - se = isEnd ? "end" : "start", - i = values.length, - type = "classic", - w = "medium", - h = "medium"; - while (i--) { - switch (values[i]) { - case "block": - case "classic": - case "oval": - case "diamond": - case "open": - case "none": - type = values[i]; - break; - case "wide": - case "narrow": h = values[i]; break; - case "long": - case "short": w = values[i]; break; - } - } - var stroke = o.node.getElementsByTagName("stroke")[0]; - stroke[se + "arrow"] = type; - stroke[se + "arrowlength"] = w; - stroke[se + "arrowwidth"] = h; - }, - setFillAndStroke = function (o, params) { - // o.paper.canvas.style.display = "none"; - o.attrs = o.attrs || {}; - var node = o.node, - a = o.attrs, - s = node.style, - xy, - newpath = pathTypes[o.type] && (params.x != a.x || params.y != a.y || params.width != a.width || params.height != a.height || params.cx != a.cx || params.cy != a.cy || params.rx != a.rx || params.ry != a.ry || params.r != a.r), - isOval = ovalTypes[o.type] && (a.cx != params.cx || a.cy != params.cy || a.r != params.r || a.rx != params.rx || a.ry != params.ry), - res = o; - - - for (var par in params) if (params[has](par)) { - a[par] = params[par]; - } - if (newpath) { - a.path = R._getPath[o.type](o); - o._.dirty = 1; - } - params.href && (node.href = params.href); - params.title && (node.title = params.title); - params.target && (node.target = params.target); - params.cursor && (s.cursor = params.cursor); - "blur" in params && o.blur(params.blur); - if (params.path && o.type == "path" || newpath) { - node.path = path2vml(~Str(a.path).toLowerCase().indexOf("r") ? R._pathToAbsolute(a.path) : a.path); - if (o.type == "image") { - o._.fillpos = [a.x, a.y]; - o._.fillsize = [a.width, a.height]; - setCoords(o, 1, 1, 0, 0, 0); - } - } - "transform" in params && o.transform(params.transform); - if (isOval) { - var cx = +a.cx, - cy = +a.cy, - rx = +a.rx || +a.r || 0, - ry = +a.ry || +a.r || 0; - node.path = R.format("ar{0},{1},{2},{3},{4},{1},{4},{1}x", round((cx - rx) * zoom), round((cy - ry) * zoom), round((cx + rx) * zoom), round((cy + ry) * zoom), round(cx * zoom)); - } - if ("clip-rect" in params) { - var rect = Str(params["clip-rect"]).split(separator); - if (rect.length == 4) { - rect[2] = +rect[2] + (+rect[0]); - rect[3] = +rect[3] + (+rect[1]); - var div = node.clipRect || R._g.doc.createElement("div"), - dstyle = div.style; - dstyle.clip = R.format("rect({1}px {2}px {3}px {0}px)", rect); - if (!node.clipRect) { - dstyle.position = "absolute"; - dstyle.top = 0; - dstyle.left = 0; - dstyle.width = o.paper.width + "px"; - dstyle.height = o.paper.height + "px"; - node.parentNode.insertBefore(div, node); - div.appendChild(node); - node.clipRect = div; - } - } - if (!params["clip-rect"]) { - node.clipRect && (node.clipRect.style.clip = "auto"); - } - } - if (o.textpath) { - var textpathStyle = o.textpath.style; - params.font && (textpathStyle.font = params.font); - params["font-family"] && (textpathStyle.fontFamily = '"' + params["font-family"].split(",")[0].replace(/^['"]+|['"]+$/g, E) + '"'); - params["font-size"] && (textpathStyle.fontSize = params["font-size"]); - params["font-weight"] && (textpathStyle.fontWeight = params["font-weight"]); - params["font-style"] && (textpathStyle.fontStyle = params["font-style"]); - } - if ("arrow-start" in params) { - addArrow(res, params["arrow-start"]); - } - if ("arrow-end" in params) { - addArrow(res, params["arrow-end"], 1); - } - if (params.opacity != null || - params["stroke-width"] != null || - params.fill != null || - params.src != null || - params.stroke != null || - params["stroke-width"] != null || - params["stroke-opacity"] != null || - params["fill-opacity"] != null || - params["stroke-dasharray"] != null || - params["stroke-miterlimit"] != null || - params["stroke-linejoin"] != null || - params["stroke-linecap"] != null) { - var fill = node.getElementsByTagName(fillString), - newfill = false; - fill = fill && fill[0]; - !fill && (newfill = fill = createNode(fillString)); - if (o.type == "image" && params.src) { - fill.src = params.src; - } - params.fill && (fill.on = true); - if (fill.on == null || params.fill == "none" || params.fill === null) { - fill.on = false; - } - if (fill.on && params.fill) { - var isURL = Str(params.fill).match(R._ISURL); - if (isURL) { - fill.parentNode == node && node.removeChild(fill); - fill.rotate = true; - fill.src = isURL[1]; - fill.type = "tile"; - var bbox = o.getBBox(1); - fill.position = bbox.x + S + bbox.y; - o._.fillpos = [bbox.x, bbox.y]; - - R._preload(isURL[1], function () { - o._.fillsize = [this.offsetWidth, this.offsetHeight]; - }); - } else { - fill.color = R.getRGB(params.fill).hex; - fill.src = E; - fill.type = "solid"; - if (R.getRGB(params.fill).error && (res.type in {circle: 1, ellipse: 1} || Str(params.fill).charAt() != "r") && addGradientFill(res, params.fill, fill)) { - a.fill = "none"; - a.gradient = params.fill; - fill.rotate = false; - } - } - } - if ("fill-opacity" in params || "opacity" in params) { - var opacity = ((+a["fill-opacity"] + 1 || 2) - 1) * ((+a.opacity + 1 || 2) - 1) * ((+R.getRGB(params.fill).o + 1 || 2) - 1); - opacity = mmin(mmax(opacity, 0), 1); - fill.opacity = opacity; - if (fill.src) { - fill.color = "none"; - } - } - node.appendChild(fill); - var stroke = (node.getElementsByTagName("stroke") && node.getElementsByTagName("stroke")[0]), - newstroke = false; - !stroke && (newstroke = stroke = createNode("stroke")); - if ((params.stroke && params.stroke != "none") || - params["stroke-width"] || - params["stroke-opacity"] != null || - params["stroke-dasharray"] || - params["stroke-miterlimit"] || - params["stroke-linejoin"] || - params["stroke-linecap"]) { - stroke.on = true; - } - (params.stroke == "none" || params.stroke === null || stroke.on == null || params.stroke == 0 || params["stroke-width"] == 0) && (stroke.on = false); - var strokeColor = R.getRGB(params.stroke); - stroke.on && params.stroke && (stroke.color = strokeColor.hex); - opacity = ((+a["stroke-opacity"] + 1 || 2) - 1) * ((+a.opacity + 1 || 2) - 1) * ((+strokeColor.o + 1 || 2) - 1); - var width = (toFloat(params["stroke-width"]) || 1) * .75; - opacity = mmin(mmax(opacity, 0), 1); - params["stroke-width"] == null && (width = a["stroke-width"]); - params["stroke-width"] && (stroke.weight = width); - width && width < 1 && (opacity *= width) && (stroke.weight = 1); - stroke.opacity = opacity; - - params["stroke-linejoin"] && (stroke.joinstyle = params["stroke-linejoin"] || "miter"); - stroke.miterlimit = params["stroke-miterlimit"] || 8; - params["stroke-linecap"] && (stroke.endcap = params["stroke-linecap"] == "butt" ? "flat" : params["stroke-linecap"] == "square" ? "square" : "round"); - if (params["stroke-dasharray"]) { - var dasharray = { - "-": "shortdash", - ".": "shortdot", - "-.": "shortdashdot", - "-..": "shortdashdotdot", - ". ": "dot", - "- ": "dash", - "--": "longdash", - "- .": "dashdot", - "--.": "longdashdot", - "--..": "longdashdotdot" - }; - stroke.dashstyle = dasharray[has](params["stroke-dasharray"]) ? dasharray[params["stroke-dasharray"]] : E; - } - newstroke && node.appendChild(stroke); - } - if (res.type == "text") { - res.paper.canvas.style.display = E; - var span = res.paper.span, - m = 100, - fontSize = a.font && a.font.match(/\d+(?:\.\d*)?(?=px)/); - s = span.style; - a.font && (s.font = a.font); - a["font-family"] && (s.fontFamily = a["font-family"]); - a["font-weight"] && (s.fontWeight = a["font-weight"]); - a["font-style"] && (s.fontStyle = a["font-style"]); - fontSize = toFloat(a["font-size"] || fontSize && fontSize[0]) || 10; - s.fontSize = fontSize * m + "px"; - res.textpath.string && (span.innerHTML = Str(res.textpath.string).replace(/")); - var brect = span.getBoundingClientRect(); - res.W = a.w = (brect.right - brect.left) / m; - res.H = a.h = (brect.bottom - brect.top) / m; - // res.paper.canvas.style.display = "none"; - res.X = a.x; - res.Y = a.y + res.H / 2; - - ("x" in params || "y" in params) && (res.path.v = R.format("m{0},{1}l{2},{1}", round(a.x * zoom), round(a.y * zoom), round(a.x * zoom) + 1)); - var dirtyattrs = ["x", "y", "text", "font", "font-family", "font-weight", "font-style", "font-size"]; - for (var d = 0, dd = dirtyattrs.length; d < dd; d++) if (dirtyattrs[d] in params) { - res._.dirty = 1; - break; - } - - // text-anchor emulation - switch (a["text-anchor"]) { - case "start": - res.textpath.style["v-text-align"] = "left"; - res.bbx = res.W / 2; - break; - case "end": - res.textpath.style["v-text-align"] = "right"; - res.bbx = -res.W / 2; - break; - default: - res.textpath.style["v-text-align"] = "center"; - res.bbx = 0; - break; - } - res.textpath.style["v-text-kern"] = true; - } - // res.paper.canvas.style.display = E; - }, - addGradientFill = function (o, gradient, fill) { - o.attrs = o.attrs || {}; - var attrs = o.attrs, - pow = Math.pow, - opacity, - oindex, - type = "linear", - fxfy = ".5 .5"; - o.attrs.gradient = gradient; - gradient = Str(gradient).replace(R._radial_gradient, function (all, fx, fy) { - type = "radial"; - if (fx && fy) { - fx = toFloat(fx); - fy = toFloat(fy); - pow(fx - .5, 2) + pow(fy - .5, 2) > .25 && (fy = math.sqrt(.25 - pow(fx - .5, 2)) * ((fy > .5) * 2 - 1) + .5); - fxfy = fx + S + fy; - } - return E; - }); - gradient = gradient.split(/\s*\-\s*/); - if (type == "linear") { - var angle = gradient.shift(); - angle = -toFloat(angle); - if (isNaN(angle)) { - return null; - } - } - var dots = R._parseDots(gradient); - if (!dots) { - return null; - } - o = o.shape || o.node; - if (dots.length) { - o.removeChild(fill); - fill.on = true; - fill.method = "none"; - fill.color = dots[0].color; - fill.color2 = dots[dots.length - 1].color; - var clrs = []; - for (var i = 0, ii = dots.length; i < ii; i++) { - dots[i].offset && clrs.push(dots[i].offset + S + dots[i].color); - } - fill.colors = clrs.length ? clrs.join() : "0% " + fill.color; - if (type == "radial") { - fill.type = "gradientTitle"; - fill.focus = "100%"; - fill.focussize = "0 0"; - fill.focusposition = fxfy; - fill.angle = 0; - } else { - // fill.rotate= true; - fill.type = "gradient"; - fill.angle = (270 - angle) % 360; - } - o.appendChild(fill); - } - return 1; - }, - Element = function (node, vml) { - this[0] = this.node = node; - node.raphael = true; - this.id = R._oid++; - node.raphaelid = this.id; - this.X = 0; - this.Y = 0; - this.attrs = {}; - this.paper = vml; - this.matrix = R.matrix(); - this._ = { - transform: [], - sx: 1, - sy: 1, - dx: 0, - dy: 0, - deg: 0, - dirty: 1, - dirtyT: 1 - }; - !vml.bottom && (vml.bottom = this); - this.prev = vml.top; - vml.top && (vml.top.next = this); - vml.top = this; - this.next = null; - }; - var elproto = R.el; - - Element.prototype = elproto; - elproto.constructor = Element; - elproto.transform = function (tstr) { - if (tstr == null) { - return this._.transform; - } - var vbs = this.paper._viewBoxShift, - vbt = vbs ? "s" + [vbs.scale, vbs.scale] + "-1-1t" + [vbs.dx, vbs.dy] : E, - oldt; - if (vbs) { - oldt = tstr = Str(tstr).replace(/\.{3}|\u2026/g, this._.transform || E); - } - R._extractTransform(this, vbt + tstr); - var matrix = this.matrix.clone(), - skew = this.skew, - o = this.node, - split, - isGrad = ~Str(this.attrs.fill).indexOf("-"), - isPatt = !Str(this.attrs.fill).indexOf("url("); - matrix.translate(-.5, -.5); - if (isPatt || isGrad || this.type == "image") { - skew.matrix = "1 0 0 1"; - skew.offset = "0 0"; - split = matrix.split(); - if ((isGrad && split.noRotation) || !split.isSimple) { - o.style.filter = matrix.toFilter(); - var bb = this.getBBox(), - bbt = this.getBBox(1), - dx = bb.x - bbt.x, - dy = bb.y - bbt.y; - o.coordorigin = (dx * -zoom) + S + (dy * -zoom); - setCoords(this, 1, 1, dx, dy, 0); - } else { - o.style.filter = E; - setCoords(this, split.scalex, split.scaley, split.dx, split.dy, split.rotate); - } - } else { - o.style.filter = E; - skew.matrix = Str(matrix); - skew.offset = matrix.offset(); - } - oldt && (this._.transform = oldt); - return this; - }; - elproto.rotate = function (deg, cx, cy) { - if (this.removed) { - return this; - } - if (deg == null) { - return; - } - deg = Str(deg).split(separator); - if (deg.length - 1) { - cx = toFloat(deg[1]); - cy = toFloat(deg[2]); - } - deg = toFloat(deg[0]); - (cy == null) && (cx = cy); - if (cx == null || cy == null) { - var bbox = this.getBBox(1); - cx = bbox.x + bbox.width / 2; - cy = bbox.y + bbox.height / 2; - } - this._.dirtyT = 1; - this.transform(this._.transform.concat([["r", deg, cx, cy]])); - return this; - }; - elproto.translate = function (dx, dy) { - if (this.removed) { - return this; - } - dx = Str(dx).split(separator); - if (dx.length - 1) { - dy = toFloat(dx[1]); - } - dx = toFloat(dx[0]) || 0; - dy = +dy || 0; - if (this._.bbox) { - this._.bbox.x += dx; - this._.bbox.y += dy; - } - this.transform(this._.transform.concat([["t", dx, dy]])); - return this; - }; - elproto.scale = function (sx, sy, cx, cy) { - if (this.removed) { - return this; - } - sx = Str(sx).split(separator); - if (sx.length - 1) { - sy = toFloat(sx[1]); - cx = toFloat(sx[2]); - cy = toFloat(sx[3]); - isNaN(cx) && (cx = null); - isNaN(cy) && (cy = null); - } - sx = toFloat(sx[0]); - (sy == null) && (sy = sx); - (cy == null) && (cx = cy); - if (cx == null || cy == null) { - var bbox = this.getBBox(1); - } - cx = cx == null ? bbox.x + bbox.width / 2 : cx; - cy = cy == null ? bbox.y + bbox.height / 2 : cy; - - this.transform(this._.transform.concat([["s", sx, sy, cx, cy]])); - this._.dirtyT = 1; - return this; - }; - elproto.hide = function () { - !this.removed && (this.node.style.display = "none"); - return this; - }; - elproto.show = function () { - !this.removed && (this.node.style.display = E); - return this; - }; - elproto._getBBox = function () { - if (this.removed) { - return {}; - } - return { - x: this.X + (this.bbx || 0) - this.W / 2, - y: this.Y - this.H, - width: this.W, - height: this.H - }; - }; - elproto.remove = function () { - if (this.removed) { - return; - } - this.paper.__set__ && this.paper.__set__.exclude(this); - R.eve.unbind("*.*." + this.id); - R._tear(this, this.paper); - this.node.parentNode.removeChild(this.node); - this.shape && this.shape.parentNode.removeChild(this.shape); - for (var i in this) { - this[i] = typeof this[i] == "function" ? R._removedFactory(i) : null; - } - this.removed = true; - }; - elproto.attr = function (name, value) { - if (this.removed) { - return this; - } - if (name == null) { - var res = {}; - for (var a in this.attrs) if (this.attrs[has](a)) { - res[a] = this.attrs[a]; - } - res.gradient && res.fill == "none" && (res.fill = res.gradient) && delete res.gradient; - res.transform = this._.transform; - return res; - } - if (value == null && R.is(name, "string")) { - if (name == fillString && this.attrs.fill == "none" && this.attrs.gradient) { - return this.attrs.gradient; - } - var names = name.split(separator), - out = {}; - for (var i = 0, ii = names.length; i < ii; i++) { - name = names[i]; - if (name in this.attrs) { - out[name] = this.attrs[name]; - } else if (R.is(this.paper.customAttributes[name], "function")) { - out[name] = this.paper.customAttributes[name].def; - } else { - out[name] = R._availableAttrs[name]; - } - } - return ii - 1 ? out : out[names[0]]; - } - if (this.attrs && value == null && R.is(name, "array")) { - out = {}; - for (i = 0, ii = name.length; i < ii; i++) { - out[name[i]] = this.attr(name[i]); - } - return out; - } - var params; - if (value != null) { - params = {}; - params[name] = value; - } - value == null && R.is(name, "object") && (params = name); - for (var key in params) { - eve("attr." + key + "." + this.id, this, params[key]); - } - if (params) { - for (key in this.paper.customAttributes) if (this.paper.customAttributes[has](key) && params[has](key) && R.is(this.paper.customAttributes[key], "function")) { - var par = this.paper.customAttributes[key].apply(this, [].concat(params[key])); - this.attrs[key] = params[key]; - for (var subkey in par) if (par[has](subkey)) { - params[subkey] = par[subkey]; - } - } - // this.paper.canvas.style.display = "none"; - if (params.text && this.type == "text") { - this.textpath.string = params.text; - } - setFillAndStroke(this, params); - // this.paper.canvas.style.display = E; - } - return this; - }; - elproto.toFront = function () { - !this.removed && this.node.parentNode.appendChild(this.node); - this.paper && this.paper.top != this && R._tofront(this, this.paper); - return this; - }; - elproto.toBack = function () { - if (this.removed) { - return this; - } - if (this.node.parentNode.firstChild != this.node) { - this.node.parentNode.insertBefore(this.node, this.node.parentNode.firstChild); - R._toback(this, this.paper); - } - return this; - }; - elproto.insertAfter = function (element) { - if (this.removed) { - return this; - } - if (element.constructor == R.st.constructor) { - element = element[element.length - 1]; - } - if (element.node.nextSibling) { - element.node.parentNode.insertBefore(this.node, element.node.nextSibling); - } else { - element.node.parentNode.appendChild(this.node); - } - R._insertafter(this, element, this.paper); - return this; - }; - elproto.insertBefore = function (element) { - if (this.removed) { - return this; - } - if (element.constructor == R.st.constructor) { - element = element[0]; - } - element.node.parentNode.insertBefore(this.node, element.node); - R._insertbefore(this, element, this.paper); - return this; - }; - elproto.blur = function (size) { - var s = this.node.runtimeStyle, - f = s.filter; - f = f.replace(blurregexp, E); - if (+size !== 0) { - this.attrs.blur = size; - s.filter = f + S + ms + ".Blur(pixelradius=" + (+size || 1.5) + ")"; - s.margin = R.format("-{0}px 0 0 -{0}px", round(+size || 1.5)); - } else { - s.filter = f; - s.margin = 0; - delete this.attrs.blur; - } - }; - - R._engine.path = function (pathString, vml) { - var el = createNode("shape"); - el.style.cssText = cssDot; - el.coordsize = zoom + S + zoom; - el.coordorigin = vml.coordorigin; - var p = new Element(el, vml), - attr = {fill: "none", stroke: "#000"}; - pathString && (attr.path = pathString); - p.type = "path"; - p.path = []; - p.Path = E; - setFillAndStroke(p, attr); - vml.canvas.appendChild(el); - var skew = createNode("skew"); - skew.on = true; - el.appendChild(skew); - p.skew = skew; - p.transform(E); - return p; - }; - R._engine.rect = function (vml, x, y, w, h, r) { - var path = R._rectPath(x, y, w, h, r), - res = vml.path(path), - a = res.attrs; - res.X = a.x = x; - res.Y = a.y = y; - res.W = a.width = w; - res.H = a.height = h; - a.r = r; - a.path = path; - res.type = "rect"; - return res; - }; - R._engine.ellipse = function (vml, x, y, rx, ry) { - var res = vml.path(), - a = res.attrs; - res.X = x - rx; - res.Y = y - ry; - res.W = rx * 2; - res.H = ry * 2; - res.type = "ellipse"; - setFillAndStroke(res, { - cx: x, - cy: y, - rx: rx, - ry: ry - }); - return res; - }; - R._engine.circle = function (vml, x, y, r) { - var res = vml.path(), - a = res.attrs; - res.X = x - r; - res.Y = y - r; - res.W = res.H = r * 2; - res.type = "circle"; - setFillAndStroke(res, { - cx: x, - cy: y, - r: r - }); - return res; - }; - R._engine.image = function (vml, src, x, y, w, h) { - var path = R._rectPath(x, y, w, h), - res = vml.path(path).attr({stroke: "none"}), - a = res.attrs, - node = res.node, - fill = node.getElementsByTagName(fillString)[0]; - a.src = src; - res.X = a.x = x; - res.Y = a.y = y; - res.W = a.width = w; - res.H = a.height = h; - a.path = path; - res.type = "image"; - fill.parentNode == node && node.removeChild(fill); - fill.rotate = true; - fill.src = src; - fill.type = "tile"; - res._.fillpos = [x, y]; - res._.fillsize = [w, h]; - node.appendChild(fill); - setCoords(res, 1, 1, 0, 0, 0); - return res; - }; - R._engine.text = function (vml, x, y, text) { - var el = createNode("shape"), - path = createNode("path"), - o = createNode("textpath"); - x = x || 0; - y = y || 0; - text = text || ""; - path.v = R.format("m{0},{1}l{2},{1}", round(x * zoom), round(y * zoom), round(x * zoom) + 1); - path.textpathok = true; - o.string = Str(text); - o.on = true; - el.style.cssText = cssDot; - el.coordsize = zoom + S + zoom; - el.coordorigin = "0 0"; - var p = new Element(el, vml), - attr = { - fill: "#000", - stroke: "none", - font: R._availableAttrs.font, - text: text - }; - p.shape = el; - p.path = path; - p.textpath = o; - p.type = "text"; - p.attrs.text = Str(text); - p.attrs.x = x; - p.attrs.y = y; - p.attrs.w = 1; - p.attrs.h = 1; - setFillAndStroke(p, attr); - el.appendChild(o); - el.appendChild(path); - vml.canvas.appendChild(el); - var skew = createNode("skew"); - skew.on = true; - el.appendChild(skew); - p.skew = skew; - p.transform(E); - return p; - }; - R._engine.setSize = function (width, height) { - var cs = this.canvas.style; - this.width = width; - this.height = height; - width == +width && (width += "px"); - height == +height && (height += "px"); - cs.width = width; - cs.height = height; - cs.clip = "rect(0 " + width + " " + height + " 0)"; - if (this._viewBox) { - R._engine.setViewBox.apply(this, this._viewBox); - } - return this; - }; - R._engine.setViewBox = function (x, y, w, h, fit) { - R.eve("setViewBox", this, this._viewBox, [x, y, w, h, fit]); - var width = this.width, - height = this.height, - size = 1 / mmax(w / width, h / height), - H, W; - if (fit) { - H = height / h; - W = width / w; - if (w * H < width) { - x -= (width - w * H) / 2 / H; - } - if (h * W < height) { - y -= (height - h * W) / 2 / W; - } - } - this._viewBox = [x, y, w, h, !!fit]; - this._viewBoxShift = { - dx: -x, - dy: -y, - scale: size - }; - this.forEach(function (el) { - el.transform("..."); - }); - return this; - }; - var createNode; - R._engine.initWin = function (win) { - var doc = win.document; - doc.createStyleSheet().addRule(".rvml", "behavior:url(#default#VML)"); - try { - !doc.namespaces.rvml && doc.namespaces.add("rvml", "urn:schemas-microsoft-com:vml"); - createNode = function (tagName) { - return doc.createElement(''); - }; - } catch (e) { - createNode = function (tagName) { - return doc.createElement('<' + tagName + ' xmlns="urn:schemas-microsoft.com:vml" class="rvml">'); - }; - } - }; - R._engine.initWin(R._g.win); - R._engine.create = function () { - var con = R._getContainer.apply(0, arguments), - container = con.container, - height = con.height, - s, - width = con.width, - x = con.x, - y = con.y; - if (!container) { - throw new Error("VML container not found."); - } - var res = new R._Paper, - c = res.canvas = R._g.doc.createElement("div"), - cs = c.style; - x = x || 0; - y = y || 0; - width = width || 512; - height = height || 342; - res.width = width; - res.height = height; - width == +width && (width += "px"); - height == +height && (height += "px"); - res.coordsize = zoom * 1e3 + S + zoom * 1e3; - res.coordorigin = "0 0"; - res.span = R._g.doc.createElement("span"); - res.span.style.cssText = "position:absolute;left:-9999em;top:-9999em;padding:0;margin:0;line-height:1;"; - c.appendChild(res.span); - cs.cssText = R.format("top:0;left:0;width:{0};height:{1};display:inline-block;position:relative;clip:rect(0 {0} {1} 0);overflow:hidden", width, height); - if (container == 1) { - R._g.doc.body.appendChild(c); - cs.left = x + "px"; - cs.top = y + "px"; - cs.position = "absolute"; - } else { - if (container.firstChild) { - container.insertBefore(c, container.firstChild); - } else { - container.appendChild(c); - } - } - // plugins.call(res, res, R.fn); - res.renderfix = function () {}; - return res; - }; - R.prototype.clear = function () { - R.eve("clear", this); - this.canvas.innerHTML = E; - this.span = R._g.doc.createElement("span"); - this.span.style.cssText = "position:absolute;left:-9999em;top:-9999em;padding:0;margin:0;line-height:1;display:inline;"; - this.canvas.appendChild(this.span); - this.bottom = this.top = null; - }; - R.prototype.remove = function () { - R.eve("remove", this); - this.canvas.parentNode.removeChild(this.canvas); - for (var i in this) { - this[i] = typeof this[i] == "function" ? R._removedFactory(i) : null; - } - return true; - }; - - var setproto = R.st; - for (var method in elproto) if (elproto[has](method) && !setproto[has](method)) { - setproto[method] = (function (methodname) { - return function () { - var arg = arguments; - return this.forEach(function (el) { - el[methodname].apply(el, arg); - }); - }; - })(method); - } -}(window.Raphael); \ No newline at end of file diff --git a/addons/web_diagram/static/src/js/vec2js/vec2.js b/addons/web_diagram/static/src/js/vec2.js similarity index 100% rename from addons/web_diagram/static/src/js/vec2js/vec2.js rename to addons/web_diagram/static/src/js/vec2.js From 666f20339509211308aabcd30455928fb7515f5e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fr=C3=A9d=C3=A9ric=20van=20der=20Essen?= Date: Fri, 24 Feb 2012 16:01:43 +0100 Subject: [PATCH 017/196] [IMP] ignore vim session files bzr revid: fva@openerp.com-20120224150143-032voefkvou5agn9 --- .bzrignore | 33 +++++++++++---------------------- 1 file changed, 11 insertions(+), 22 deletions(-) diff --git a/.bzrignore b/.bzrignore index 62f8a05c90f..a797d0cfc05 100644 --- a/.bzrignore +++ b/.bzrignore @@ -1,23 +1,12 @@ -*.pyc -.*.swp -.bzrignore -openerp/addons/* -openerp/filestore* -.Python -include -lib -bin/activate -bin/activate_this.py -bin/easy_install -bin/easy_install-2.6 -bin/pip -bin/python -bin/python2.6 -*.pyc -*.pyo +.* +*.egg-info +*.orig +*.vim build/ -bin/yolk -bin/pil*.py -.project -.pydevproject -.settings +RE:^bin/ +RE:^dist/ +RE:^include/ + +RE:^share/ +RE:^man/ +RE:^lib/ From 6c3311cd9a37739fd865c965fbfa9ca751cb9302 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fr=C3=A9d=C3=A9ric=20van=20der=20Essen?= Date: Fri, 24 Feb 2012 16:04:17 +0100 Subject: [PATCH 018/196] [IMP] removing css expermiments for diagram implementation bzr revid: fva@openerp.com-20120224150417-89cq4v6ovpffwb8e --- .../static/src/css/base_diagram.css | 23 ------------------- 1 file changed, 23 deletions(-) diff --git a/addons/web_diagram/static/src/css/base_diagram.css b/addons/web_diagram/static/src/css/base_diagram.css index 5fb883721be..32aae531393 100644 --- a/addons/web_diagram/static/src/css/base_diagram.css +++ b/addons/web_diagram/static/src/css/base_diagram.css @@ -35,26 +35,3 @@ user-select: none; }; -/* -.openerp .diagram{ - margin:0; - padding:0; - position:absolute; - top:178px; - bottom:26px; - left:201px; - right:0; - background-color:white; - border-style:none; - border-top-style:solid; - border-top-width:1px; - border-top-color:#DCDCDC; - overflow:hidden; - -}*/ -/* -#widget-19_view_diagram { - position:relative; -}*/ - - From 2adcdd3aad92a0a14545d9348617fde0939eb4a1 Mon Sep 17 00:00:00 2001 From: Xavier Morel Date: Fri, 24 Feb 2012 16:48:25 +0100 Subject: [PATCH 019/196] [FIX] warnings (implicit globals, missing semicolons, unused variables) bzr revid: xmo@openerp.com-20120224154825-gzimhyqcozbisbwm --- addons/web_diagram/static/src/js/diagram.js | 2 +- addons/web_diagram/static/src/js/graph.js | 75 ++++++++++----------- addons/web_diagram/static/src/js/vec2.js | 6 +- 3 files changed, 40 insertions(+), 43 deletions(-) diff --git a/addons/web_diagram/static/src/js/diagram.js b/addons/web_diagram/static/src/js/diagram.js index 2c6bb29d8ff..0ea7fbe3281 100644 --- a/addons/web_diagram/static/src/js/diagram.js +++ b/addons/web_diagram/static/src/js/diagram.js @@ -120,7 +120,7 @@ openerp.web.DiagramView = openerp.web.View.extend({ var res_edges = result['conn']; this.parent_field = result.parent_field; - var id_to_node = {} + var id_to_node = {}; var style = { "edge" : "#A0A0A0", diff --git a/addons/web_diagram/static/src/js/graph.js b/addons/web_diagram/static/src/js/graph.js index 9f77b40303e..2b36cbb8fb7 100644 --- a/addons/web_diagram/static/src/js/graph.js +++ b/addons/web_diagram/static/src/js/graph.js @@ -23,10 +23,10 @@ this.update_pos = function(){ conn_circle.attr({'cx':node.get_pos().x + pos_x, 'cy':node.get_pos().y + pos_y}); - } + }; this.get_pos = function(){ return new node.get_pos().add_xy(pos_x,pos_y); - } + }; function hover_in(){ if(!visible){ return;} conn_circle.animate({'r':8},300,'elastic'); @@ -51,25 +51,25 @@ self.edge_end = new EdgeEnd(self.ox, self.oy); self.edge_tmp = new GraphEdge(graph,'',self.edge_start,self.edge_end,true); graph.creating_edge = true; - } + }; var drag_move = function(dx,dy){ if(!visible){ return; } self.edge_end.x = self.ox + dx; self.edge_end.y = self.oy + dy; self.edge_tmp.update(); - } + }; var drag_up = function(){ if(!visible){ return; } graph.creating_edge = false; self.edge_tmp.remove(); if(graph.target_node){ - edge_prop = GraphEdge.creation_callback(node,graph.target_node); + var edge_prop = GraphEdge.creation_callback(node,graph.target_node); if(edge_prop){ var new_edge = new GraphEdge(graph,edge_prop.label, node,graph.target_node); GraphEdge.new_edge_callback(new_edge); } } - } + }; conn_circle.drag(drag_move,drag_down,drag_up); function show(){ @@ -93,7 +93,7 @@ var nodes = []; // list of all nodes in the graph var edges = []; // list of all edges in the graph var graph = {}; // graph[n1.uid][n2.uid] -> list of all edges from n1 to n2 - var links = {} // links[n.uid] -> list of all edges from or to n + var links = {}; // links[n.uid] -> list of all edges from or to n var uid = 1; // all nodes and edges have an uid used to order their display when they are curved self.creating_edge = false; // true if we are dragging a new edge onto a node @@ -101,14 +101,13 @@ self.r = r; // the raphael instance self.style = style; // definition of the colors, spacing, fonts, ... used by the elements var tr_x = 0, tr_y = 0; // global translation coordinate - var scale = 1; // global scale var background = r.rect(0,0,'100%','100%').attr({'fill':'white', 'stroke':'none', 'opacity':0}); // return the global transform of the scene this.get_transform = function(){ return "T"+tr_x+","+tr_y - } + }; // translate every element of the graph except the background. @@ -117,34 +116,35 @@ var translate_all = function(dx,dy){ tr_x += dx; tr_y += dy; - tstr = self.get_transform(); + var tstr = self.get_transform(); r.forEach(function(el){ if(el != background){ el.transform(tstr); } }); - } + }; //Adds a mousewheel event callback to raph_element that scrolls the viewport this.set_scrolling = function(raph_element){ $(raph_element.node).bind('mousewheel',function(event,delta){ translate_all(0,delta*20); }); - } + }; + var px, py; // Graph translation when background is dragged var bg_drag_down = function(){ px = py = 0; - } + }; var bg_drag_move = function(x,y){ var dx = x - px; var dy = y - py; px = x; py = y; translate_all(dx,dy); - } - var bg_drag_up = function(){} + }; + var bg_drag_up = function(){}; background.drag( bg_drag_move, bg_drag_down, bg_drag_up); this.set_scrolling(background); @@ -181,7 +181,7 @@ links[n1.uid] = _.without(links[n1.uid],edge); links[n2.uid] = _.without(links[n2.uid],edge); graph[n1.uid][n2.uid] = _.without(graph[n1.uid][n2.uid],edge); - } + }; //return the list of edges from n1 to n2 this.get_edge_list = function(n1,n2){ var list = []; @@ -193,7 +193,7 @@ this.get_linked_edge_list = function(n){ if(!links[n.uid]) return []; return links[n.uid]; - } + }; //return a curvature index so that all edges connecting n1,n2 have different curvatures this.get_edge_curvature = function(n1,n2,e){ var el_12 = this.get_edge_list(n1,n2); @@ -219,7 +219,6 @@ // Returns the angle in degrees of the edge loop. We do not support more than 8 loops on one node this.get_loop_angle = function(n,e){ var loop_list = this.get_edge_list(n,n); - var lc = loop_list.length; var slots = []; // the 8 angles where we can put the loops for(var angle = 0; angle < 360; angle += 45){ @@ -265,7 +264,7 @@ index++; } } - index = index % slots.length; + index %= slots.length; return slots[index].angle_deg(); } @@ -280,7 +279,6 @@ var sx = graph.style.node_size_x; var node_fig = null; var selected = false; - this.update_time = 0; this.connectors = []; this.uid = 0; @@ -309,7 +307,7 @@ for(var i = 0; i < edges.length; i++){ edges[i].update(); } - } + }; // sets the center position of the node var set_pos = function(pos){ @@ -323,11 +321,11 @@ self.connectors[i].update_pos(); } update_linked_edges(); - } + }; // returns the figure used to draw the node var get_fig = function(){ return node_fig; - } + }; // returns the center coordinates var get_pos = function(){ if(type == 'circle'){ @@ -335,22 +333,22 @@ }else{ return new Vec2(node_fig.attr('x') + sx/2, node_fig.attr('y') + sy/2); } - } + }; // return the label string var get_label = function(){ return node_label.attr("text"); - } + }; // sets the label string var set_label = function(text){ node_label.attr({'text':text}); - } + }; var get_bound = function(){ if(type == 'circle'){ return new BEllipse(get_pos().x,get_pos().y,sx/2,sy/2); }else{ return BRect.new_centered(get_pos().x,get_pos().y,sx,sy); } - } + }; // selects this node and deselects all other nodes var set_selected = function(){ if(!selected){ @@ -366,7 +364,7 @@ self.connectors[i].show(); } } - } + }; // deselect this node var set_not_selected = function(){ if(selected){ @@ -376,7 +374,7 @@ for(var i = 0; i < self.connectors.length; i++){ self.connectors[i].hide(); } - } + }; this.set_pos = set_pos; this.get_pos = get_pos; @@ -385,7 +383,7 @@ this.get_bound = get_bound; this.get_fig = get_fig; this.set_selected = set_selected; - this.set_not_selected = set_not_selected + this.set_not_selected = set_not_selected; this.update_linked_edges = update_linked_edges; @@ -401,14 +399,14 @@ node_fig.animate({'x':cx - sx/2, 'y':cy - sy/2, 'ẃidth':sx, 'height':sy},500,'elastic'); } set_selected(); - } + }; node_fig.click(click_action); node_label.click(click_action); //move the node when dragged var drag_down = function(){ this.opos = get_pos(); - } + }; var drag_move = function(dx,dy){ // we disable labels when moving for performance reasons, // updating the label position is quite expensive @@ -418,7 +416,7 @@ edges[i].label_disable(); } set_pos(this.opos.add_xy(dx,dy)); - } + }; var drag_up = function(){ //we re-enable the var edges = graph.get_linked_edge_list(self); @@ -426,7 +424,7 @@ edges[i].label_enable(); } - } + }; node_fig.drag(drag_move,drag_down,drag_up); node_label.drag(drag_move,drag_down,drag_up); @@ -456,7 +454,7 @@ GraphNode.double_click_callback = function(node){ console.log("double click from node:",node); - } + }; // creates a new edge with label 'label' from start to end. start and end must implement get_pos_*, // if tmp is true, the edge is not added to the graph, used for drag edges. @@ -464,7 +462,6 @@ function GraphEdge(graph,label,start,end,tmp){ var self = this; var r = graph.r; - var update_time = -1; var curvature = 0; // 0 = straight, != 0 curved var s,e; // positions of the start and end point of the line between start and end var mc; // position of the middle of the curve (bezier control point) @@ -547,7 +544,7 @@ var r = Vec2.new_polar_deg(rad,graph.get_loop_angle(start,self)); mc = s.add(r); - p = r.rotate_deg(90); + var p = r.rotate_deg(90); mc1 = mc.add(p.set_len(rad*0.5)); mc2 = mc.add(p.set_len(-rad*0.5)); @@ -647,7 +644,7 @@ GraphEdge.double_click_callback = function(edge){ console.log("double click from edge:",edge); - } + }; // this is the default edge creation callback. It is called before an edge is created // It returns an object containing the properties of the edge. @@ -670,7 +667,7 @@ var brk = '\n'; if (!str) { return str; } var regex = '.{1,' +width+ '}(\\s|$)' + (cut ? '|.{' +width+ '}|.+$' : '|\\S+?(\\s|$)'); - return str.match( RegExp(regex, 'g') ).join( brk ); + return str.match(new RegExp(regex, 'g') ).join( brk ); } window.CuteGraph = Graph; diff --git a/addons/web_diagram/static/src/js/vec2.js b/addons/web_diagram/static/src/js/vec2.js index 73b13d04125..c86246c2a7b 100644 --- a/addons/web_diagram/static/src/js/vec2.js +++ b/addons/web_diagram/static/src/js/vec2.js @@ -216,7 +216,7 @@ this.hx = rx; // half of the ellipse width on the x axis this.hy = ry; // half of the ellipse width on the y axis this.cx = cx; // x coordinate of the ellipse center - this.cy = cy; // y coordinqte of the ellipse center + this.cy = cy; // y coordinate of the ellipse center this.mx = cx + rx; // maximum x coordinate contained in the ellipse this.my = cy + ry; // maximum x coordinate contained in the ellipse } @@ -226,7 +226,7 @@ // boundary and a line segment defined by the start and end vectors a,b BEllipse.prototype.collide_segment = function(a,b){ // http://paulbourke.net/geometry/sphereline/ - collisions = [] + var collisions = []; if(a.equals(b)){ //we do not compute the intersection in this case. TODO ? return collisions; @@ -318,7 +318,7 @@ // boundary and a line segment defined by the start and end vectors a,b BRect.prototype.collide_segment = function(a,b){ - var collisions = [] + var collisions = []; var corners = [ new Vec2(this.x,this.y), new Vec2(this.x,this.my), new Vec2(this.mx,this.my), new Vec2(this.mx,this.y) ]; var pos = line_intersect(a,b,corners[0],corners[1]); From af36854aa217f092d777210cb1cb18e4f195d44c Mon Sep 17 00:00:00 2001 From: Xavier Morel Date: Fri, 24 Feb 2012 16:57:41 +0100 Subject: [PATCH 020/196] [FIX] set a single numeric id as the m2o value in the 'new node' popup to force a name_get resolution with a pair, the field's textual value would get set to 'undefined' leading to inconsistent behavior depending on whether the field is visible or not bzr revid: xmo@openerp.com-20120224155741-o43tndbmxfsmcub7 --- addons/web_diagram/static/src/js/diagram.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/addons/web_diagram/static/src/js/diagram.js b/addons/web_diagram/static/src/js/diagram.js index 0ea7fbe3281..288aec62e6f 100644 --- a/addons/web_diagram/static/src/js/diagram.js +++ b/addons/web_diagram/static/src/js/diagram.js @@ -238,7 +238,7 @@ openerp.web.DiagramView = openerp.web.View.extend({ _.each(form_fields, function(fld) { if (!(fld in form_controller.fields)) { return; } var field = form_controller.fields[fld]; - field.set_value([self.id,self.active_model]); + field.set_value(self.id); field.dirty = true; }); }); From 2832fadd21c6c3c6eaeaf8f340f3136d910108a9 Mon Sep 17 00:00:00 2001 From: Xavier Morel Date: Fri, 24 Feb 2012 16:59:04 +0100 Subject: [PATCH 021/196] [REM] leftover logging bzr revid: xmo@openerp.com-20120224155904-nz4mzhtkg9j9rexn --- addons/web_diagram/static/src/js/diagram.js | 1 - 1 file changed, 1 deletion(-) diff --git a/addons/web_diagram/static/src/js/diagram.js b/addons/web_diagram/static/src/js/diagram.js index 288aec62e6f..194565aa746 100644 --- a/addons/web_diagram/static/src/js/diagram.js +++ b/addons/web_diagram/static/src/js/diagram.js @@ -115,7 +115,6 @@ openerp.web.DiagramView = openerp.web.View.extend({ // Set-up the drawing elements of the diagram draw_diagram: function(result) { var self = this; - console.log(result); var res_nodes = result['nodes']; var res_edges = result['conn']; this.parent_field = result.parent_field; From 49b2920b8298e20e12944bb067f3ede1b02d07b7 Mon Sep 17 00:00:00 2001 From: "Ujjvala Collins (OpenERP)" Date: Mon, 27 Feb 2012 11:26:35 +0530 Subject: [PATCH 022/196] [IMP]: Improved code. bzr revid: uco@tinyerp.com-20120227055635-ugxsh4rh6flw3ryu --- addons/account/account_installer.xml | 7 -- addons/plugin_outlook/plugin_outlook.xml | 15 ++-- .../plugin_thunderbird/plugin_thunderbird.xml | 16 +++-- addons/sale/sale.py | 70 +++++++++++-------- addons/sale/sale_view.xml | 1 - addons/sale/security/sale_security.xml | 8 +-- addons/sale/test/manual_order_policy.yml | 6 +- 7 files changed, 70 insertions(+), 53 deletions(-) diff --git a/addons/account/account_installer.xml b/addons/account/account_installer.xml index 430d65e0bf9..01c684a0736 100644 --- a/addons/account/account_installer.xml +++ b/addons/account/account_installer.xml @@ -55,13 +55,6 @@ 5 - - - - 3 - automatic - - Review your Financial Accounts ir.actions.act_window diff --git a/addons/plugin_outlook/plugin_outlook.xml b/addons/plugin_outlook/plugin_outlook.xml index 37b924f319f..68e265e0730 100644 --- a/addons/plugin_outlook/plugin_outlook.xml +++ b/addons/plugin_outlook/plugin_outlook.xml @@ -48,11 +48,16 @@ new - - - - 4 - automatic + + Sales Application + sale.configuration + form + + + +