@datagrok/helm 2.3.2 → 2.3.4

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

@@ -0,0 +1,472 @@
+define("dojox/charting/plot2d/Default", ["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){
+
+	/*=====
+	declare("dojox.charting.plot2d.__DefaultCtorArgs", dojox.charting.plot2d.__CartesianCtorArgs, {
+		// summary:
+		//		The arguments used for any/most plots.
+	
+		// lines: Boolean?
+		//		Whether or not to draw lines on this plot.  Defaults to true.
+		lines:   true,
+	
+		// areas: Boolean?
+		//		Whether or not to draw areas on this plot. Defaults to false.
+		areas:   false,
+	
+		// markers: Boolean?
+		//		Whether or not to draw markers at data points on this plot. Default is false.
+		markers: false,
+	
+		// tension: Number|String?
+		//		Whether or not to apply 'tensioning' to the lines on this chart.
+		//		Options include a number, "X", "x", or "S"; if a number is used, the
+		//		simpler bezier curve calculations are used to draw the lines.  If X, x or S
+		//		is used, the more accurate smoothing algorithm is used.
+		tension: "",
+	
+		// animate: Boolean?|Number?
+		//		Whether or not to animate the chart to place. When a Number it specifies the duration of the animation.
+		//		Default is false.
+		animate: false,
+	
+		// 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 (such as areas).
+		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:	"",
+	
+		// markerStroke: dojo.gfx.Stroke?
+		//		An optional stroke to use for any markers on the plot.
+		markerStroke:		{},
+	
+		// markerOutline: dojo.gfx.Stroke?
+		//		An optional outline to use for any markers on the plot.
+		markerOutline:		{},
+	
+		// markerShadow: dojo.gfx.Stroke?
+		//		An optional shadow to use for any markers on the plot.
+		markerShadow:		{},
+	
+		// markerFill: dojo.gfx.Fill?
+		//		An optional fill to use for any markers on the plot.
+		markerFill:			{},
+	
+		// markerFont: String?
+		//		An optional font definition to use for any markers on the plot.
+		markerFont:			"",
+	
+		// markerFontColor: String|dojo.Color?
+		//		An optional color to use for any marker text on the plot.
+		markerFontColor:	"",
+		
+		// enableCache: Boolean?
+		//		Whether the markers are cached from one rendering to another. This improves the rendering performance of
+		//		successive rendering but penalize the first rendering.  Default false.
+		enableCache: false,
+
+		// interpolate: Boolean?
+		//		Whether when there is a null data point in the data the plot interpolates it or if the lines is split at that
+		//		point.	Default false.
+		interpolate: false
+	});
+=====*/
+
+	var purgeGroup = dfr.lambda("item.purgeGroup()");
+
+	var DEFAULT_ANIMATION_LENGTH = 1200;	// in ms
+
+	return declare("dojox.charting.plot2d.Default", [CartesianBase, _PlotEvents], {
+		
+		// defaultParams:
+		//		The default parameters of this plot.
+		defaultParams: {
+			lines:   true,	// draw lines
+			areas:   false,	// draw areas
+			markers: false,	// draw markers
+			tension: "",	// draw curved lines (tension is "X", "x", or "S")
+			animate: false, // animate chart to place
+			enableCache: false,
+			interpolate: false
+		},
+		
+		// optionalParams:
+		//		The optional parameters of this plot.
+		optionalParams: {
+			// theme component
+			stroke:		{},
+			outline:	{},
+			shadow:		{},
+			fill:		{},
+			filter:     {},
+			styleFunc: null,
+			font:		"",
+			fontColor:	"",
+			marker:             "",
+			markerStroke:		{},
+			markerOutline:		{},
+			markerShadow:		{},
+			markerFill:			{},
+			markerFont:			"",
+			markerFontColor:	""
+		},
+
+		constructor: function(chart, kwArgs){
+			// summary:
+			//		Return a new plot.
+			// chart: dojox/charting/Chart
+			//		The chart this plot belongs to.
+			// kwArgs: dojox.charting.plot2d.__DefaultCtorArgs?
+			//		An optional arguments object to help define this plot.
+			this.opt = lang.clone(lang.mixin(this.opt, this.defaultParams));
+			du.updateWithObject(this.opt, kwArgs);
+			du.updateWithPattern(this.opt, kwArgs, this.optionalParams);
+			// animation properties
+			this.animate = this.opt.animate;
+		},
+
+		createPath: function(run, creator, params){
+			var path;
+			if(this.opt.enableCache && run._pathFreePool.length > 0){
+				path = run._pathFreePool.pop();
+				path.setShape(params);
+				// was cleared, add it back
+				creator.add(path);
+			}else{
+				path = creator.createPath(params);
+			}
+			if(this.opt.enableCache){
+				run._pathUsePool.push(path);
+			}
+			return path;
+		},
+
+		buildSegments: function(i, indexed){
+			var run = this.series[i],
+				min = indexed?Math.max(0, Math.floor(this._hScaler.bounds.from - 1)):0,
+				max = indexed?Math.min(run.data.length, Math.ceil(this._hScaler.bounds.to)):run.data.length,
+				rseg = null, segments = [];
+
+			// split the run data into dense segments (each containing no nulls)
+			// except if interpolates is false in which case ignore null between valid data
+			for(var j = min; j < max; j++){
+				if(run.data[j] != null && (indexed || run.data[j].y != null)){
+					if(!rseg){
+						rseg = [];
+						segments.push({index: j, rseg: rseg});
+					}
+					rseg.push((indexed && run.data[j].hasOwnProperty("y"))?run.data[j].y:run.data[j]);
+				}else{
+					if(!this.opt.interpolate || indexed){
+						// we break the line only if not interpolating or if we have indexed data
+						rseg = null;
+					}
+				}
+			}
+			return segments;
+		},
+
+		render: function(dim, offsets){
+			// summary:
+			//		Render/draw everything 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/Default
+			//		A reference to this plot for functional chaining.
+
+			// make sure all the series is not modified
+			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();
+				this.getGroup().setTransform(null);
+				s = this.getGroup();
+				df.forEachRev(this.series, function(item){ item.cleanGroup(s); });
+			}
+			var t = this.chart.theme, stroke, outline, events = this.events();
+
+			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._pathFreePool = (run._pathFreePool?run._pathFreePool:[]).concat(run._pathUsePool?run._pathUsePool:[]);
+					run._pathUsePool = [];
+				}
+				if(!run.data.length){
+					run.dirty = false;
+					t.skip();
+					continue;
+				}
+
+				var theme = t.next(this.opt.areas ? "area" : "line", [this.opt, run], true),
+					lpoly,
+					ht = this._hScaler.scaler.getTransformerFromModel(this._hScaler),
+					vt = this._vScaler.scaler.getTransformerFromModel(this._vScaler),
+					eventSeries = this._eventSeries[run.name] = new Array(run.data.length);
+
+				s = run.group;
+				if(run.hidden){
+					if(this.opt.lines){
+						run.dyn.stroke = theme.series.stroke;
+					}
+					if(this.opt.markers){
+						run.dyn.markerFill = theme.marker.fill;
+						run.dyn.markerStroke = theme.marker.stroke;
+						run.dyn.marker = theme.symbol;
+					}
+					if(this.opt.areas){ 
+						run.dyn.fill = theme.series.fill;
+					}
+					continue;
+				}
+				// optim works only for index based case
+				var indexed = arr.some(run.data, function(item){
+					return typeof item == "number" || (item && !item.hasOwnProperty("x"));
+				});
+
+				var rsegments = this.buildSegments(i, indexed);
+				for(var seg = 0; seg < rsegments.length; seg++){
+					var rsegment = rsegments[seg];
+					if(indexed){
+						lpoly = arr.map(rsegment.rseg, function(v, i){
+							return {
+								x: ht(i + rsegment.index + 1) + offsets.l,
+								y: dim.height - offsets.b - vt(v),
+								data: v
+							};
+						}, this);
+					}else{
+						lpoly = arr.map(rsegment.rseg, function(v){
+							return {
+								x: ht(v.x) + offsets.l,
+								y: dim.height - offsets.b - vt(v.y),
+								data: v
+							};
+						}, this);
+					}
+
+					// if we are indexed & we interpolate we need to put all the segments as a single one now
+					if(indexed && this.opt.interpolate){
+						while(seg < rsegments.length) {
+							seg++;
+							rsegment = rsegments[seg];
+							if(rsegment){
+								lpoly = lpoly.concat(arr.map(rsegment.rseg, function(v, i){
+									return {
+										x: ht(i + rsegment.index + 1) + offsets.l,
+										y: dim.height - offsets.b - vt(v),
+										data: v
+									};
+								}, this));
+							}
+						}
+					} 
+
+					var lpath = this.opt.tension ? dc.curve(lpoly, this.opt.tension) : "";
+
+					if(this.opt.areas && lpoly.length > 1){
+						var fill = this._plotFill(theme.series.fill, dim, offsets), apoly = lang.clone(lpoly);
+						if(this.opt.tension){
+							var apath = "L" + apoly[apoly.length-1].x + "," + (dim.height - offsets.b) +
+								" L" + apoly[0].x + "," + (dim.height - offsets.b) +
+								" L" + apoly[0].x + "," + apoly[0].y;
+							run.dyn.fill = s.createPath(lpath + " " + apath).setFill(fill).getFill();
+						} else {
+							apoly.push({x: lpoly[lpoly.length - 1].x, y: dim.height - offsets.b});
+							apoly.push({x: lpoly[0].x, y: dim.height - offsets.b});
+							apoly.push(lpoly[0]);
+							run.dyn.fill = s.createPolyline(apoly).setFill(fill).getFill();
+						}
+					}
+					if(this.opt.lines || this.opt.markers){
+						// need a stroke
+						stroke = theme.series.stroke;
+						if(theme.series.outline){
+							outline = run.dyn.outline = dc.makeStroke(theme.series.outline);
+							outline.width = 2 * outline.width + stroke.width;
+						}
+					}
+					if(this.opt.markers){
+						run.dyn.marker = theme.symbol;
+					}
+					var frontMarkers = null, outlineMarkers = null, shadowMarkers = null;
+					if(stroke && theme.series.shadow && lpoly.length > 1){
+						var shadow = theme.series.shadow,
+							spoly = arr.map(lpoly, function(c){
+								return {x: c.x + shadow.dx, y: c.y + shadow.dy};
+							});
+						if(this.opt.lines){
+							if(this.opt.tension){
+								run.dyn.shadow = s.createPath(dc.curve(spoly, this.opt.tension)).setStroke(shadow).getStroke();
+							} else {
+								run.dyn.shadow = s.createPolyline(spoly).setStroke(shadow).getStroke();
+							}
+						}
+						if(this.opt.markers && theme.marker.shadow){
+							shadow = theme.marker.shadow;
+							shadowMarkers = arr.map(spoly, function(c){
+								return this.createPath(run, s, "M" + c.x + " " + c.y + " " + theme.symbol).
+									setStroke(shadow).setFill(shadow.color);
+							}, this);
+						}
+					}
+					if(this.opt.lines && lpoly.length > 1){
+						var shape;
+						if(outline){
+							if(this.opt.tension){
+								run.dyn.outline = s.createPath(lpath).setStroke(outline).getStroke();
+							} else {
+								run.dyn.outline = s.createPolyline(lpoly).setStroke(outline).getStroke();
+							}
+						}
+						if(this.opt.tension){
+							run.dyn.stroke = (shape = s.createPath(lpath)).setStroke(stroke).getStroke();
+						} else {
+							run.dyn.stroke = (shape = s.createPolyline(lpoly)).setStroke(stroke).getStroke();
+						}
+						if(shape.setFilter && theme.series.filter){
+							shape.setFilter(theme.series.filter);
+						}
+					}
+					var markerBox = null;
+					if(this.opt.markers){
+						var markerTheme = theme; 
+						frontMarkers = new Array(lpoly.length);
+						outlineMarkers = new Array(lpoly.length);
+						outline = null;
+						if(markerTheme.marker.outline){
+							outline = dc.makeStroke(markerTheme.marker.outline);
+							outline.width = 2 * outline.width + (markerTheme.marker.stroke ? markerTheme.marker.stroke.width : 0);
+						}
+						arr.forEach(lpoly, function(c, i){
+							if(this.opt.styleFunc || typeof c.data != "number"){
+								var tMixin = typeof c.data != "number" ? [c.data] : [];
+								if(this.opt.styleFunc){
+									tMixin.push(this.opt.styleFunc(c.data));
+								}
+								markerTheme = t.addMixin(theme, "marker", tMixin, true);
+							}else{
+								markerTheme = t.post(theme, "marker");
+							}
+							var path = "M" + c.x + " " + c.y + " " + markerTheme.symbol;
+							if(outline){
+								outlineMarkers[i] = this.createPath(run, s, path).setStroke(outline);
+							}
+							frontMarkers[i] = this.createPath(run, s, path).setStroke(markerTheme.marker.stroke).setFill(markerTheme.marker.fill);
+						}, this);
+						run.dyn.markerFill = markerTheme.marker.fill;
+						run.dyn.markerStroke = markerTheme.marker.stroke;
+						if(!markerBox && this.opt.labels){
+							markerBox = frontMarkers[0].getBoundingBox();
+						}
+						if(events){
+							arr.forEach(frontMarkers, function(s, i){
+								var o = {
+									element: "marker",
+									index:   i + rsegment.index,
+									run:     run,
+									shape:   s,
+									outline: outlineMarkers[i] || null,
+									shadow:  shadowMarkers && shadowMarkers[i] || null,
+									cx:      lpoly[i].x,
+									cy:      lpoly[i].y
+								};
+								if(indexed){
+									o.x = i + rsegment.index + 1;
+									o.y = run.data[i + rsegment.index];
+								}else{
+									o.x = rsegment.rseg[i].x;
+									o.y = run.data[i + rsegment.index].y;
+								}
+								this._connectEvents(o);
+								eventSeries[i + rsegment.index] = o;
+							}, this);
+						}else{
+							delete this._eventSeries[run.name];
+						}
+					}
+					if(this.opt.labels){
+						var labelBoxW = markerBox?markerBox.width:2;
+						var labelBoxH = markerBox?markerBox.height:2;
+						arr.forEach(lpoly, function(c, i){
+							if(this.opt.styleFunc || typeof c.data != "number"){
+								var tMixin = typeof c.data != "number" ? [c.data] : [];
+								if(this.opt.styleFunc){
+									tMixin.push(this.opt.styleFunc(c.data));
+								}
+								markerTheme = t.addMixin(theme, "marker", tMixin, true);
+							}else{
+								markerTheme = t.post(theme, "marker");
+							}
+							this.createLabel(s, rsegment.rseg[i], { x: c.x - labelBoxW / 2, y: c.y - labelBoxH / 2,
+								width: labelBoxW , height: labelBoxH }, markerTheme);
+						}, this);
+					}
+				}
+				run.dirty = false;
+			}
+			// chart mirroring starts
+			if(has("dojo-bidi")){
+				this._checkOrientation(this.group, dim, offsets);
+			}
+			// chart mirroring ends
+			if(this.animate){
+				// grow from the bottom
+				var plotGroup = this.getGroup();
+				fx.animateTransform(lang.delegate({
+					shape: plotGroup,
+					duration: DEFAULT_ANIMATION_LENGTH,
+					transform:[
+						{name:"translate", start: [0, dim.height - offsets.b], end: [0, 0]},
+						{name:"scale", start: [1, 0], end:[1, 1]},
+						{name:"original"}
+					]
+				}, this.animate)).play();
+			}
+			this.dirty = false;
+			return this;	//	dojox/charting/plot2d/Default
+		}
+	});
+});

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

