@datagrok/helm 2.3.2 → 2.3.4

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

@@ -0,0 +1,243 @@
+define("dojox/charting/plot2d/Candlesticks", ["dojo/_base/lang", "dojo/_base/declare", "dojo/_base/array", "dojo/has", "./CartesianBase", "./_PlotEvents", "./common",
+		"dojox/lang/functional", "dojox/lang/functional/reversed", "dojox/lang/utils", "dojox/gfx/fx"], 
+	function(lang, declare, arr, has, CartesianBase, _PlotEvents, dc, df, dfr, du, fx){
+
+	var purgeGroup = dfr.lambda("item.purgeGroup()");
+
+	//	Candlesticks are based on the Bars plot type; we expect the following passed
+	//	as values in a series:
+	//	{ x?, open, close, high, low, mid? }
+	//	if x is not provided, the array index is used.
+	//	failing to provide the OHLC values will throw an error.
+	return declare("dojox.charting.plot2d.Candlesticks", [CartesianBase, _PlotEvents], {
+		// summary:
+		//		A plot that represents typical candlesticks (financial reporting, primarily).
+		//		Unlike most charts, the Candlestick expects data points to be represented by
+		//		an object of the form { x?, open, close, high, low, mid? }, where both
+		//		x and mid are optional parameters.  If x is not provided, the index of the
+		//		data array is used.
+		defaultParams: {
+			gap:	2,		// gap between columns in pixels
+			animate: null   // animate bars into place
+		},
+		optionalParams: {
+			minBarSize:	1,	// minimal candle width in pixels
+			maxBarSize:	1,	// maximal candle width in pixels
+			// theme component
+			stroke:		{},
+			outline:	{},
+			shadow:		{},
+			fill:		{},
+			font:		"",
+			fontColor:	""
+		},
+
+		constructor: function(chart, kwArgs){
+			// summary:
+			//		The constructor for a candlestick 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(this.defaultParams);
+			du.updateWithObject(this.opt, kwArgs);
+			du.updateWithPattern(this.opt, kwArgs, this.optionalParams);
+			this.animate = this.opt.animate;
+		},
+
+		collectStats: function(series){
+			// summary:
+			//		Collect all statistics for drawing this chart.  Since the common
+			//		functionality only assumes x and y, Candlesticks must create it's own
+			//		stats (since data has no y value, but open/close/high/low instead).
+			// series: dojox.charting.Series[]
+			//		The data series array to be drawn on this plot.
+			// returns: Object
+			//		Returns an object in the form of { hmin, hmax, vmin, vmax }.
+
+			//	we have to roll our own, since we need to use all four passed
+			//	values to figure out our stats, and common only assumes x and y.
+			var stats = lang.delegate(dc.defaultStats);
+			for(var i=0; i<series.length; i++){
+				var run = series[i];
+				if(!run.data.length){ continue; }
+				var old_vmin = stats.vmin, old_vmax = stats.vmax;
+				if(!("ymin" in run) || !("ymax" in run)){
+					arr.forEach(run.data, function(val, idx){
+						if(val !== null){
+							var x = val.x || idx + 1;
+							stats.hmin = Math.min(stats.hmin, x);
+							stats.hmax = Math.max(stats.hmax, x);
+							stats.vmin = Math.min(stats.vmin, val.open, val.close, val.high, val.low);
+							stats.vmax = Math.max(stats.vmax, val.open, val.close, val.high, val.low);
+						}
+					});
+				}
+				if("ymin" in run){ stats.vmin = Math.min(old_vmin, run.ymin); }
+				if("ymax" in run){ stats.vmax = Math.max(old_vmax, run.ymax); }
+			}
+			return stats;	//	Object
+		},
+
+		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 = this.collectStats(this.series);
+			stats.hmin -= 0.5;
+			stats.hmax += 0.5;
+			return stats; // Object
+		},
+
+		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/Candlesticks
+			//		A reference to this plot for functional chaining.
+			if(this.zoom && !this.isDataDirty()){
+				return this.performZoom(dim, offsets);
+			}
+			this.resetEvents();
+			this.dirty = this.isDirty();
+			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, f, gap, width,
+				ht = this._hScaler.scaler.getTransformerFromModel(this._hScaler),
+				vt = this._vScaler.scaler.getTransformerFromModel(this._vScaler),
+				events = this.events();
+			f = dc.calculateBarSize(this._hScaler.bounds.scale, this.opt);
+			gap = f.gap;
+			width = f.size;
+			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();
+				var theme = t.next("candlestick", [this.opt, run]),
+					eventSeries = new Array(run.data.length);
+
+				if(run.hidden){
+					run.dyn.fill = theme.series.fill;
+					run.dyn.stroke =  theme.series.stroke;
+					continue;
+				}
+				s = run.group;
+                
+				for(var j = 0; j < run.data.length; ++j){
+					var v = run.data[j];
+					if(v !== null){
+						var finalTheme = t.addMixin(theme, "candlestick", v, true);
+
+						//	calculate the points we need for OHLC
+						var x = ht(v.x || (j+0.5)) + offsets.l + gap,
+							y = dim.height - offsets.b,
+							open = vt(v.open),
+							close = vt(v.close),
+							high = vt(v.high),
+							low = vt(v.low);
+						if("mid" in v){
+							var mid = vt(v.mid);
+						}
+						if(low > high){
+							var tmp = high;
+							high = low;
+							low = tmp;
+						}
+
+						if(width >= 1){
+							//	draw the line and rect, set up as a group and pass that to the events.
+							var doFill = open > close;
+							var line = { x1: width/2, x2: width/2, y1: y - high, y2: y - low },
+								rect = {
+									x: 0, y: y-Math.max(open, close),
+									width: width, height: Math.max(doFill ? open-close : close-open, 1)
+								};
+							var shape = s.createGroup();
+							shape.setTransform({dx: x, dy: 0 });
+							var inner = shape.createGroup();
+							inner.createLine(line).setStroke(finalTheme.series.stroke);
+							inner.createRect(rect).setStroke(finalTheme.series.stroke).
+								setFill(doFill ? finalTheme.series.fill : "white");
+							if("mid" in v){
+								//	add the mid line.
+								inner.createLine({
+									x1: (finalTheme.series.stroke.width||1), x2: width - (finalTheme.series.stroke.width || 1),
+									y1: y - mid, y2: y - mid
+								}).setStroke(doFill ? "white" : finalTheme.series.stroke);
+							}
+
+							// TODO: double check this.
+							run.dyn.fill   = finalTheme.series.fill;
+							run.dyn.stroke = finalTheme.series.stroke;
+							if(events){
+								var o = {
+									element: "candlestick",
+									index:   j,
+									run:     run,
+									shape:   inner,
+									x:       x,
+									y:       y-Math.max(open, close),
+									cx:		 width/2,
+									cy:		 (y-Math.max(open, close)) + (Math.max(doFill ? open-close : close-open, 1)/2),
+									width:	 width,
+									height:  Math.max(doFill ? open-close : close-open, 1),
+									data:	 v
+								};
+								this._connectEvents(o);
+								eventSeries[j] = o;
+							}
+						}
+						if(this.animate){
+							this._animateCandlesticks(shape, y - low, high - low);
+						}
+					}
+				}
+				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/Candlesticks
+		},
+
+		tooltipFunc: function(o){
+			return '<table cellpadding="1" cellspacing="0" border="0" style="font-size:0.9em;">'
+						+ '<tr><td>Open:</td><td align="right"><strong>' + o.data.open + '</strong></td></tr>'
+						+ '<tr><td>High:</td><td align="right"><strong>' + o.data.high + '</strong></td></tr>'
+						+ '<tr><td>Low:</td><td align="right"><strong>' + o.data.low + '</strong></td></tr>'
+						+ '<tr><td>Close:</td><td align="right"><strong>' + o.data.close + '</strong></td></tr>'
+						+ (o.data.mid !== undefined ? '<tr><td>Mid:</td><td align="right"><strong>' + o.data.mid + '</strong></td></tr>' : '')
+						+ '</table>';
+		},
+
+		_animateCandlesticks: function(shape, voffset, vsize){
+			fx.animateTransform(lang.delegate({
+				shape: shape,
+				duration: 1200,
+				transform: [
+					{name: "translate", start: [0, voffset - (voffset/vsize)], end: [0, 0]},
+					{name: "scale", start: [1, 1/vsize], end: [1, 1]},
+					{name: "original"}
+				]
+			}, this.animate)).play();
+		}
+	});
+});

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

