@datagrok/helm 2.3.2 → 2.3.3

package/vendor/dojo-1.10.10/dojox/charting/plot2d/StackedColumns.js

@@ -0,0 +1,20 @@
+//>>built
+define("dojox/charting/plot2d/StackedColumns",["dojo/_base/declare","./Columns","./commonStacked"],function(_1,_2,_3){
+return _1("dojox.charting.plot2d.StackedColumns",_2,{getSeriesStats:function(){
+var _4=_3.collectStats(this.series);
+_4.hmin-=0.5;
+_4.hmax+=0.5;
+return _4;
+},getValue:function(_5,_6,_7,_8){
+var x,y;
+if(_8){
+x=_6;
+y=_3.getIndexValue(this.series,_7,x);
+}else{
+x=_5.x-1;
+y=_3.getValue(this.series,_7,_5.x);
+y=[y[0]?y[0].y:null,y[1]?y[1]:null];
+}
+return {x:x,y:y[0],py:y[1]};
+}});
+});

package/vendor/dojo-1.10.10/dojox/charting/plot2d/StackedColumns.js.uncompressed.js

@@ -0,0 +1,31 @@
+define("dojox/charting/plot2d/StackedColumns", ["dojo/_base/declare", "./Columns", "./commonStacked"], 
+	function( declare, Columns, commonStacked){
+
+	return declare("dojox.charting.plot2d.StackedColumns", Columns, {
+		// summary:
+		//		The plot object representing a stacked column chart (vertical bars).
+		getSeriesStats: function(){
+			// summary:
+			//		Calculate the min/max on all attached series in both directions.
+			// returns: Object
+			//		{hmin, hmax, vmin, vmax} min/max in both directions.
+			var stats = commonStacked.collectStats(this.series);
+			stats.hmin -= 0.5;
+			stats.hmax += 0.5;
+			return stats; // Object
+		},
+		getValue: function(value, index, seriesIndex, indexed){
+			var x, y;
+			if(indexed){
+				x = index;
+				y = commonStacked.getIndexValue(this.series, seriesIndex, x);
+			}else{
+				x = value.x - 1;
+				y = commonStacked.getValue(this.series, seriesIndex, value.x);
+				y = [  y[0]?y[0].y:null, y[1]?y[1]:null ];
+			}
+			// in py we return the previous stack value as we need it to position labels on columns
+			return { x: x, y: y[0], py: y[1] };
+		}
+	});
+});

package/vendor/dojo-1.10.10/dojox/charting/plot2d/StackedLines.js

@@ -0,0 +1,6 @@
+//>>built
+define("dojox/charting/plot2d/StackedLines",["dojo/_base/declare","./Stacked"],function(_1,_2){
+return _1("dojox.charting.plot2d.StackedLines",_2,{constructor:function(){
+this.opt.lines=true;
+}});
+});

package/vendor/dojo-1.10.10/dojox/charting/plot2d/StackedLines.js.uncompressed.js

@@ -0,0 +1,12 @@
+define("dojox/charting/plot2d/StackedLines", ["dojo/_base/declare", "./Stacked"], function(declare, Stacked){
+
+	return declare("dojox.charting.plot2d.StackedLines", Stacked, {
+		// summary:
+		//		A convenience object to create a stacked line chart.
+		constructor: function(){
+			// summary:
+			//		Force our Stacked base to be lines only.
+			this.opt.lines = true;
+		}
+	});
+});

package/vendor/dojo-1.10.10/dojox/charting/plot2d/_PlotEvents.js

