@datagrok/helm 2.3.2 → 2.3.4

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

@@ -0,0 +1,168 @@
+//>>built
+define("dojox/charting/plot2d/Bars",["dojo/_base/lang","dojo/_base/array","dojo/_base/declare","dojo/has","./CartesianBase","./_PlotEvents","./common","dojox/gfx/fx","dojox/lang/utils","dojox/lang/functional","dojox/lang/functional/reversed"],function(_1,_2,_3,_4,_5,_6,dc,fx,du,df,_7){
+var _8=_7.lambda("item.purgeGroup()");
+return _3("dojox.charting.plot2d.Bars",[_5,_6],{defaultParams:{gap:0,animate:null,enableCache:false},optionalParams:{minBarSize:1,maxBarSize:1,stroke:{},outline:{},shadow:{},fill:{},filter:{},styleFunc:null,font:"",fontColor:""},constructor:function(_9,_a){
+this.opt=_1.clone(_1.mixin(this.opt,this.defaultParams));
+du.updateWithObject(this.opt,_a);
+du.updateWithPattern(this.opt,_a,this.optionalParams);
+this.animate=this.opt.animate;
+this.renderingOptions={"shape-rendering":"crispEdges"};
+},getSeriesStats:function(){
+var _b=dc.collectSimpleStats(this.series),t;
+_b.hmin-=0.5;
+_b.hmax+=0.5;
+t=_b.hmin,_b.hmin=_b.vmin,_b.vmin=t;
+t=_b.hmax,_b.hmax=_b.vmax,_b.vmax=t;
+return _b;
+},createRect:function(_c,_d,_e){
+var _f;
+if(this.opt.enableCache&&_c._rectFreePool.length>0){
+_f=_c._rectFreePool.pop();
+_f.setShape(_e);
+_d.add(_f);
+}else{
+_f=_d.createRect(_e);
+}
+if(this.opt.enableCache){
+_c._rectUsePool.push(_f);
+}
+return _f;
+},createLabel:function(_10,_11,_12,_13){
+if(this.opt.labels&&this.opt.labelStyle=="outside"){
+var y=_12.y+_12.height/2;
+var x=_12.x+_12.width+this.opt.labelOffset;
+this.renderLabel(_10,x,y,this._getLabel(isNaN(_11.y)?_11:_11.y),_13,"start");
+}else{
+this.inherited(arguments);
+}
+},render:function(dim,_14){
+if(this.zoom&&!this.isDataDirty()){
+return this.performZoom(dim,_14);
+}
+this.dirty=this.isDirty();
+this.resetEvents();
+var s;
+if(this.dirty){
+_2.forEach(this.series,_8);
+this._eventSeries={};
+this.cleanGroup();
+s=this.getGroup();
+df.forEachRev(this.series,function(_15){
+_15.cleanGroup(s);
+});
+}
+var t=this.chart.theme,ht=this._hScaler.scaler.getTransformerFromModel(this._hScaler),vt=this._vScaler.scaler.getTransformerFromModel(this._vScaler),_16=Math.max(0,this._hScaler.bounds.lower),_17=ht(_16),_18=this.events();
+var bar=this.getBarProperties();
+var _19=this.series.length;
+_2.forEach(this.series,function(_1a){
+if(_1a.hidden){
+_19--;
+}
+});
+var z=_19;
+for(var i=this.series.length-1;i>=0;--i){
+var run=this.series[i];
+if(!this.dirty&&!run.dirty){
+t.skip();
+this._reconnectEvents(run.name);
+continue;
+}
+run.cleanGroup();
+if(this.opt.enableCache){
+run._rectFreePool=(run._rectFreePool?run._rectFreePool:[]).concat(run._rectUsePool?run._rectUsePool:[]);
+run._rectUsePool=[];
+}
+var _1b=t.next("bar",[this.opt,run]);
+if(run.hidden){
+run.dyn.fill=_1b.series.fill;
+run.dyn.stroke=_1b.series.stroke;
+continue;
+}
+z--;
+var _1c=new Array(run.data.length);
+s=run.group;
+var _1d=_2.some(run.data,function(_1e){
+return typeof _1e=="number"||(_1e&&!_1e.hasOwnProperty("x"));
+});
+var min=_1d?Math.max(0,Math.floor(this._vScaler.bounds.from-1)):0;
+var max=_1d?Math.min(run.data.length,Math.ceil(this._vScaler.bounds.to)):run.data.length;
+for(var j=min;j<max;++j){
+var _1f=run.data[j];
+if(_1f!=null){
+var val=this.getValue(_1f,j,i,_1d),hv=ht(val.y),w=Math.abs(hv-_17),_20,_21;
+if(this.opt.styleFunc||typeof _1f!="number"){
+var _22=typeof _1f!="number"?[_1f]:[];
+if(this.opt.styleFunc){
+_22.push(this.opt.styleFunc(_1f));
+}
+_20=t.addMixin(_1b,"bar",_22,true);
+}else{
+_20=t.post(_1b,"bar");
+}
+if(w>=0&&bar.height>=1){
+var _23={x:_14.l+(val.y<_16?hv:_17),y:dim.height-_14.b-vt(val.x+1.5)+bar.gap+bar.thickness*(_19-z-1),width:w,height:bar.height};
+if(_20.series.shadow){
+var _24=_1.clone(_23);
+_24.x+=_20.series.shadow.dx;
+_24.y+=_20.series.shadow.dy;
+_21=this.createRect(run,s,_24).setFill(_20.series.shadow.color).setStroke(_20.series.shadow);
+if(this.animate){
+this._animateBar(_21,_14.l+_17,-w);
+}
+}
+var _25=this._plotFill(_20.series.fill,dim,_14);
+_25=this._shapeFill(_25,_23);
+var _26=this.createRect(run,s,_23).setFill(_25).setStroke(_20.series.stroke);
+if(_26.setFilter&&_20.series.filter){
+_26.setFilter(_20.series.filter);
+}
+run.dyn.fill=_26.getFill();
+run.dyn.stroke=_26.getStroke();
+if(_18){
+var o={element:"bar",index:j,run:run,shape:_26,shadow:_21,cx:val.y,cy:val.x+1.5,x:_1d?j:run.data[j].x,y:_1d?run.data[j]:run.data[j].y};
+this._connectEvents(o);
+_1c[j]=o;
+}
+if(!isNaN(val.py)&&val.py>_16){
+_23.x+=ht(val.py);
+_23.width-=ht(val.py);
+}
+this.createLabel(s,_1f,_23,_20);
+if(this.animate){
+this._animateBar(_26,_14.l+_17,-w);
+}
+}
+}
+}
+this._eventSeries[run.name]=_1c;
+run.dirty=false;
+}
+this.dirty=false;
+if(_4("dojo-bidi")){
+this._checkOrientation(this.group,dim,_14);
+}
+return this;
+},getValue:function(_27,j,_28,_29){
+var y,x;
+if(_29){
+if(typeof _27=="number"){
+y=_27;
+}else{
+y=_27.y;
+}
+x=j;
+}else{
+y=_27.y;
+x=_27.x-1;
+}
+return {y:y,x:x};
+},getBarProperties:function(){
+var f=dc.calculateBarSize(this._vScaler.bounds.scale,this.opt);
+return {gap:f.gap,height:f.size,thickness:0};
+},_animateBar:function(_2a,_2b,_2c){
+if(_2c==0){
+_2c=1;
+}
+fx.animateTransform(_1.delegate({shape:_2a,duration:1200,transform:[{name:"translate",start:[_2b-(_2b/_2c),0],end:[0,0]},{name:"scale",start:[1/_2c,1],end:[1,1]},{name:"original"}]},this.animate)).play();
+}});
+});

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