@@ -0,0 +1,108 @@
+//>>built
+define("dojox/charting/plot2d/CartesianBase",["dojo/_base/lang","dojo/_base/declare","dojo/_base/connect","dojo/has","./Base","../scaler/primitive","dojox/gfx","dojox/gfx/fx","dojox/lang/utils"],function(_1,_2,_3,_4,_5,_6,_7,fx,du){
+return _2("dojox.charting.plot2d.CartesianBase",_5,{baseParams:{hAxis:"x",vAxis:"y",labels:false,labelOffset:10,fixed:true,precision:1,labelStyle:"inside",htmlLabels:true,omitLabels:true,labelFunc:null},constructor:function(_8,_9){
+this.axes=["hAxis","vAxis"];
+this.zoom=null;
+this.zoomQueue=[];
+this.lastWindow={vscale:1,hscale:1,xoffset:0,yoffset:0};
+this.hAxis=(_9&&_9.hAxis)||"x";
+this.vAxis=(_9&&_9.vAxis)||"y";
+this.series=[];
+this.opt=_1.clone(this.baseParams);
+du.updateWithObject(this.opt,_9);
+},clear:function(){
+this.inherited(arguments);
+this._hAxis=null;
+this._vAxis=null;
+return this;
+},cleanGroup:function(_a,_b){
+this.inherited(arguments);
+if(!_b&&this.chart._nativeClip){
+var _c=this.chart.offsets,_d=this.chart.dim;
+var w=Math.max(0,_d.width-_c.l-_c.r),h=Math.max(0,_d.height-_c.t-_c.b);
+this.group.setClip({x:_c.l,y:_c.t,width:w,height:h});
+if(!this._clippedGroup){
+this._clippedGroup=this.group.createGroup();
+}
+}
+},purgeGroup:function(){
+this.inherited(arguments);
+this._clippedGroup=null;
+},getGroup:function(){
+return this._clippedGroup||this.group;
+},setAxis:function(_e){
+if(_e){
+this[_e.vertical?"_vAxis":"_hAxis"]=_e;
+}
+return this;
+},toPage:function(_f){
+var ah=this._hAxis,av=this._vAxis,sh=ah.getScaler(),sv=av.getScaler(),th=sh.scaler.getTransformerFromModel(sh),tv=sv.scaler.getTransformerFromModel(sv),c=this.chart.getCoords(),o=this.chart.offsets,dim=this.chart.dim;
+var t=function(_10){
+var r={};
+r.x=th(_10[ah.name])+c.x+o.l;
+r.y=c.y+dim.height-o.b-tv(_10[av.name]);
+return r;
+};
+return _f?t(_f):t;
+},toData:function(_11){
+var ah=this._hAxis,av=this._vAxis,sh=ah.getScaler(),sv=av.getScaler(),th=sh.scaler.getTransformerFromPlot(sh),tv=sv.scaler.getTransformerFromPlot(sv),c=this.chart.getCoords(),o=this.chart.offsets,dim=this.chart.dim;
+var t=function(_12){
+var r={};
+r[ah.name]=th(_12.x-c.x-o.l);
+r[av.name]=tv(c.y+dim.height-_12.y-o.b);
+return r;
+};
+return _11?t(_11):t;
+},isDirty:function(){
+return this.dirty||this._hAxis&&this._hAxis.dirty||this._vAxis&&this._vAxis.dirty;
+},createLabel:function(_13,_14,_15,_16){
+if(this.opt.labels){
+var x,y,_17=this.opt.labelFunc?this.opt.labelFunc.apply(this,[_14,this.opt.fixed,this.opt.precision]):this._getLabel(isNaN(_14.y)?_14:_14.y);
+if(this.opt.labelStyle=="inside"){
+var _18=_7._base._getTextBox(_17,{font:_16.series.font});
+x=_15.x+_15.width/2;
+y=_15.y+_15.height/2+_18.h/4;
+if(_18.w>_15.width||_18.h>_15.height){
+return;
+}
+}else{
+x=_15.x+_15.width/2;
+y=_15.y-this.opt.labelOffset;
+}
+this.renderLabel(_13,x,y,_17,_16,this.opt.labelStyle=="inside");
+}
+},performZoom:function(dim,_19){
+var vs=this._vAxis.scale||1,hs=this._hAxis.scale||1,_1a=dim.height-_19.b,_1b=this._hScaler.bounds,_1c=(_1b.from-_1b.lower)*_1b.scale,_1d=this._vScaler.bounds,_1e=(_1d.from-_1d.lower)*_1d.scale,_1f=vs/this.lastWindow.vscale,_20=hs/this.lastWindow.hscale,_21=(this.lastWindow.xoffset-_1c)/((this.lastWindow.hscale==1)?hs:this.lastWindow.hscale),_22=(_1e-this.lastWindow.yoffset)/((this.lastWindow.vscale==1)?vs:this.lastWindow.vscale),_23=this.getGroup(),_24=fx.animateTransform(_1.delegate({shape:_23,duration:1200,transform:[{name:"translate",start:[0,0],end:[_19.l*(1-_20),_1a*(1-_1f)]},{name:"scale",start:[1,1],end:[_20,_1f]},{name:"original"},{name:"translate",start:[0,0],end:[_21,_22]}]},this.zoom));
+_1.mixin(this.lastWindow,{vscale:vs,hscale:hs,xoffset:_1c,yoffset:_1e});
+this.zoomQueue.push(_24);
+_3.connect(_24,"onEnd",this,function(){
+this.zoom=null;
+this.zoomQueue.shift();
+if(this.zoomQueue.length>0){
+this.zoomQueue[0].play();
+}
+});
+if(this.zoomQueue.length==1){
+this.zoomQueue[0].play();
+}
+return this;
+},initializeScalers:function(dim,_25){
+if(this._hAxis){
+if(!this._hAxis.initialized()){
+this._hAxis.calculate(_25.hmin,_25.hmax,dim.width);
+}
+this._hScaler=this._hAxis.getScaler();
+}else{
+this._hScaler=_6.buildScaler(_25.hmin,_25.hmax,dim.width);
+}
+if(this._vAxis){
+if(!this._vAxis.initialized()){
+this._vAxis.calculate(_25.vmin,_25.vmax,dim.height);
+}
+this._vScaler=this._vAxis.getScaler();
+}else{
+this._vScaler=_6.buildScaler(_25.vmin,_25.vmax,dim.height);
+}
+return this;
+}});
+});

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