@@ -0,0 +1,68 @@
+//>>built
+define("dojox/charting/plot2d/_PlotEvents",["dojo/_base/lang","dojo/_base/array","dojo/_base/declare","dojo/_base/connect"],function(_1,_2,_3,_4){
+return _3("dojox.charting.plot2d._PlotEvents",null,{constructor:function(){
+this._shapeEvents=[];
+this._eventSeries={};
+},destroy:function(){
+this.resetEvents();
+this.inherited(arguments);
+},plotEvent:function(o){
+},raiseEvent:function(o){
+this.plotEvent(o);
+var t=_1.delegate(o);
+t.originalEvent=o.type;
+t.originalPlot=o.plot;
+t.type="onindirect";
+_2.forEach(this.chart.stack,function(_5){
+if(_5!==this&&_5.plotEvent){
+t.plot=_5;
+_5.plotEvent(t);
+}
+},this);
+},connect:function(_6,_7){
+this.dirty=true;
+return _4.connect(this,"plotEvent",_6,_7);
+},events:function(){
+return !!this.plotEvent.after;
+},resetEvents:function(){
+if(this._shapeEvents.length){
+_2.forEach(this._shapeEvents,function(_8){
+_8.shape.disconnect(_8.handle);
+});
+this._shapeEvents=[];
+}
+this.raiseEvent({type:"onplotreset",plot:this});
+},_connectSingleEvent:function(o,_9){
+this._shapeEvents.push({shape:o.eventMask,handle:o.eventMask.connect(_9,this,function(e){
+o.type=_9;
+o.event=e;
+this.raiseEvent(o);
+o.event=null;
+})});
+},_connectEvents:function(o){
+if(o){
+o.chart=this.chart;
+o.plot=this;
+o.hAxis=this.hAxis||null;
+o.vAxis=this.vAxis||null;
+o.eventMask=o.eventMask||o.shape;
+this._connectSingleEvent(o,"onmouseover");
+this._connectSingleEvent(o,"onmouseout");
+this._connectSingleEvent(o,"onclick");
+}
+},_reconnectEvents:function(_a){
+var a=this._eventSeries[_a];
+if(a){
+_2.forEach(a,this._connectEvents,this);
+}
+},fireEvent:function(_b,_c,_d,_e){
+var s=this._eventSeries[_b];
+if(s&&s.length&&_d<s.length){
+var o=s[_d];
+o.type=_c;
+o.event=_e||null;
+this.raiseEvent(o);
+o.event=null;
+}
+}});
+});

package/vendor/dojo-1.10.10/dojox/charting/plot2d/_PlotEvents.js.uncompressed.js