@@ -0,0 +1,311 @@
+define("dojox/charting/plot2d/Bars", ["dojo/_base/lang", "dojo/_base/array", "dojo/_base/declare", "dojo/has", "./CartesianBase", "./_PlotEvents", "./common",
+	"dojox/gfx/fx", "dojox/lang/utils", "dojox/lang/functional", "dojox/lang/functional/reversed"], 
+	function(lang, arr, declare, has, CartesianBase, _PlotEvents, dc, fx, du, df, dfr){
+		
+	/*=====
+	declare("dojox.charting.plot2d.__BarCtorArgs", dojox.charting.plot2d.__DefaultCtorArgs, {
+		// summary:
+		//		Additional keyword arguments for bar charts.
+	
+		// minBarSize: Number?
+		//		The minimum size for a bar in pixels.  Default is 1.
+		minBarSize: 1,
+	
+		// maxBarSize: Number?
+		//		The maximum size for a bar in pixels.  Default is 1.
+		maxBarSize: 1,
+
+		// stroke: dojox.gfx.Stroke?
+		//		An optional stroke to use for any series on the plot.
+		stroke:		{},
+
+		// outline: dojox.gfx.Stroke?
+		//		An optional stroke used to outline any series on the plot.
+		outline:	{},
+
+		// shadow: dojox.gfx.Stroke?
+		//		An optional stroke to use to draw any shadows for a series on a plot.
+		shadow:		{},
+
+		// fill: dojox.gfx.Fill?
+		//		Any fill to be used for elements on the plot.
+		fill:		{},
+
+		// filter: dojox.gfx.Filter?
+	 	//		An SVG filter to be used for elements on the plot. gfx SVG renderer must be used and dojox/gfx/svgext must
+	 	//		be required for this to work.
+	 	filter:		{},
+
+		// styleFunc: Function?
+		//		A function that returns a styling object for the a given data item.
+		styleFunc:	null,
+
+		// font: String?
+		//		A font definition to be used for labels and other text-based elements on the plot.
+		font:		"",
+
+		// fontColor: String|dojo.Color?
+		//		The color to be used for any text-based elements on the plot.
+		fontColor:	"",
+		
+		// enableCache: Boolean?
+		//		Whether the bars rect are cached from one rendering to another. This improves the rendering performance of
+		//		successive rendering but penalize the first rendering.  Default false.
+		enableCache: false
+	});
+	=====*/
+	var purgeGroup = dfr.lambda("item.purgeGroup()");
+
+	return declare("dojox.charting.plot2d.Bars", [CartesianBase, _PlotEvents], {
+		// summary:
+		//		The plot object representing a bar chart (horizontal bars).
+		defaultParams: {
+			gap:	0,		// gap between columns in pixels
+			animate: null,   // animate bars into place
+			enableCache: false
+		},
+		optionalParams: {
+			minBarSize:	1,	// minimal bar width in pixels
+			maxBarSize:	1,	// maximal bar width in pixels
+			// theme component
+			stroke:		{},
+			outline:	{},
+			shadow:		{},
+			fill:		{},
+			filter:	    {},
+			styleFunc:  null,
+			font:		"",
+			fontColor:	""
+		},
+
+		constructor: function(chart, kwArgs){
+			// summary:
+			//		The constructor for a bar chart.
+			// chart: dojox/charting/Chart
+			//		The chart this plot belongs to.
+			// kwArgs: dojox.charting.plot2d.__BarCtorArgs?
+			//		An optional keyword arguments object to help define the plot.
+			this.opt = lang.clone(lang.mixin(this.opt, this.defaultParams));
+			du.updateWithObject(this.opt, kwArgs);
+			du.updateWithPattern(this.opt, kwArgs, this.optionalParams);
+			this.animate = this.opt.animate;
+			this.renderingOptions = { "shape-rendering": "crispEdges" };
+		},
+
+		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 = dc.collectSimpleStats(this.series), t;
+			stats.hmin -= 0.5;
+			stats.hmax += 0.5;
+			t = stats.hmin, stats.hmin = stats.vmin, stats.vmin = t;
+			t = stats.hmax, stats.hmax = stats.vmax, stats.vmax = t;
+			return stats; // Object
+		},
+		
+		createRect: function(run, creator, params){
+			var rect;
+			if(this.opt.enableCache && run._rectFreePool.length > 0){
+				rect = run._rectFreePool.pop();
+				rect.setShape(params);
+				// was cleared, add it back
+				creator.add(rect);
+			}else{
+				rect = creator.createRect(params);
+			}
+			if(this.opt.enableCache){
+				run._rectUsePool.push(rect);
+			}
+			return rect;
+		},
+
+		createLabel: function(group, value, bbox, theme){
+			if(this.opt.labels && this.opt.labelStyle == "outside"){
+				var y = bbox.y + bbox.height / 2;
+				var x = bbox.x + bbox.width + this.opt.labelOffset;
+				this.renderLabel(group, x, y, this._getLabel(isNaN(value.y)?value:value.y), theme, "start");
+          	}else{
+				this.inherited(arguments);
+			}
+		},
+
+		render: function(dim, offsets){
+			// summary:
+			//		Run the calculations for any axes for this plot.
+			// dim: Object
+			//		An object in the form of { width, height }
+			// offsets: Object
+			//		An object of the form { l, r, t, b}.
+			// returns: dojox/charting/plot2d/Bars
+			//		A reference to this plot for functional chaining.
+			if(this.zoom && !this.isDataDirty()){
+				return this.performZoom(dim, offsets); // dojox/charting/plot2d/Bars
+			}
+			this.dirty = this.isDirty();
+			this.resetEvents();
+			var s;
+			if(this.dirty){
+				arr.forEach(this.series, purgeGroup);
+				this._eventSeries = {};
+				this.cleanGroup();
+				s = this.getGroup();
+				df.forEachRev(this.series, function(item){ item.cleanGroup(s); });
+			}
+			var t = this.chart.theme,
+				ht = this._hScaler.scaler.getTransformerFromModel(this._hScaler),
+				vt = this._vScaler.scaler.getTransformerFromModel(this._vScaler),
+				baseline = Math.max(0, this._hScaler.bounds.lower),
+				baselineWidth = ht(baseline),
+				events = this.events();
+			var bar = this.getBarProperties();
+
+			var actualLength = this.series.length;
+			arr.forEach(this.series, function(serie){if(serie.hidden){actualLength--;}});
+			var z = actualLength;
+			for(var i = this.series.length - 1; i >= 0; --i){
+				var run = this.series[i];
+				if(!this.dirty && !run.dirty){
+					t.skip();
+					this._reconnectEvents(run.name);
+					continue;
+				}
+				run.cleanGroup();
+				if(this.opt.enableCache){
+					run._rectFreePool = (run._rectFreePool?run._rectFreePool:[]).concat(run._rectUsePool?run._rectUsePool:[]);
+					run._rectUsePool = [];
+				}
+				var theme = t.next("bar", [this.opt, run]);
+				if(run.hidden){
+					run.dyn.fill = theme.series.fill;
+					run.dyn.stroke = theme.series.stroke;
+					continue;
+				}
+				z--;
+
+				var	eventSeries = new Array(run.data.length);
+				s = run.group;	
+				var indexed = arr.some(run.data, function(item){
+					return typeof item == "number" || (item && !item.hasOwnProperty("x"));
+				});
+				// on indexed charts we can easily just interate from the first visible to the last visible
+				// data point to save time
+				var min = indexed?Math.max(0, Math.floor(this._vScaler.bounds.from - 1)):0;
+				var max = indexed?Math.min(run.data.length, Math.ceil(this._vScaler.bounds.to)):run.data.length;
+				for(var j = min; j < max; ++j){
+					var value = run.data[j];
+					if(value != null){
+						var val = this.getValue(value, j, i, indexed),
+							hv = ht(val.y),
+							w = Math.abs(hv - baselineWidth),
+							finalTheme,
+							sshape;
+						if(this.opt.styleFunc || typeof value != "number"){
+							var tMixin = typeof value != "number" ? [value] : [];
+							if(this.opt.styleFunc){
+								tMixin.push(this.opt.styleFunc(value));
+							}
+							finalTheme = t.addMixin(theme, "bar", tMixin, true);
+						}else{
+							finalTheme = t.post(theme, "bar");
+						}
+						if(w >= 0 && bar.height >= 1){
+							var rect = {
+								x: offsets.l + (val.y < baseline ? hv : baselineWidth),
+								y: dim.height - offsets.b - vt(val.x + 1.5) + bar.gap + bar.thickness * (actualLength - z - 1),
+								// y: dim.height - offsets.b - vt(val.x + 1.5) + bar.gap + bar.thickness * z,
+								width: w,
+								height: bar.height
+							};
+							if(finalTheme.series.shadow){
+								var srect = lang.clone(rect);
+								srect.x += finalTheme.series.shadow.dx;
+								srect.y += finalTheme.series.shadow.dy;
+								sshape = this.createRect(run, s, srect).setFill(finalTheme.series.shadow.color).setStroke(finalTheme.series.shadow);
+								if(this.animate){
+									this._animateBar(sshape, offsets.l + baselineWidth, -w);
+								}
+							}
+							var specialFill = this._plotFill(finalTheme.series.fill, dim, offsets);
+							specialFill = this._shapeFill(specialFill, rect);
+							var shape = this.createRect(run, s, rect).setFill(specialFill).setStroke(finalTheme.series.stroke);
+							if(shape.setFilter && finalTheme.series.filter){
+								shape.setFilter(finalTheme.series.filter);
+							}
+							run.dyn.fill   = shape.getFill();
+							run.dyn.stroke = shape.getStroke();
+							if(events){
+								var o = {
+									element: "bar",
+									index:   j,
+									run:     run,
+									shape:   shape,
+									shadow:	 sshape,
+									cx:      val.y,
+									cy:      val.x + 1.5,
+									x:	     indexed?j:run.data[j].x,
+									y:	 	 indexed?run.data[j]:run.data[j].y
+								};
+								this._connectEvents(o);
+								eventSeries[j] = o;
+							}
+							// if val.py is here, this means we are stacking and we need to subtract previous
+							// value to get the high in which we will lay out the label
+							if(!isNaN(val.py) && val.py > baseline){
+								rect.x += ht(val.py);
+								rect.width -= ht(val.py);
+							}
+							this.createLabel(s, value, rect, finalTheme);
+							if(this.animate){
+								this._animateBar(shape, offsets.l + baselineWidth, -w);
+							}
+						}
+					}
+				}
+				this._eventSeries[run.name] = eventSeries;
+				run.dirty = false;
+			}
+			this.dirty = false;
+			// chart mirroring starts
+			if(has("dojo-bidi")){
+				this._checkOrientation(this.group, dim, offsets);
+			}
+			// chart mirroring ends
+			return this;	//	dojox/charting/plot2d/Bars
+		},
+		getValue: function(value, j, seriesIndex, indexed){
+			var y, x;
+			if(indexed){
+				if(typeof value == "number"){
+					y = value;
+				}else{
+					y = value.y;
+				}
+				x = j;
+			}else{
+				y = value.y;
+				x = value.x -1;
+			}
+			return {y:y, x:x};
+		},	
+		getBarProperties: function(){
+			var f = dc.calculateBarSize(this._vScaler.bounds.scale, this.opt);
+			return {gap: f.gap, height: f.size, thickness: 0};
+		},
+		_animateBar: function(shape, hoffset, hsize){
+			if(hsize==0){
+				hsize = 1;
+			}
+			fx.animateTransform(lang.delegate({
+				shape: shape,
+				duration: 1200,
+				transform: [
+					{name: "translate", start: [hoffset - (hoffset/hsize), 0], end: [0, 0]},
+					{name: "scale", start: [1/hsize, 1], end: [1, 1]},
+					{name: "original"}
+				]
+			}, this.animate)).play();
+		}
+	});
+});

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