@@ -0,0 +1,182 @@
+//>>built
+define("dojox/charting/plot2d/Grid",["dojo/_base/lang","dojo/_base/declare","dojo/_base/array","dojo/sniff","./CartesianBase","./common","dojox/lang/utils","dojox/gfx/fx"],function(_1,_2,_3,_4,_5,dc,du,fx){
+var _6=function(a,b){
+return a.value-b.value;
+};
+return _2("dojox.charting.plot2d.Grid",_5,{defaultParams:{hMajorLines:true,hMinorLines:false,vMajorLines:true,vMinorLines:false,hStripes:false,vStripes:false,animate:null,enableCache:false,renderOnAxis:true},optionalParams:{majorHLine:{},minorHLine:{},majorVLine:{},minorVLine:{},hFill:{},vFill:{},hAlternateFill:{},vAlternateFill:{}},constructor:function(_7,_8){
+this.opt=_1.clone(this.defaultParams);
+du.updateWithObject(this.opt,_8);
+du.updateWithPattern(this.opt,_8,this.optionalParams);
+this.animate=this.opt.animate;
+if(this.opt.enableCache){
+this._lineFreePool=[];
+this._lineUsePool=[];
+this._rectFreePool=[];
+this._rectUsePool=[];
+}
+},addSeries:function(_9){
+return this;
+},getSeriesStats:function(){
+return _1.delegate(dc.defaultStats);
+},cleanGroup:function(){
+this.inherited(arguments);
+if(this.opt.enableCache){
+this._lineFreePool=this._lineFreePool.concat(this._lineUsePool);
+this._lineUsePool=[];
+this._rectFreePool=this._rectFreePool.concat(this._rectUsePool);
+this._rectUsePool=[];
+}
+},createLine:function(_a,_b){
+var _c;
+if(this.opt.enableCache&&this._lineFreePool.length>0){
+_c=this._lineFreePool.pop();
+_c.setShape(_b);
+_a.add(_c);
+}else{
+_c=_a.createLine(_b);
+}
+if(this.opt.enableCache){
+this._lineUsePool.push(_c);
+}
+return _c;
+},createRect:function(_d,_e){
+var _f;
+if(this.opt.enableCache&&this._rectFreePool.length>0){
+_f=this._rectFreePool.pop();
+_f.setShape(_e);
+_d.add(_f);
+}else{
+_f=_d.createRect(_e);
+}
+if(this.opt.enableCache){
+this._rectUsePool.push(_f);
+}
+return _f;
+},render:function(dim,_10){
+if(this.zoom){
+return this.performZoom(dim,_10);
+}
+this.dirty=this.isDirty();
+if(!this.dirty){
+return this;
+}
+this.cleanGroup();
+var s=this.getGroup(),ta=this.chart.theme,_11,_12;
+if((_4("ios")&&_4("ios")<6)||_4("android")||(_4("safari")&&!_4("ios"))){
+var w=Math.max(0,dim.width-_10.l-_10.r),h=Math.max(0,dim.height-_10.t-_10.b);
+s.createRect({x:_10.l,y:_10.t,width:w,height:h});
+}
+if(this._vAxis){
+_12=this._vAxis.getTicks();
+var _13=this._vAxis.getScaler();
+if(_12!=null&&_13!=null){
+var vt=_13.scaler.getTransformerFromModel(_13);
+if(this.opt.hStripes){
+this._renderHRect(_12,ta.grid,dim,_10,_13,vt);
+}
+if(this.opt.hMinorLines){
+_11=this.opt.minorHLine||(ta.grid&&ta.grid.minorLine)||ta.axis.minorTick;
+this._renderHLines(_12.minor,_11,dim,_10,_13,vt);
+}
+if(this.opt.hMajorLines){
+_11=this.opt.majorHLine||(ta.grid&&ta.grid.majorLine)||ta.axis.majorTick;
+this._renderHLines(_12.major,_11,dim,_10,_13,vt);
+}
+}
+}
+if(this._hAxis){
+_12=this._hAxis.getTicks();
+var _14=this._hAxis.getScaler();
+if(_12!=null&&_14!=null){
+var ht=_14.scaler.getTransformerFromModel(_14);
+if(this.opt.vStripes){
+this._renderVRect(_12,ta.grid,dim,_10,_14,ht);
+}
+if(_12&&this.opt.vMinorLines){
+_11=this.opt.minorVLine||(ta.grid&&ta.grid.minorLine)||ta.axis.minorTick;
+this._renderVLines(_12.minor,_11,dim,_10,_14,ht);
+}
+if(_12&&this.opt.vMajorLines){
+_11=this.opt.majorVLine||(ta.grid&&ta.grid.majorLine)||ta.axis.majorTick;
+this._renderVLines(_12.major,_11,dim,_10,_14,ht);
+}
+}
+}
+this.dirty=false;
+return this;
+},_renderHLines:function(_15,_16,dim,_17,_18,vt){
+var s=this.getGroup();
+_3.forEach(_15,function(_19){
+if(!this.opt.renderOnAxis&&_19.value==(this._vAxis.opt.leftBottom?_18.bounds.from:_18.bounds.to)){
+return;
+}
+var y=dim.height-_17.b-vt(_19.value);
+var _1a=this.createLine(s,{x1:_17.l,y1:y,x2:dim.width-_17.r,y2:y}).setStroke(_16);
+if(this.animate){
+this._animateGrid(_1a,"h",_17.l,_17.r+_17.l-dim.width);
+}
+},this);
+},_renderVLines:function(_1b,_1c,dim,_1d,_1e,ht){
+var s=this.getGroup();
+_3.forEach(_1b,function(_1f){
+if(!this.opt.renderOnAxis&&_1f.value==(this._hAxis.opt.leftBottom?_1e.bounds.from:_1e.bounds.to)){
+return;
+}
+var x=_1d.l+ht(_1f.value);
+var _20=this.createLine(s,{x1:x,y1:_1d.t,x2:x,y2:dim.height-_1d.b}).setStroke(_1c);
+if(this.animate){
+this._animateGrid(_20,"v",dim.height-_1d.b,dim.height-_1d.b-_1d.t);
+}
+},this);
+},_renderHRect:function(_21,_22,dim,_23,_24,vt){
+var _25,_26,y,y2,_27;
+var _28=_21.major.concat(_21.minor);
+_28.sort(_6);
+if(_28[0].value>_24.bounds.from){
+_28.splice(0,0,{value:_24.bounds.from});
+}
+if(_28[_28.length-1].value<_24.bounds.to){
+_28.push({value:_24.bounds.to});
+}
+var s=this.getGroup();
+for(var j=0;j<_28.length-1;j++){
+_26=_28[j];
+y=dim.height-_23.b-vt(_26.value);
+y2=dim.height-_23.b-vt(_28[j+1].value);
+_25=(j%2==0)?(this.opt.hAlternateFill||(_22&&_22.alternateFill)):(this.opt.hFill||(_22&&_22.fill));
+if(_25){
+_27=this.createRect(s,{x:_23.l,y:y,width:dim.width-_23.r,height:y-y2}).setFill(_25);
+if(this.animate){
+this._animateGrid(_27,"h",_23.l,_23.r+_23.l-dim.width);
+}
+}
+}
+},_renderVRect:function(_29,_2a,dim,_2b,_2c,ht){
+var _2d,_2e,x,x2,_2f;
+var _30=_29.major.concat(_29.minor);
+_30.sort(_6);
+if(_30[0].value>_2c.bounds.from){
+_30.splice(0,0,{value:_2c.bounds.from});
+}
+if(_30[_30.length-1].value<_2c.bounds.to){
+_30.push({value:_2c.bounds.to});
+}
+var s=this.getGroup();
+for(var j=0;j<_30.length-1;j++){
+_2e=_30[j];
+x=_2b.l+ht(_2e.value);
+x2=_2b.l+ht(_30[j+1].value);
+_2d=(j%2==0)?(this.opt.vAlternateFill||(_2a&&_2a.alternateFill)):(this.opt.vFill||(_2a&&_2a.fill));
+if(_2d){
+_2f=this.createRect(s,{x:x,y:_2b.t,width:x2-x,height:dim.width-_2b.r}).setFill(_2d);
+if(this.animate){
+this._animateGrid(_2f,"v",dim.height-_2b.b,dim.height-_2b.b-_2b.t);
+}
+}
+}
+},_animateGrid:function(_31,_32,_33,_34){
+var _35=_32=="h"?[_33,0]:[0,_33];
+var _36=_32=="h"?[1/_34,1]:[1,1/_34];
+fx.animateTransform(_1.delegate({shape:_31,duration:1200,transform:[{name:"translate",start:_35,end:[0,0]},{name:"scale",start:_36,end:[1,1]},{name:"original"}]},this.animate)).play();
+}});
+});