@@ -0,0 +1,120 @@
+define("dojox/charting/plot2d/_PlotEvents", ["dojo/_base/lang", "dojo/_base/array", "dojo/_base/declare", "dojo/_base/connect"], 
+	function(lang, arr, declare, hub){
+
+	return declare("dojox.charting.plot2d._PlotEvents", null, {
+		constructor: function(){
+			this._shapeEvents = [];
+			this._eventSeries = {};
+		},
+		destroy: function(){
+			// summary:
+			//		Destroy any internal elements and event handlers.
+			this.resetEvents();
+			this.inherited(arguments);
+		},
+		plotEvent: function(o){
+			// summary:
+			//		Stub function for use by specific plots.
+			// o: Object
+			//		An object intended to represent event parameters.
+		},
+		raiseEvent: function(o){
+			// summary:
+			//		Raises events in predefined order
+			// o: Object
+			//		An object intended to represent event parameters.
+			this.plotEvent(o);
+			var t = lang.delegate(o);
+			t.originalEvent = o.type;
+			t.originalPlot  = o.plot;
+			t.type = "onindirect";
+			arr.forEach(this.chart.stack, function(plot){
+				if(plot !== this && plot.plotEvent){
+					t.plot = plot;
+					plot.plotEvent(t);
+				}
+			}, this);
+		},
+		connect: function(object, method){
+			// summary:
+			//		Helper function to connect any object's method to our plotEvent.
+			// object: Object
+			//		The object to connect to.
+			// method: String|Function
+			//		The method to fire when our plotEvent is fired.
+			// returns: Array
+			//		The handle as returned from dojo.connect (see dojo.connect).
+			this.dirty = true;
+			return hub.connect(this, "plotEvent", object, method);	//	Array
+		},
+		events: function(){
+			// summary:
+			//		Find out if any event handlers have been connected to our plotEvent.
+			// returns: Boolean
+			//		A flag indicating that there are handlers attached.
+			return !!this.plotEvent.after;
+		},
+		resetEvents: function(){
+			// summary:
+			//		Reset all events attached to our plotEvent (i.e. disconnect).
+			if(this._shapeEvents.length){
+				arr.forEach(this._shapeEvents, function(item){
+					item.shape.disconnect(item.handle);
+				});
+				this._shapeEvents = [];
+			}
+			this.raiseEvent({type: "onplotreset", plot: this});
+		},
+		_connectSingleEvent: function(o, eventName){
+			this._shapeEvents.push({
+				shape:  o.eventMask,
+				handle: o.eventMask.connect(eventName, this, function(e){
+					o.type  = eventName;
+					o.event = e;
+					this.raiseEvent(o);
+					o.event = null;
+				})
+			});
+		},
+		_connectEvents: function(o){
+			if(o){
+				o.chart = this.chart;
+				o.plot  = this;
+				o.hAxis = this.hAxis || null;
+				o.vAxis = this.vAxis || null;
+				o.eventMask = o.eventMask || o.shape;
+				this._connectSingleEvent(o, "onmouseover");
+				this._connectSingleEvent(o, "onmouseout");
+				this._connectSingleEvent(o, "onclick");
+			}
+		},
+		_reconnectEvents: function(seriesName){
+			var a = this._eventSeries[seriesName];
+			if(a){
+				arr.forEach(a, this._connectEvents, this);
+			}
+		},
+		fireEvent: function(seriesName, eventName, index, eventObject){
+			// summary:
+			//		Emulates firing an event for a given data value (specified by
+			//		an index) of a given series.
+			// seriesName: String
+			//		Series name.
+			// eventName: String
+			//		Event name to emulate.
+			// index: Number
+			//		Valid data value index used to raise an event.
+			// eventObject: Object?
+			//		Optional event object. Especially useful for synthetic events.
+			//		Default: null.
+			var s = this._eventSeries[seriesName];
+			if(s && s.length && index < s.length){
+				var o = s[index];
+				o.type  = eventName;
+				o.event = eventObject || null;
+				this.raiseEvent(o);
+				o.event = null;
+			}
+		}
+	});
+});

package/vendor/dojo-1.10.10/dojox/charting/plot2d/common.js

