@datagrok/helm 2.3.2 → 2.3.4

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

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

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

@@ -0,0 +1,153 @@
+//>>built
+define("dojox/charting/plot2d/Columns",["dojo/_base/lang","dojo/_base/array","dojo/_base/declare","dojo/has","./CartesianBase","./_PlotEvents","./common","dojox/lang/functional","dojox/lang/functional/reversed","dojox/lang/utils","dojox/gfx/fx"],function(_1,_2,_3,_4,_5,_6,dc,df,_7,du,fx){
+var _8=_7.lambda("item.purgeGroup()");
+return _3("dojox.charting.plot2d.Columns",[_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);
+_b.hmin-=0.5;
+_b.hmax+=0.5;
+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;
+},render:function(dim,_10){
+if(this.zoom&&!this.isDataDirty()){
+return this.performZoom(dim,_10);
+}
+this.resetEvents();
+this.dirty=this.isDirty();
+var s;
+if(this.dirty){
+_2.forEach(this.series,_8);
+this._eventSeries={};
+this.cleanGroup();
+s=this.getGroup();
+df.forEachRev(this.series,function(_11){
+_11.cleanGroup(s);
+});
+}
+var t=this.chart.theme,ht=this._hScaler.scaler.getTransformerFromModel(this._hScaler),vt=this._vScaler.scaler.getTransformerFromModel(this._vScaler),_12=Math.max(0,this._vScaler.bounds.lower),_13=vt(_12),_14=this.events(),bar=this.getBarProperties();
+var z=this.series.length;
+_2.forEach(this.series,function(_15){
+if(_15.hidden){
+z--;
+}
+});
+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 _16=t.next("column",[this.opt,run]),_17=new Array(run.data.length);
+if(run.hidden){
+run.dyn.fill=_16.series.fill;
+continue;
+}
+z--;
+s=run.group;
+var _18=_2.some(run.data,function(_19){
+return typeof _19=="number"||(_19&&!_19.hasOwnProperty("x"));
+});
+var min=_18?Math.max(0,Math.floor(this._hScaler.bounds.from-1)):0;
+var max=_18?Math.min(run.data.length,Math.ceil(this._hScaler.bounds.to)):run.data.length;
+for(var j=min;j<max;++j){
+var _1a=run.data[j];
+if(_1a!=null){
+var val=this.getValue(_1a,j,i,_18),vv=vt(val.y),h=Math.abs(vv-_13),_1b,_1c;
+if(this.opt.styleFunc||typeof _1a!="number"){
+var _1d=typeof _1a!="number"?[_1a]:[];
+if(this.opt.styleFunc){
+_1d.push(this.opt.styleFunc(_1a));
+}
+_1b=t.addMixin(_16,"column",_1d,true);
+}else{
+_1b=t.post(_16,"column");
+}
+if(bar.width>=1&&h>=0){
+var _1e={x:_10.l+ht(val.x+0.5)+bar.gap+bar.thickness*z,y:dim.height-_10.b-(val.y>_12?vv:_13),width:bar.width,height:h};
+if(_1b.series.shadow){
+var _1f=_1.clone(_1e);
+_1f.x+=_1b.series.shadow.dx;
+_1f.y+=_1b.series.shadow.dy;
+_1c=this.createRect(run,s,_1f).setFill(_1b.series.shadow.color).setStroke(_1b.series.shadow);
+if(this.animate){
+this._animateColumn(_1c,dim.height-_10.b+_13,h);
+}
+}
+var _20=this._plotFill(_1b.series.fill,dim,_10);
+_20=this._shapeFill(_20,_1e);
+var _21=this.createRect(run,s,_1e).setFill(_20).setStroke(_1b.series.stroke);
+if(_21.setFilter&&_1b.series.filter){
+_21.setFilter(_1b.series.filter);
+}
+run.dyn.fill=_21.getFill();
+run.dyn.stroke=_21.getStroke();
+if(_14){
+var o={element:"column",index:j,run:run,shape:_21,shadow:_1c,cx:val.x+0.5,cy:val.y,x:_18?j:run.data[j].x,y:_18?run.data[j]:run.data[j].y};
+this._connectEvents(o);
+_17[j]=o;
+}
+if(!isNaN(val.py)&&val.py>_12){
+_1e.height=vv-vt(val.py);
+}
+this.createLabel(s,_1a,_1e,_1b);
+if(this.animate){
+this._animateColumn(_21,dim.height-_10.b-_13,h);
+}
+}
+}
+}
+this._eventSeries[run.name]=_17;
+run.dirty=false;
+}
+this.dirty=false;
+if(_4("dojo-bidi")){
+this._checkOrientation(this.group,dim,_10);
+}
+return this;
+},getValue:function(_22,j,_23,_24){
+var y,x;
+if(_24){
+if(typeof _22=="number"){
+y=_22;
+}else{
+y=_22.y;
+}
+x=j;
+}else{
+y=_22.y;
+x=_22.x-1;
+}
+return {x:x,y:y};
+},getBarProperties:function(){
+var f=dc.calculateBarSize(this._hScaler.bounds.scale,this.opt);
+return {gap:f.gap,width:f.size,thickness:0};
+},_animateColumn:function(_25,_26,_27){
+if(_27==0){
+_27=1;
+}
+fx.animateTransform(_1.delegate({shape:_25,duration:1200,transform:[{name:"translate",start:[0,_26-(_26/_27)],end:[0,0]},{name:"scale",start:[1,1/_27],end:[1,1]},{name:"original"}]},this.animate)).play();
+}});
+});

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