@@ -0,0 +1,61 @@
+//>>built
+define("dojox/charting/plot2d/Base",["dojo/_base/declare","dojo/_base/array","dojox/gfx","../Element","./common","../axis2d/common","dojo/has"],function(_1,_2,_3,_4,_5,ac,_6){
+var _7=_1("dojox.charting.plot2d.Base",_4,{constructor:function(_8,_9){
+if(_9&&_9.tooltipFunc){
+this.tooltipFunc=_9.tooltipFunc;
+}
+},clear:function(){
+this.series=[];
+this.dirty=true;
+return this;
+},setAxis:function(_a){
+return this;
+},assignAxes:function(_b){
+_2.forEach(this.axes,function(_c){
+if(this[_c]){
+this.setAxis(_b[this[_c]]);
+}
+},this);
+},addSeries:function(_d){
+this.series.push(_d);
+return this;
+},getSeriesStats:function(){
+return _5.collectSimpleStats(this.series);
+},calculateAxes:function(_e){
+this.initializeScalers(_e,this.getSeriesStats());
+return this;
+},initializeScalers:function(){
+return this;
+},isDataDirty:function(){
+return _2.some(this.series,function(_f){
+return _f.dirty;
+});
+},render:function(dim,_10){
+return this;
+},renderLabel:function(_11,x,y,_12,_13,_14,_15){
+var _16=ac.createText[this.opt.htmlLabels&&_3.renderer!="vml"?"html":"gfx"](this.chart,_11,x,y,_15?_15:"middle",_12,_13.series.font,_13.series.fontColor);
+if(_14){
+if(this.opt.htmlLabels&&_3.renderer!="vml"){
+_16.style.pointerEvents="none";
+}else{
+if(_16.rawNode){
+_16.rawNode.style.pointerEvents="none";
+}
+}
+}
+if(this.opt.htmlLabels&&_3.renderer!="vml"){
+this.htmlElements.push(_16);
+}
+return _16;
+},getRequiredColors:function(){
+return this.series.length;
+},_getLabel:function(_17){
+return _5.getLabel(_17,this.opt.fixed,this.opt.precision);
+}});
+if(_6("dojo-bidi")){
+_7.extend({_checkOrientation:function(_18,dim,_19){
+this.chart.applyMirroring(this.group,dim,_19);
+}});
+}
+return _7;
+});

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