@@ -0,0 +1,290 @@
+define("dojox/charting/plot2d/CartesianBase", ["dojo/_base/lang", "dojo/_base/declare", "dojo/_base/connect", "dojo/has",
+		"./Base", "../scaler/primitive", "dojox/gfx", "dojox/gfx/fx", "dojox/lang/utils"], 
+	function(lang, declare, hub, has, Base, primitive, gfx, fx, du){
+	/*=====
+	declare("dojox.charting.plot2d.__CartesianCtorArgs", dojox.charting.plot2d.__PlotCtorArgs, {
+		// hAxis: String?
+		//		The horizontal axis name.
+		hAxis: "x",
+
+		// vAxis: String?
+		//		The vertical axis name
+		vAxis: "y",
+
+		// labels: Boolean?
+		//		For plots that support labels, whether or not to draw labels for each data item.  Default is false.
+		labels:			false,
+
+		// fixed: Boolean?
+        //		Whether a fixed precision must be applied to data values for display. Default is true.
+		fixed:			true,
+
+		// precision: Number?
+        //		The precision at which to round data values for display. Default is 0.
+		precision:		1,
+
+		// labelOffset: Number?
+		//		The amount in pixels by which to offset labels when using "outside" labelStyle.  Default is 10.
+		labelOffset:	10,
+
+		// labelStyle: String?
+		//		Options as to where to draw labels.  This must be either "inside" or "outside". By default
+		//      the labels are drawn "inside" the shape representing the data point (a column rectangle for a Columns plot
+		//      or a marker for a Line plot for instance). When "outside" is used the labels are drawn above the data point shape.
+		labelStyle:		"inside",
+
+		// htmlLabels: Boolean?
+		//		Whether or not to use HTML to render slice labels. Default is true.
+		htmlLabels:		true,
+
+		// omitLabels: Boolean?
+		//		Whether labels that do not fit in an item render are omitted or not.	This applies only when labelStyle
+		//		is "inside".	Default is false.
+		omitLabels: true,
+
+		// labelFunc: Function?
+		//		An optional function to use to compute label text. It takes precedence over
+		//		the default text when available.
+		//	|		function labelFunc(value, fixed, precision) {}
+		//		`value` is the data value to display
+		//		`fixed` is true if fixed precision must be applied.
+		//		`precision` is the requested precision to be applied.
+		labelFunc: null
+	});
+	=====*/
+
+	return declare("dojox.charting.plot2d.CartesianBase", Base, {
+		baseParams: {
+			hAxis: 			"x",
+			vAxis: 			"y",
+			labels:			false,
+			labelOffset:    10,
+			fixed:			true,
+			precision:		1,
+			labelStyle:		"inside",
+			htmlLabels:		true,		// use HTML to draw labels
+			omitLabels:		true,
+			labelFunc:		null
+        },
+
+		// summary:
+		//		Base class for cartesian plot types.
+		constructor: function(chart, kwArgs){
+			// summary:
+			//		Create a cartesian base plot for cartesian charts.
+			// chart: dojox/chart/Chart
+			//		The chart this plot belongs to.
+			// kwArgs: dojox.charting.plot2d.__CartesianCtorArgs?
+			//		An optional arguments object to help define the plot.
+			this.axes = ["hAxis", "vAxis"];
+			this.zoom = null;
+			this.zoomQueue = [];	// zooming action task queue
+			this.lastWindow = {vscale: 1, hscale: 1, xoffset: 0, yoffset: 0};
+			this.hAxis = (kwArgs && kwArgs.hAxis) || "x";
+			this.vAxis = (kwArgs && kwArgs.vAxis) || "y";
+			this.series = [];
+			this.opt = lang.clone(this.baseParams);
+			du.updateWithObject(this.opt, kwArgs);
+		},
+		clear: function(){
+			// summary:
+			//		Clear out all of the information tied to this plot.
+			// returns: dojox/charting/plot2d/CartesianBase
+			//		A reference to this plot for functional chaining.
+			this.inherited(arguments);
+			this._hAxis = null;
+			this._vAxis = null;
+			return this;	//	dojox/charting/plot2d/CartesianBase
+		},
+		cleanGroup: function(creator, noClip){
+			this.inherited(arguments);
+			if(!noClip && this.chart._nativeClip){
+				var offsets = this.chart.offsets, dim = this.chart.dim;
+				var w = Math.max(0, dim.width  - offsets.l - offsets.r),
+					h = Math.max(0, dim.height - offsets.t - offsets.b);
+				this.group.setClip({ x: offsets.l, y: offsets.t, width: w, height: h });
+				if(!this._clippedGroup){
+					this._clippedGroup = this.group.createGroup();
+				}
+			}
+		},
+		purgeGroup: function(){
+			this.inherited(arguments);
+			this._clippedGroup = null;
+		},
+		getGroup: function(){
+			return this._clippedGroup || this.group;
+		},
+		setAxis: function(axis){
+			// summary:
+			//		Set an axis for this plot.
+			// axis: dojox/charting/axis2d/Base
+			//		The axis to set.
+			// returns: dojox/charting/plot2d/CartesianBase
+			//		A reference to this plot for functional chaining.
+			if(axis){
+				this[axis.vertical ? "_vAxis" : "_hAxis"] = axis;
+			}
+			return this;	//	dojox/charting/plot2d/CartesianBase
+		},
+		toPage: function(coord){
+			// summary:
+			//		Compute page coordinates from plot axis data coordinates.
+			// coord: Object?
+			//		The coordinates in plot axis data coordinate space. For cartesian charts that is of the following form:
+			//		`{ hAxisName: 50, vAxisName: 200 }`
+			//		If not provided return the transform method instead of the result of the transformation.
+			// returns: Object
+			//		The resulting page pixel coordinates. That is of the following form:
+			//		`{ x: 50, y: 200 }`
+			var ah = this._hAxis, av = this._vAxis,
+				sh = ah.getScaler(), sv = av.getScaler(),
+				th = sh.scaler.getTransformerFromModel(sh),
+				tv = sv.scaler.getTransformerFromModel(sv),
+				c = this.chart.getCoords(),
+				o = this.chart.offsets, dim = this.chart.dim;
+			var t = function(coord){
+				var r = {};
+				r.x = th(coord[ah.name]) + c.x + o.l;
+				r.y = c.y + dim.height - o.b - tv(coord[av.name]);
+				return r;
+			};
+			// if no coord return the function so that we can capture the current transforms
+			// and reuse them later on
+			return coord?t(coord):t; // Object
+		},
+		toData: function(coord){
+			// summary:
+			//		Compute plot axis data coordinates from page coordinates.
+			// coord: Object
+			//		The pixel coordinate in page coordinate space. That is of the following form:
+			//		`{ x: 50, y: 200 }`
+			//		If not provided return the tranform method instead of the result of the transformation.
+			// returns: Object
+			//		The resulting plot axis data coordinates. For cartesian charts that is of the following form:
+			//		`{ hAxisName: 50, vAxisName: 200 }`
+			var ah = this._hAxis, av = this._vAxis,
+				sh = ah.getScaler(), sv = av.getScaler(),
+				th = sh.scaler.getTransformerFromPlot(sh),
+				tv = sv.scaler.getTransformerFromPlot(sv),
+				c = this.chart.getCoords(),
+				o = this.chart.offsets, dim = this.chart.dim;
+			var t = function(coord){
+				var r = {};
+				r[ah.name] = th(coord.x - c.x - o.l);
+				r[av.name] = tv(c.y + dim.height - coord.y  - o.b);
+				return r;
+			};
+			// if no coord return the function so that we can capture the current transforms
+			// and reuse them later on
+			return coord?t(coord):t; // Object
+		},
+		isDirty: function(){
+			// summary:
+			//		Returns whether or not this plot needs to be rendered.
+			// returns: Boolean
+			//		The state of the plot.
+			return this.dirty || this._hAxis && this._hAxis.dirty || this._vAxis && this._vAxis.dirty;	//	Boolean
+		},
+		createLabel: function(group, value, bbox, theme){
+			if(this.opt.labels){
+				var x, y, label = this.opt.labelFunc?this.opt.labelFunc.apply(this, [value, this.opt.fixed, this.opt.precision]):
+					this._getLabel(isNaN(value.y)?value:value.y);
+				if(this.opt.labelStyle == "inside"){
+					var lbox = gfx._base._getTextBox(label, { font: theme.series.font } );
+					x = bbox.x + bbox.width / 2;
+					y = bbox.y + bbox.height / 2 + lbox.h / 4;
+					if(lbox.w > bbox.width || lbox.h > bbox.height){
+						return;
+					}
+
+				}else{
+					x = bbox.x + bbox.width / 2;
+					y = bbox.y - this.opt.labelOffset;
+				}
+				this.renderLabel(group, x, y, label, theme, this.opt.labelStyle == "inside");
+			}
+		},
+		performZoom: function(dim, offsets){
+			// summary:
+			//		Create/alter any zooming windows on this plot.
+			// dim: Object
+			//		An object of the form { width, height }.
+			// offsets: Object
+			//		An object of the form { l, r, t, b }.
+			// returns: dojox/charting/plot2d/CartesianBase
+			//		A reference to this plot for functional chaining.
+
+			// get current zooming various
+			var vs = this._vAxis.scale || 1,
+				hs = this._hAxis.scale || 1,
+				vOffset = dim.height - offsets.b,
+				hBounds = this._hScaler.bounds,
+				xOffset = (hBounds.from - hBounds.lower) * hBounds.scale,
+				vBounds = this._vScaler.bounds,
+				yOffset = (vBounds.from - vBounds.lower) * vBounds.scale,
+				// get incremental zooming various
+				rVScale = vs / this.lastWindow.vscale,
+				rHScale = hs / this.lastWindow.hscale,
+				rXOffset = (this.lastWindow.xoffset - xOffset)/
+					((this.lastWindow.hscale == 1)? hs : this.lastWindow.hscale),
+				rYOffset = (yOffset - this.lastWindow.yoffset)/
+					((this.lastWindow.vscale == 1)? vs : this.lastWindow.vscale),
+
+				shape = this.getGroup(),
+				anim = fx.animateTransform(lang.delegate({
+					shape: shape,
+					duration: 1200,
+					transform:[
+						{name:"translate", start:[0, 0], end: [offsets.l * (1 - rHScale), vOffset * (1 - rVScale)]},
+						{name:"scale", start:[1, 1], end: [rHScale, rVScale]},
+						{name:"original"},
+						{name:"translate", start: [0, 0], end: [rXOffset, rYOffset]}
+					]}, this.zoom));
+
+			lang.mixin(this.lastWindow, {vscale: vs, hscale: hs, xoffset: xOffset, yoffset: yOffset});
+			//add anim to zooming action queue,
+			//in order to avoid several zooming action happened at the same time
+			this.zoomQueue.push(anim);
+			//perform each anim one by one in zoomQueue
+			hub.connect(anim, "onEnd", this, function(){
+				this.zoom = null;
+				this.zoomQueue.shift();
+				if(this.zoomQueue.length > 0){
+					this.zoomQueue[0].play();
+				}
+			});
+			if(this.zoomQueue.length == 1){
+				this.zoomQueue[0].play();
+			}
+			return this;	//	dojox/charting/plot2d/CartesianBase
+		},
+		initializeScalers: function(dim, stats){
+			// summary:
+			//		Initializes scalers using attached axes.
+			// dim: Object
+			//		Size of a plot area in pixels as {width, height}.
+			// stats: Object
+			//		Min/max of data in both directions as {hmin, hmax, vmin, vmax}.
+			// returns: dojox/charting/plot2d/CartesianBase
+			//		A reference to this plot for functional chaining.
+			if(this._hAxis){
+				if(!this._hAxis.initialized()){
+					this._hAxis.calculate(stats.hmin, stats.hmax, dim.width);
+				}
+				this._hScaler = this._hAxis.getScaler();
+			}else{
+				this._hScaler = primitive.buildScaler(stats.hmin, stats.hmax, dim.width);
+			}
+			if(this._vAxis){
+				if(!this._vAxis.initialized()){
+					this._vAxis.calculate(stats.vmin, stats.vmax, dim.height);
+				}
+				this._vScaler = this._vAxis.getScaler();
+			}else{
+				this._vScaler = primitive.buildScaler(stats.vmin, stats.vmax, dim.height);
+			}
+			return this;	//	dojox/charting/plot2d/CartesianBase
+		}
+	});
+});

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