@@ -0,0 +1,249 @@
+define("dojox/charting/plot2d/Columns", ["dojo/_base/lang", "dojo/_base/array", "dojo/_base/declare", "dojo/has", "./CartesianBase", "./_PlotEvents", "./common",
+		"dojox/lang/functional", "dojox/lang/functional/reversed", "dojox/lang/utils", "dojox/gfx/fx"], 
+	function(lang, arr, declare, has, CartesianBase, _PlotEvents, dc, df, dfr, du, fx){
+
+	var purgeGroup = dfr.lambda("item.purgeGroup()");
+
+	return declare("dojox.charting.plot2d.Columns", [CartesianBase, _PlotEvents], {
+		// summary:
+		//		The plot object representing a column chart (vertical bars).
+		defaultParams: {
+			gap:	0,		// gap between columns in pixels
+			animate: null,  // animate bars into place
+			enableCache: false
+		},
+		optionalParams: {
+			minBarSize:	1,	// minimal column width in pixels
+			maxBarSize:	1,	// maximal column width in pixels
+			// theme component
+			stroke:		{},
+			outline:	{},
+			shadow:		{},
+			fill:		{},
+			filter:     {},
+			styleFunc:  null,
+			font:		"",
+			fontColor:	""
+		},
+
+		constructor: function(chart, kwArgs){
+			// summary:
+			//		The constructor for a columns 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);
+			stats.hmin -= 0.5;
+			stats.hmax += 0.5;
+			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;
+		},
+
+		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/Columns
+			//		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,
+				ht = this._hScaler.scaler.getTransformerFromModel(this._hScaler),
+				vt = this._vScaler.scaler.getTransformerFromModel(this._vScaler),
+				baseline = Math.max(0, this._vScaler.bounds.lower),
+				baselineHeight = vt(baseline),
+				events = this.events(),
+				bar = this.getBarProperties();
+			
+			var z = this.series.length;
+			arr.forEach(this.series, function(serie){if(serie.hidden){z--;}});
+
+			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("column", [this.opt, run]),
+					eventSeries = new Array(run.data.length);
+
+				if(run.hidden){
+					run.dyn.fill = theme.series.fill;
+					continue;
+				}
+				z--;
+
+				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._hScaler.bounds.from - 1)):0;
+				var max = indexed?Math.min(run.data.length, Math.ceil(this._hScaler.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),
+							vv = vt(val.y),
+							h = Math.abs(vv - baselineHeight), 
+							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, "column", tMixin, true);
+						}else{
+							finalTheme = t.post(theme, "column");
+						}
+						
+						if(bar.width >= 1 && h >= 0){
+							var rect = {
+								x: offsets.l + ht(val.x + 0.5) + bar.gap + bar.thickness * z,
+								y: dim.height - offsets.b - (val.y > baseline ? vv : baselineHeight),
+								width: bar.width, 
+								height: h
+							};
+							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._animateColumn(sshape, dim.height - offsets.b + baselineHeight, h);
+								}
+							}
+							
+							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: "column",
+									index:   j,
+									run:     run,
+									shape:   shape,
+									shadow:  sshape,
+									cx:      val.x + 0.5,
+									cy:      val.y,
+									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.height = vv - vt(val.py);
+							}
+							this.createLabel(s, value, rect, finalTheme);
+							if(this.animate){
+								this._animateColumn(shape, dim.height - offsets.b - baselineHeight, h);
+							}
+						}
+					}
+				}
+				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/Columns
+		},
+		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 { x: x, y: y };
+		},
+		getBarProperties: function(){
+			var f = dc.calculateBarSize(this._hScaler.bounds.scale, this.opt);
+			return {gap: f.gap, width: f.size, thickness: 0};
+		},
+		_animateColumn: function(shape, voffset, vsize){
+			if(vsize==0){
+				vsize = 1;
+			}
+			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/Default.js

@@ -0,0 +1,253 @@
+//>>built
+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(_1,_2,_3,_4,_5,_6,dc,df,_7,du,fx){
+var _8=_7.lambda("item.purgeGroup()");
+var _9=1200;
+return _2("dojox.charting.plot2d.Default",[_5,_6],{defaultParams:{lines:true,areas:false,markers:false,tension:"",animate:false,enableCache:false,interpolate:false},optionalParams:{stroke:{},outline:{},shadow:{},fill:{},filter:{},styleFunc:null,font:"",fontColor:"",marker:"",markerStroke:{},markerOutline:{},markerShadow:{},markerFill:{},markerFont:"",markerFontColor:""},constructor:function(_a,_b){
+this.opt=_1.clone(_1.mixin(this.opt,this.defaultParams));
+du.updateWithObject(this.opt,_b);
+du.updateWithPattern(this.opt,_b,this.optionalParams);
+this.animate=this.opt.animate;
+},createPath:function(_c,_d,_e){
+var _f;
+if(this.opt.enableCache&&_c._pathFreePool.length>0){
+_f=_c._pathFreePool.pop();
+_f.setShape(_e);
+_d.add(_f);
+}else{
+_f=_d.createPath(_e);
+}
+if(this.opt.enableCache){
+_c._pathUsePool.push(_f);
+}
+return _f;
+},buildSegments:function(i,_10){
+var run=this.series[i],min=_10?Math.max(0,Math.floor(this._hScaler.bounds.from-1)):0,max=_10?Math.min(run.data.length,Math.ceil(this._hScaler.bounds.to)):run.data.length,_11=null,_12=[];
+for(var j=min;j<max;j++){
+if(run.data[j]!=null&&(_10||run.data[j].y!=null)){
+if(!_11){
+_11=[];
+_12.push({index:j,rseg:_11});
+}
+_11.push((_10&&run.data[j].hasOwnProperty("y"))?run.data[j].y:run.data[j]);
+}else{
+if(!this.opt.interpolate||_10){
+_11=null;
+}
+}
+}
+return _12;
+},render:function(dim,_13){
+if(this.zoom&&!this.isDataDirty()){
+return this.performZoom(dim,_13);
+}
+this.resetEvents();
+this.dirty=this.isDirty();
+var s;
+if(this.dirty){
+_3.forEach(this.series,_8);
+this._eventSeries={};
+this.cleanGroup();
+this.getGroup().setTransform(null);
+s=this.getGroup();
+df.forEachRev(this.series,function(_14){
+_14.cleanGroup(s);
+});
+}
+var t=this.chart.theme,_15,_16,_17=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 _18=t.next(this.opt.areas?"area":"line",[this.opt,run],true),_19,ht=this._hScaler.scaler.getTransformerFromModel(this._hScaler),vt=this._vScaler.scaler.getTransformerFromModel(this._vScaler),_1a=this._eventSeries[run.name]=new Array(run.data.length);
+s=run.group;
+if(run.hidden){
+if(this.opt.lines){
+run.dyn.stroke=_18.series.stroke;
+}
+if(this.opt.markers){
+run.dyn.markerFill=_18.marker.fill;
+run.dyn.markerStroke=_18.marker.stroke;
+run.dyn.marker=_18.symbol;
+}
+if(this.opt.areas){
+run.dyn.fill=_18.series.fill;
+}
+continue;
+}
+var _1b=_3.some(run.data,function(_1c){
+return typeof _1c=="number"||(_1c&&!_1c.hasOwnProperty("x"));
+});
+var _1d=this.buildSegments(i,_1b);
+for(var seg=0;seg<_1d.length;seg++){
+var _1e=_1d[seg];
+if(_1b){
+_19=_3.map(_1e.rseg,function(v,i){
+return {x:ht(i+_1e.index+1)+_13.l,y:dim.height-_13.b-vt(v),data:v};
+},this);
+}else{
+_19=_3.map(_1e.rseg,function(v){
+return {x:ht(v.x)+_13.l,y:dim.height-_13.b-vt(v.y),data:v};
+},this);
+}
+if(_1b&&this.opt.interpolate){
+while(seg<_1d.length){
+seg++;
+_1e=_1d[seg];
+if(_1e){
+_19=_19.concat(_3.map(_1e.rseg,function(v,i){
+return {x:ht(i+_1e.index+1)+_13.l,y:dim.height-_13.b-vt(v),data:v};
+},this));
+}
+}
+}
+var _1f=this.opt.tension?dc.curve(_19,this.opt.tension):"";
+if(this.opt.areas&&_19.length>1){
+var _20=this._plotFill(_18.series.fill,dim,_13),_21=_1.clone(_19);
+if(this.opt.tension){
+var _22="L"+_21[_21.length-1].x+","+(dim.height-_13.b)+" L"+_21[0].x+","+(dim.height-_13.b)+" L"+_21[0].x+","+_21[0].y;
+run.dyn.fill=s.createPath(_1f+" "+_22).setFill(_20).getFill();
+}else{
+_21.push({x:_19[_19.length-1].x,y:dim.height-_13.b});
+_21.push({x:_19[0].x,y:dim.height-_13.b});
+_21.push(_19[0]);
+run.dyn.fill=s.createPolyline(_21).setFill(_20).getFill();
+}
+}
+if(this.opt.lines||this.opt.markers){
+_15=_18.series.stroke;
+if(_18.series.outline){
+_16=run.dyn.outline=dc.makeStroke(_18.series.outline);
+_16.width=2*_16.width+_15.width;
+}
+}
+if(this.opt.markers){
+run.dyn.marker=_18.symbol;
+}
+var _23=null,_24=null,_25=null;
+if(_15&&_18.series.shadow&&_19.length>1){
+var _26=_18.series.shadow,_27=_3.map(_19,function(c){
+return {x:c.x+_26.dx,y:c.y+_26.dy};
+});
+if(this.opt.lines){
+if(this.opt.tension){
+run.dyn.shadow=s.createPath(dc.curve(_27,this.opt.tension)).setStroke(_26).getStroke();
+}else{
+run.dyn.shadow=s.createPolyline(_27).setStroke(_26).getStroke();
+}
+}
+if(this.opt.markers&&_18.marker.shadow){
+_26=_18.marker.shadow;
+_25=_3.map(_27,function(c){
+return this.createPath(run,s,"M"+c.x+" "+c.y+" "+_18.symbol).setStroke(_26).setFill(_26.color);
+},this);
+}
+}
+if(this.opt.lines&&_19.length>1){
+var _28;
+if(_16){
+if(this.opt.tension){
+run.dyn.outline=s.createPath(_1f).setStroke(_16).getStroke();
+}else{
+run.dyn.outline=s.createPolyline(_19).setStroke(_16).getStroke();
+}
+}
+if(this.opt.tension){
+run.dyn.stroke=(_28=s.createPath(_1f)).setStroke(_15).getStroke();
+}else{
+run.dyn.stroke=(_28=s.createPolyline(_19)).setStroke(_15).getStroke();
+}
+if(_28.setFilter&&_18.series.filter){
+_28.setFilter(_18.series.filter);
+}
+}
+var _29=null;
+if(this.opt.markers){
+var _2a=_18;
+_23=new Array(_19.length);
+_24=new Array(_19.length);
+_16=null;
+if(_2a.marker.outline){
+_16=dc.makeStroke(_2a.marker.outline);
+_16.width=2*_16.width+(_2a.marker.stroke?_2a.marker.stroke.width:0);
+}
+_3.forEach(_19,function(c,i){
+if(this.opt.styleFunc||typeof c.data!="number"){
+var _2b=typeof c.data!="number"?[c.data]:[];
+if(this.opt.styleFunc){
+_2b.push(this.opt.styleFunc(c.data));
+}
+_2a=t.addMixin(_18,"marker",_2b,true);
+}else{
+_2a=t.post(_18,"marker");
+}
+var _2c="M"+c.x+" "+c.y+" "+_2a.symbol;
+if(_16){
+_24[i]=this.createPath(run,s,_2c).setStroke(_16);
+}
+_23[i]=this.createPath(run,s,_2c).setStroke(_2a.marker.stroke).setFill(_2a.marker.fill);
+},this);
+run.dyn.markerFill=_2a.marker.fill;
+run.dyn.markerStroke=_2a.marker.stroke;
+if(!_29&&this.opt.labels){
+_29=_23[0].getBoundingBox();
+}
+if(_17){
+_3.forEach(_23,function(s,i){
+var o={element:"marker",index:i+_1e.index,run:run,shape:s,outline:_24[i]||null,shadow:_25&&_25[i]||null,cx:_19[i].x,cy:_19[i].y};
+if(_1b){
+o.x=i+_1e.index+1;
+o.y=run.data[i+_1e.index];
+}else{
+o.x=_1e.rseg[i].x;
+o.y=run.data[i+_1e.index].y;
+}
+this._connectEvents(o);
+_1a[i+_1e.index]=o;
+},this);
+}else{
+delete this._eventSeries[run.name];
+}
+}
+if(this.opt.labels){
+var _2d=_29?_29.width:2;
+var _2e=_29?_29.height:2;
+_3.forEach(_19,function(c,i){
+if(this.opt.styleFunc||typeof c.data!="number"){
+var _2f=typeof c.data!="number"?[c.data]:[];
+if(this.opt.styleFunc){
+_2f.push(this.opt.styleFunc(c.data));
+}
+_2a=t.addMixin(_18,"marker",_2f,true);
+}else{
+_2a=t.post(_18,"marker");
+}
+this.createLabel(s,_1e.rseg[i],{x:c.x-_2d/2,y:c.y-_2e/2,width:_2d,height:_2e},_2a);
+},this);
+}
+}
+run.dirty=false;
+}
+if(_4("dojo-bidi")){
+this._checkOrientation(this.group,dim,_13);
+}
+if(this.animate){
+var _30=this.getGroup();
+fx.animateTransform(_1.delegate({shape:_30,duration:_9,transform:[{name:"translate",start:[0,dim.height-_13.b],end:[0,0]},{name:"scale",start:[1,0],end:[1,1]},{name:"original"}]},this.animate)).play();
+}
+this.dirty=false;
+return this;
+}});
+});