@@ -0,0 +1,161 @@
+define("dojox/charting/plot2d/Base", ["dojo/_base/declare", "dojo/_base/array", "dojox/gfx",
+		"../Element", "./common", "../axis2d/common", "dojo/has"],
+	function(declare, arr, gfx, Element, common, ac, has){
+/*=====
+dojox.charting.plot2d.__PlotCtorArgs = {
+	// summary:
+	//		The base keyword arguments object for plot constructors.
+	//		Note that the parameters for this may change based on the
+	//		specific plot type (see the corresponding plot type for
+	//		details).
+
+	// tooltipFunc: Function?
+	//		An optional function used to compute tooltip text for this plot. It takes precedence over
+	//		the default function when available.
+	//	|		function tooltipFunc(o) { return "text"; }
+	//		`o`is the event object that triggered the tooltip.
+	tooltipFunc: null
+};
+=====*/
+	var Base = declare("dojox.charting.plot2d.Base", Element, {
+		// summary:
+		//		Base class for all plot types.
+		constructor: function(chart, kwArgs){
+			// summary:
+			//		Create a base plot for charting.
+			// chart: dojox/chart/Chart
+			//		The chart this plot belongs to.
+			// kwArgs: dojox.charting.plot2d.__PlotCtorArgs?
+			//		An optional arguments object to help define the plot.
+	
+			// TODO does not work in markup
+			if(kwArgs && kwArgs.tooltipFunc){
+				this.tooltipFunc = kwArgs.tooltipFunc;
+			}
+		},
+		clear: function(){
+			// summary:
+			//		Clear out all of the information tied to this plot.
+			// returns: dojox.charting.plot2d.Base
+			//		A reference to this plot for functional chaining.
+			this.series = [];
+			this.dirty = true;
+			return this;	//	dojox/charting/plot2d/Base
+		},
+		setAxis: function(axis){
+			// summary:
+			//		Set an axis for this plot.
+			// axis: dojox.charting.axis2d.Base
+			//		The axis to set.
+			// returns: dojox/charting/plot2d/Base
+			//		A reference to this plot for functional chaining.
+			return this;	//	dojox/charting/plot2d/Base
+		},
+		assignAxes: function(axes){
+			// summary:
+			//		From an array of axes pick the ones that correspond to this plot and
+			//		assign them to the plot using setAxis method.
+			// axes: Array
+			//		An array of dojox/charting/axis2d/Base
+			// tags:
+			//		protected
+			arr.forEach(this.axes, function(axis){
+				if(this[axis]){
+					this.setAxis(axes[this[axis]]);
+				}
+			}, this);
+		},
+		addSeries: function(run){
+			// summary:
+			//		Add a data series to this plot.
+			// run: dojox.charting.Series
+			//		The series to be added.
+			// returns: dojox/charting/plot2d/Base
+			//		A reference to this plot for functional chaining.
+			this.series.push(run);
+			return this;	//	dojox/charting/plot2d/Base
+		},
+		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.
+			return common.collectSimpleStats(this.series);
+		},
+		calculateAxes: function(dim){
+			// summary:
+			//		Stub function for running the axis calculations (deprecated).
+			// dim: Object
+			//		An object of the form { width, height }
+			// returns: dojox/charting/plot2d/Base
+			//		A reference to this plot for functional chaining.
+			this.initializeScalers(dim, this.getSeriesStats());
+			return this;	//	dojox/charting/plot2d/Base
+		},
+		initializeScalers: function(){
+			// summary:
+			//		Does nothing.
+			return this;
+		},
+		isDataDirty: function(){
+			// summary:
+			//		Returns whether or not any of this plot's data series need to be rendered.
+			// returns: Boolean
+			//		Flag indicating if any of this plot's series are invalid and need rendering.
+			return arr.some(this.series, function(item){ return item.dirty; });	//	Boolean
+		},
+		render: function(dim, offsets){
+			// summary:
+			//		Render the plot on the chart.
+			// dim: Object
+			//		An object of the form { width, height }.
+			// offsets: Object
+			//		An object of the form { l, r, t, b }.
+			// returns: dojox/charting/plot2d/Base
+			//		A reference to this plot for functional chaining.
+			return this;	//	dojox/charting/plot2d/Base
+		},
+		renderLabel: function(group, x, y, label, theme, block, align){
+			var elem = ac.createText[this.opt.htmlLabels && gfx.renderer != "vml" ? "html" : "gfx"]
+				(this.chart, group, x, y, align?align:"middle", label, theme.series.font, theme.series.fontColor);
+			// if the label is inside we need to avoid catching events on it this would prevent action on
+			// chart elements
+			if(block){
+				// TODO this won't work in IE neither in VML nor in HTML
+				// a solution would be to catch the event on the label and refire it to the element
+				// possibly using elementFromPoint or having it already available
+				if(this.opt.htmlLabels && gfx.renderer != "vml"){
+					// we have HTML labels, let's use pointEvents on the HTML node
+					elem.style.pointerEvents = "none";
+				}else if(elem.rawNode){
+					// we have SVG labels, let's use pointerEvents on the SVG or VML node
+					elem.rawNode.style.pointerEvents = "none";
+				}
+				// else we have Canvas, we need do nothing, as Canvas text won't catch events
+			}
+			if(this.opt.htmlLabels && gfx.renderer != "vml"){
+				this.htmlElements.push(elem);
+			}
+
+			return elem;
+		},
+		getRequiredColors: function(){
+			// summary:
+			//		Get how many data series we have, so we know how many colors to use.
+			// returns: Number
+			//		The number of colors needed.
+			return this.series.length;	//	Number
+		},
+		_getLabel: function(number){
+			return common.getLabel(number, this.opt.fixed, this.opt.precision);
+		}
+	});
+	if(has("dojo-bidi")){
+		Base.extend({
+			_checkOrientation: function(group, dim, offsets){
+				this.chart.applyMirroring(this.group, dim, offsets);
+			}		
+		});
+	}
+	return Base;
+});