@@ -0,0 +1,209 @@
+//>>built
+define("dojox/charting/plot2d/common",["dojo/_base/lang","dojo/_base/array","dojo/_base/Color","dojox/gfx","dojox/lang/functional","../scaler/common"],function(_1,_2,_3,g,df,sc){
+var _4=_1.getObject("dojox.charting.plot2d.common",true);
+return _1.mixin(_4,{doIfLoaded:sc.doIfLoaded,makeStroke:function(_5){
+if(!_5){
+return _5;
+}
+if(typeof _5=="string"||_5 instanceof _3){
+_5={color:_5};
+}
+return g.makeParameters(g.defaultStroke,_5);
+},augmentColor:function(_6,_7){
+var t=new _3(_6),c=new _3(_7);
+c.a=t.a;
+return c;
+},augmentStroke:function(_8,_9){
+var s=_4.makeStroke(_8);
+if(s){
+s.color=_4.augmentColor(s.color,_9);
+}
+return s;
+},augmentFill:function(_a,_b){
+var fc,c=new _3(_b);
+if(typeof _a=="string"||_a instanceof _3){
+return _4.augmentColor(_a,_b);
+}
+return _a;
+},defaultStats:{vmin:Number.POSITIVE_INFINITY,vmax:Number.NEGATIVE_INFINITY,hmin:Number.POSITIVE_INFINITY,hmax:Number.NEGATIVE_INFINITY},collectSimpleStats:function(_c){
+var _d=_1.delegate(_4.defaultStats);
+for(var i=0;i<_c.length;++i){
+var _e=_c[i];
+for(var j=0;j<_e.data.length;j++){
+if(_e.data[j]!==null){
+if(typeof _e.data[j]=="number"){
+var _f=_d.vmin,_10=_d.vmax;
+_2.forEach(_e.data,function(val,i){
+if(val!==null){
+var x=i+1,y=val;
+if(isNaN(y)){
+y=0;
+}
+_d.hmin=Math.min(_d.hmin,x);
+_d.hmax=Math.max(_d.hmax,x);
+_d.vmin=Math.min(_d.vmin,y);
+_d.vmax=Math.max(_d.vmax,y);
+}
+});
+if("ymin" in _e){
+_d.vmin=Math.min(_f,_e.ymin);
+}
+if("ymax" in _e){
+_d.vmax=Math.max(_10,_e.ymax);
+}
+}else{
+var _11=_d.hmin,_12=_d.hmax,_f=_d.vmin,_10=_d.vmax;
+if(!("xmin" in _e)||!("xmax" in _e)||!("ymin" in _e)||!("ymax" in _e)){
+_2.forEach(_e.data,function(val,i){
+if(val!==null){
+var x="x" in val?val.x:i+1,y=val.y;
+if(isNaN(x)){
+x=0;
+}
+if(isNaN(y)){
+y=0;
+}
+_d.hmin=Math.min(_d.hmin,x);
+_d.hmax=Math.max(_d.hmax,x);
+_d.vmin=Math.min(_d.vmin,y);
+_d.vmax=Math.max(_d.vmax,y);
+}
+});
+}
+if("xmin" in _e){
+_d.hmin=Math.min(_11,_e.xmin);
+}
+if("xmax" in _e){
+_d.hmax=Math.max(_12,_e.xmax);
+}
+if("ymin" in _e){
+_d.vmin=Math.min(_f,_e.ymin);
+}
+if("ymax" in _e){
+_d.vmax=Math.max(_10,_e.ymax);
+}
+}
+break;
+}
+}
+}
+return _d;
+},calculateBarSize:function(_13,opt,_14){
+if(!_14){
+_14=1;
+}
+var gap=opt.gap,_15=(_13-2*gap)/_14;
+if("minBarSize" in opt){
+_15=Math.max(_15,opt.minBarSize);
+}
+if("maxBarSize" in opt){
+_15=Math.min(_15,opt.maxBarSize);
+}
+_15=Math.max(_15,1);
+gap=(_13-_15*_14)/2;
+return {size:_15,gap:gap};
+},collectStackedStats:function(_16){
+var _17=_1.clone(_4.defaultStats);
+if(_16.length){
+_17.hmin=Math.min(_17.hmin,1);
+_17.hmax=df.foldl(_16,"seed, run -> Math.max(seed, run.data.length)",_17.hmax);
+for(var i=0;i<_17.hmax;++i){
+var v=_16[0].data[i];
+v=v&&(typeof v=="number"?v:v.y);
+if(isNaN(v)){
+v=0;
+}
+_17.vmin=Math.min(_17.vmin,v);
+for(var j=1;j<_16.length;++j){
+var t=_16[j].data[i];
+t=t&&(typeof t=="number"?t:t.y);
+if(isNaN(t)){
+t=0;
+}
+v+=t;
+}
+_17.vmax=Math.max(_17.vmax,v);
+}
+}
+return _17;
+},curve:function(a,_18){
+var _19=a.slice(0);
+if(_18=="x"){
+_19[_19.length]=_19[0];
+}
+var p=_2.map(_19,function(_1a,i){
+if(i==0){
+return "M"+_1a.x+","+_1a.y;
+}
+if(!isNaN(_18)){
+var dx=_1a.x-_19[i-1].x,dy=_19[i-1].y;
+return "C"+(_1a.x-(_18-1)*(dx/_18))+","+dy+" "+(_1a.x-(dx/_18))+","+_1a.y+" "+_1a.x+","+_1a.y;
+}else{
+if(_18=="X"||_18=="x"||_18=="S"){
+var p0,p1=_19[i-1],p2=_19[i],p3;
+var _1b,_1c,_1d,_1e;
+var f=1/6;
+if(i==1){
+if(_18=="x"){
+p0=_19[_19.length-2];
+}else{
+p0=p1;
+}
+f=1/3;
+}else{
+p0=_19[i-2];
+}
+if(i==(_19.length-1)){
+if(_18=="x"){
+p3=_19[1];
+}else{
+p3=p2;
+}
+f=1/3;
+}else{
+p3=_19[i+1];
+}
+var _1f=Math.sqrt((p2.x-p1.x)*(p2.x-p1.x)+(p2.y-p1.y)*(p2.y-p1.y));
+var _20=Math.sqrt((p2.x-p0.x)*(p2.x-p0.x)+(p2.y-p0.y)*(p2.y-p0.y));
+var _21=Math.sqrt((p3.x-p1.x)*(p3.x-p1.x)+(p3.y-p1.y)*(p3.y-p1.y));
+var _22=_20*f;
+var _23=_21*f;
+if(_22>_1f/2&&_23>_1f/2){
+_22=_1f/2;
+_23=_1f/2;
+}else{
+if(_22>_1f/2){
+_22=_1f/2;
+_23=_1f/2*_21/_20;
+}else{
+if(_23>_1f/2){
+_23=_1f/2;
+_22=_1f/2*_20/_21;
+}
+}
+}
+if(_18=="S"){
+if(p0==p1){
+_22=0;
+}
+if(p2==p3){
+_23=0;
+}
+}
+_1b=p1.x+_22*(p2.x-p0.x)/_20;
+_1c=p1.y+_22*(p2.y-p0.y)/_20;
+_1d=p2.x-_23*(p3.x-p1.x)/_21;
+_1e=p2.y-_23*(p3.y-p1.y)/_21;
+}
+}
+return "C"+(_1b+","+_1c+" "+_1d+","+_1e+" "+p2.x+","+p2.y);
+});
+return p.join(" ");
+},getLabel:function(_24,_25,_26){
+return sc.doIfLoaded("dojo/number",function(_27){
+return (_25?_27.format(_24,{places:_26}):_27.format(_24))||"";
+},function(){
+return _25?_24.toFixed(_26):_24.toString();
+});
+}});
+});