@@ -0,0 +1,13 @@
+//>>built
+define("dojox/charting/plot2d/ClusteredBars",["dojo/_base/declare","dojo/_base/array","./Bars","./common"],function(_1,_2,_3,dc){
+return _1("dojox.charting.plot2d.ClusteredBars",_3,{getBarProperties:function(){
+var _4=this.series.length;
+_2.forEach(this.series,function(_5){
+if(_5.hidden){
+_4--;
+}
+});
+var f=dc.calculateBarSize(this._vScaler.bounds.scale,this.opt,_4);
+return {gap:f.gap,height:f.size,thickness:f.size};
+}});
+});

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

@@ -0,0 +1,14 @@
+define("dojox/charting/plot2d/ClusteredBars", ["dojo/_base/declare", "dojo/_base/array", "./Bars", "./common"], 
+	function(declare, array, Bars, dc){
+
+	return declare("dojox.charting.plot2d.ClusteredBars", Bars, {
+		// summary:
+		//		A plot representing grouped or clustered bars (horizontal bars)
+		getBarProperties: function(){
+			var length = this.series.length;
+			array.forEach(this.series, function(serie){if(serie.hidden){length--;}});
+			var f = dc.calculateBarSize(this._vScaler.bounds.scale, this.opt, length);
+			return {gap: f.gap, height: f.size, thickness: f.size};
+		}
+	});
+});

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

@@ -0,0 +1,13 @@
+//>>built
+define("dojox/charting/plot2d/ClusteredColumns",["dojo/_base/declare","dojo/_base/array","./Columns","./common"],function(_1,_2,_3,dc){
+return _1("dojox.charting.plot2d.ClusteredColumns",_3,{getBarProperties:function(){
+var _4=this.series.length;
+_2.forEach(this.series,function(_5){
+if(_5.hidden){
+_4--;
+}
+});
+var f=dc.calculateBarSize(this._hScaler.bounds.scale,this.opt,_4);
+return {gap:f.gap,width:f.size,thickness:f.size,clusterSize:_4};
+}});
+});