package/vendor/dojo-1.10.10/dojox/charting/plot2d/common.js.uncompressed.js

@@ -0,0 +1,214 @@
+define("dojox/charting/plot2d/common", ["dojo/_base/lang", "dojo/_base/array", "dojo/_base/Color", 
+		"dojox/gfx", "dojox/lang/functional", "../scaler/common"], 
+	function(lang, arr, Color, g, df, sc){
+	
+	var common = lang.getObject("dojox.charting.plot2d.common", true);
+	
+	return lang.mixin(common, {	
+		doIfLoaded: sc.doIfLoaded,
+		makeStroke: function(stroke){
+			if(!stroke){ return stroke; }
+			if(typeof stroke == "string" || stroke instanceof Color){
+				stroke = {color: stroke};
+			}
+			return g.makeParameters(g.defaultStroke, stroke);
+		},
+		augmentColor: function(target, color){
+			var t = new Color(target),
+				c = new Color(color);
+			c.a = t.a;
+			return c;
+		},
+		augmentStroke: function(stroke, color){
+			var s = common.makeStroke(stroke);
+			if(s){
+				s.color = common.augmentColor(s.color, color);
+			}
+			return s;
+		},
+		augmentFill: function(fill, color){
+			var fc, c = new Color(color);
+			if(typeof fill == "string" || fill instanceof Color){
+				return common.augmentColor(fill, color);
+			}
+			return fill;
+		},
+
+		defaultStats: {
+			vmin: Number.POSITIVE_INFINITY, vmax: Number.NEGATIVE_INFINITY,
+			hmin: Number.POSITIVE_INFINITY, hmax: Number.NEGATIVE_INFINITY
+		},
+
+		collectSimpleStats: function(series){
+			var stats = lang.delegate(common.defaultStats);
+			for(var i = 0; i < series.length; ++i){
+				var run = series[i];
+				for(var j = 0; j < run.data.length; j++){
+					if(run.data[j] !== null){
+						if(typeof run.data[j] == "number"){
+							// 1D case
+							var old_vmin = stats.vmin, old_vmax = stats.vmax;
+							arr.forEach(run.data, function(val, i){
+								if(val !== null){
+									var x = i + 1, y = val;
+									if(isNaN(y)){ y = 0; }
+									stats.hmin = Math.min(stats.hmin, x);
+									stats.hmax = Math.max(stats.hmax, x);
+									stats.vmin = Math.min(stats.vmin, y);
+									stats.vmax = Math.max(stats.vmax, y);
+								}
+							});
+							if("ymin" in run){ stats.vmin = Math.min(old_vmin, run.ymin); }
+							if("ymax" in run){ stats.vmax = Math.max(old_vmax, run.ymax); }
+						}else{
+							// 2D case
+							var old_hmin = stats.hmin, old_hmax = stats.hmax,
+								old_vmin = stats.vmin, old_vmax = stats.vmax;
+							if(!("xmin" in run) || !("xmax" in run) || !("ymin" in run) || !("ymax" in run)){
+								arr.forEach(run.data, function(val, i){
+									if(val !== null){
+										var x = "x" in val ? val.x : i + 1, y = val.y;
+										if(isNaN(x)){ x = 0; }
+										if(isNaN(y)){ y = 0; }
+										stats.hmin = Math.min(stats.hmin, x);
+										stats.hmax = Math.max(stats.hmax, x);
+										stats.vmin = Math.min(stats.vmin, y);
+										stats.vmax = Math.max(stats.vmax, y);
+									}
+								});
+							}
+							if("xmin" in run){ stats.hmin = Math.min(old_hmin, run.xmin); }
+							if("xmax" in run){ stats.hmax = Math.max(old_hmax, run.xmax); }
+							if("ymin" in run){ stats.vmin = Math.min(old_vmin, run.ymin); }
+							if("ymax" in run){ stats.vmax = Math.max(old_vmax, run.ymax); }
+						}
+
+						break;
+					}
+				}
+			}
+			return stats;
+		},
+
+		calculateBarSize: function(/* Number */ availableSize, /* Object */ opt, /* Number? */ clusterSize){
+			if(!clusterSize){
+				clusterSize = 1;
+			}
+			var gap = opt.gap, size = (availableSize - 2 * gap) / clusterSize;
+			if("minBarSize" in opt){
+				size = Math.max(size, opt.minBarSize);
+			}
+			if("maxBarSize" in opt){
+				size = Math.min(size, opt.maxBarSize);
+			}
+			size = Math.max(size, 1);
+			gap = (availableSize - size * clusterSize) / 2;
+			return {size: size, gap: gap};	// Object
+		},
+
+		collectStackedStats: function(series){
+			// collect statistics
+			var stats = lang.clone(common.defaultStats);
+			if(series.length){
+				// 1st pass: find the maximal length of runs
+				stats.hmin = Math.min(stats.hmin, 1);
+				stats.hmax = df.foldl(series, "seed, run -> Math.max(seed, run.data.length)", stats.hmax);
+				// 2nd pass: stack values
+				for(var i = 0; i < stats.hmax; ++i){
+					var v = series[0].data[i];
+					v = v && (typeof v == "number" ? v : v.y);
+					if(isNaN(v)){ v = 0; }
+					stats.vmin = Math.min(stats.vmin, v);
+					for(var j = 1; j < series.length; ++j){
+						var t = series[j].data[i];
+						t = t && (typeof t == "number" ? t : t.y);
+						if(isNaN(t)){ t = 0; }
+						v += t;
+					}
+					stats.vmax = Math.max(stats.vmax, v);
+				}
+			}
+			return stats;
+		},
+
+		curve: function(/* Number[] */a, /* Number|String */tension){
+			//	FIX for #7235, submitted by Enzo Michelangeli.
+			//	Emulates the smoothing algorithms used in a famous, unnamed spreadsheet
+			//		program ;)
+			var array = a.slice(0);
+			if(tension == "x") {
+				array[array.length] = array[0];   // add a last element equal to the first, closing the loop
+			}
+			var p=arr.map(array, function(item, i){
+				if(i==0){ return "M" + item.x + "," + item.y; }
+				if(!isNaN(tension)) { // use standard Dojo smoothing in tension is numeric
+					var dx=item.x-array[i-1].x, dy=array[i-1].y;
+					return "C"+(item.x-(tension-1)*(dx/tension))+","+dy+" "+(item.x-(dx/tension))+","+item.y+" "+item.x+","+item.y;
+				} else if(tension == "X" || tension == "x" || tension == "S") {
+					// use Excel "line smoothing" algorithm (http://xlrotor.com/resources/files.shtml)
+					var p0, p1 = array[i-1], p2 = array[i], p3;
+					var bz1x, bz1y, bz2x, bz2y;
+					var f = 1/6;
+					if(i==1) {
+						if(tension == "x") {
+							p0 = array[array.length-2];
+						} else { // "tension == X || tension == "S"
+							p0 = p1;
+						}
+						f = 1/3;
+					} else {
+						p0 = array[i-2];
+					}
+					if(i==(array.length-1)) {
+						if(tension == "x") {
+							p3 = array[1];
+						} else { // "tension == X || tension == "S"
+							p3 = p2;
+						}
+						f = 1/3;
+					} else {
+						p3 = array[i+1];
+					}
+					var p1p2 = Math.sqrt((p2.x-p1.x)*(p2.x-p1.x)+(p2.y-p1.y)*(p2.y-p1.y));
+					var p0p2 = Math.sqrt((p2.x-p0.x)*(p2.x-p0.x)+(p2.y-p0.y)*(p2.y-p0.y));
+					var p1p3 = Math.sqrt((p3.x-p1.x)*(p3.x-p1.x)+(p3.y-p1.y)*(p3.y-p1.y));
+
+					var p0p2f = p0p2 * f;
+					var p1p3f = p1p3 * f;
+
+					if(p0p2f > p1p2/2 && p1p3f > p1p2/2) {
+						p0p2f = p1p2/2;
+						p1p3f = p1p2/2;
+					} else if(p0p2f > p1p2/2) {
+						p0p2f = p1p2/2;
+						p1p3f = p1p2/2 * p1p3/p0p2;
+					} else if(p1p3f > p1p2/2) {
+						p1p3f = p1p2/2;
+						p0p2f = p1p2/2 * p0p2/p1p3;
+					}
+
+					if(tension == "S") {
+						if(p0 == p1) { p0p2f = 0; }
+						if(p2 == p3) { p1p3f = 0; }
+					}
+
+					bz1x = p1.x + p0p2f*(p2.x - p0.x)/p0p2;
+					bz1y = p1.y + p0p2f*(p2.y - p0.y)/p0p2;
+					bz2x = p2.x - p1p3f*(p3.x - p1.x)/p1p3;
+					bz2y = p2.y - p1p3f*(p3.y - p1.y)/p1p3;
+				}
+				return "C"+(bz1x+","+bz1y+" "+bz2x+","+bz2y+" "+p2.x+","+p2.y);
+			});
+			return p.join(" ");
+		},
+		
+		getLabel: function(/*Number*/number, /*Boolean*/fixed, /*Number*/precision){
+			return sc.doIfLoaded("dojo/number", function(numberLib){
+				return (fixed ? numberLib.format(number, {places : precision}) :
+					numberLib.format(number)) || "";
+			}, function(){
+				return fixed ? number.toFixed(precision) : number.toString();
+			});
+		}
+	});
+});