Initial commit of intern.ccwn.org contentsHEADmaster

1 files changed, 371 insertions, 0 deletions

diff --git a/js/dojo-1.7.2/dojox/charting/action2d/_IndicatorElement.js b/js/dojo-1.7.2/dojox/charting/action2d/_IndicatorElement.js
new file mode 100644
index 0000000..ab71c63
--- /dev/null
+++ b/js/dojo-1.7.2/dojox/charting/action2d/_IndicatorElement.js
@@ -0,0 +1,371 @@
+//>>built
+define("dojox/charting/action2d/_IndicatorElement", ["dojo/_base/lang", "dojo/_base/declare", "../Element", "../plot2d/common", 
+    "../axis2d/common", "dojox/gfx"], 
+	function(lang, declare, Element, dcpc, dcac, gfx){ 
+
+	// all the code below should be removed when http://trac.dojotoolkit.org/ticket/11299 will be available
+	var getBoundingBox = function(shape){
+		return getTextBBox(shape, shape.getShape().text);
+	};
+	var getTextBBox = function(s, t){
+		var c = s.declaredClass;
+		if (c.indexOf("svg")!=-1){
+			// try/catch the FF native getBBox error. cheaper than walking up in the DOM
+			// hierarchy to check the conditions (bench show /10 )
+			try {
+				return lang.mixin({}, s.rawNode.getBBox());
+			}catch (e){
+				return null;
+			}
+		}else if(c.indexOf("vml")!=-1){
+			var rawNode = s.rawNode, _display = rawNode.style.display;
+			rawNode.style.display = "inline";
+			var w = gfx.pt2px(parseFloat(rawNode.currentStyle.width));
+			var h = gfx.pt2px(parseFloat(rawNode.currentStyle.height));
+			var sz = {x: 0, y: 0, width: w, height: h};
+			// in VML, the width/height we get are in view coordinates
+			// in our case we don't zoom the view so that is ok
+			// It's impossible to get the x/y from the currentStyle.left/top,
+			// because all negative coordinates are 'clipped' to 0.
+			// (x:0 + translate(-100) -> x=0
+			computeLocation(s, sz);
+			rawNode.style.display = _display;
+			return sz;
+		}else if(c.indexOf("silverlight")!=-1){
+			var bb = {width: s.rawNode.actualWidth, height: s.rawNode.actualHeight};
+			return computeLocation(s, bb, 0.75);
+		}else if(s.getTextWidth){
+			// canvas
+			var w = s.getTextWidth();
+			var font = s.getFont();
+			var fz = font ? font.size : gfx.defaultFont.size;
+			var h = gfx.normalizedLength(fz);
+			sz = {width: w, height: h};
+			computeLocation(s, sz, 0.75);
+			return sz;
+		}
+	};
+	var computeLocation =  function(s, sz, coef){
+		var width = sz.width, height = sz.height, sh = s.getShape(), align = sh.align;
+		switch (align) {
+		case "end":
+			sz.x = sh.x - width;
+			break;
+		case "middle":
+			sz.x = sh.x - width / 2;
+			break;
+		case "start":
+		default:
+			sz.x = sh.x;
+		break;
+		}
+		coef = coef || 1;
+		sz.y = sh.y - height*coef; // rough approximation of the ascent!...
+		return sz;
+	};
+
+	return declare("dojox.charting.action2d._IndicatorElement",[Element], {
+		//	summary:
+		//		Internal element used by indicator actions.
+		//	tags:
+		//		private
+		constructor: function(chart, kwArgs){
+			if(!kwArgs){ kwArgs = {}; }
+			this.inter = kwArgs.inter;
+		},
+		_updateVisibility: function(cp, limit, attr){
+			var axis = attr=="x"?this.inter.plot._hAxis:this.inter.plot._vAxis;
+			var scale = axis.getWindowScale();
+			this.chart.setAxisWindow(axis.name, scale, axis.getWindowOffset() + (cp[attr] - limit[attr]) / scale);
+			this._noDirty = true;
+			this.chart.render();
+			this._noDirty = false;
+			if(!this._tracker){
+				this.initTrack();
+			}
+		},
+		_trackMove: function(){
+			// let's update the selector
+			this._updateIndicator(this.pageCoord);            
+			// if we reached that point once, then we don't stop until mouse up
+			if(this._initTrackPhase){
+				this._initTrackPhase = false;
+				this._tracker = setInterval(lang.hitch(this, this._trackMove), 100);
+			}
+		},
+		initTrack: function(){
+			this._initTrackPhase = true;
+			this._tracker = setTimeout(lang.hitch(this, this._trackMove), 500);
+		},
+		stopTrack: function(){
+			if(this._tracker){
+				if(this._initTrackPhase){
+					clearTimeout(this._tracker);					
+				}else{
+					clearInterval(this._tracker);
+				}
+				this._tracker = null;
+			}
+		},
+		render: function(){
+			if(!this.isDirty()){
+				return;
+			}
+
+			this.cleanGroup();
+
+			if (!this.pageCoord){
+				return;
+			}
+			
+			this._updateIndicator(this.pageCoord, this.secondCoord);
+		},
+		_updateIndicator: function(cp1, cp2){
+			var inter = this.inter, plot = inter.plot, v = inter.opt.vertical;
+			var hAxis = this.chart.getAxis(plot.hAxis), vAxis = this.chart.getAxis(plot.vAxis);
+			var hn = hAxis.name, vn = vAxis.name, hb = hAxis.getScaler().bounds, vb = vAxis.getScaler().bounds;
+			var attr = v?"x":"y", n = v?hn:vn, bounds = v?hb:vb;
+			
+			// sort data point
+			if(cp2){
+				var tmp;
+				if(v){
+					if(cp1.x>cp2.x){
+						tmp = cp2;
+						cp2 = cp1;
+						cp1 = tmp;
+					}
+				}else{
+					if(cp1.y>cp2.y){
+						tmp = cp2;
+						cp2 = cp1;
+						cp1 = tmp;
+					}		
+				}
+			}
+
+			var cd1 = plot.toData(cp1), cd2;
+			if(cp2){
+				cd2 = plot.toData(cp2);
+			}
+			
+			var o = {};
+			o[hn] = hb.from;
+			o[vn] = vb.from;
+			var min = plot.toPage(o);
+			o[hn] = hb.to;
+			o[vn] = vb.to;
+			var max = plot.toPage(o);
+			
+			if(cd1[n] < bounds.from){
+				// do not autoscroll if dual indicator
+				if(!cd2 && inter.opt.autoScroll){
+					this._updateVisibility(cp1, min, attr);
+					return;
+				}else{
+					cp1[attr] = min[attr];
+				}
+				// cp1 might have changed, let's update cd1
+				cd1 = plot.toData(cp1);
+			}else if(cd1[n] > bounds.to){
+				if(!cd2 && inter.opt.autoScroll){
+					this._updateVisibility(cp1, max, attr);
+					return;
+				}else{
+					cp1[attr] = max[attr];
+				}
+				// cp1 might have changed, let's update cd1
+				cd1 = plot.toData(cp1);
+			}	
+			
+			var c1 = this._getData(cd1, attr, v), c2;
+
+			if(c1.y == null){
+				// we have no data for that point let's just return
+				return;
+			}
+
+			if(cp2){
+				if(cd2[n] < bounds.from){
+					cp2[attr] = min[attr];
+					cd2 = plot.toData(cp2);
+				}else if(cd2[n] > bounds.to){
+					cp2[attr] = max[attr];
+					cd2 = plot.toData(cp2);	
+				}
+				c2 = this._getData(cd2, attr, v);
+				if(c2.y == null){
+					// we have no data for that point let's pretend we have a single touch point
+					cp2 = null;
+				}
+			}
+			
+			var t1 = this._renderIndicator(c1, cp2?1:0, hn, vn, min, max);
+			if(cp2){
+				var t2 = this._renderIndicator(c2, 2, hn, vn, min, max);
+				var delta = v?c2.y-c1.y:c2.x-c1.y;
+				var text = inter.opt.labelFunc?inter.opt.labelFunc(c1, c2, inter.opt.fixed, inter.opt.precision):
+					(dcpc.getLabel(delta, inter.opt.fixed, inter.opt.precision)+" ("+dcpc.getLabel(100*delta/(v?c1.y:c1.x), true, 2)+"%)");
+				this._renderText(text, inter, this.chart.theme, v?(t1.x+t2.x)/2:t1.x, v?t1.y:(t1.y+t2.y)/2, c1, c2);
+			};
+			
+		},
+		_renderIndicator: function(coord, index, hn, vn, min, max){
+			var t = this.chart.theme, c = this.chart.getCoords(), inter = this.inter, plot = inter.plot, v = inter.opt.vertical;
+			
+			var mark = {};
+			mark[hn] = coord.x;
+			mark[vn] = coord.y;
+			mark = plot.toPage(mark);
+
+			var cx = mark.x - c.x, cy = mark.y - c.y;
+			var x1 = v?cx:min.x - c.x, y1 = v?min.y - c.y:cy, x2 = v?x1:max.x - c.x, y2 = v?max.y - c.y:y1;
+			var sh = inter.opt.lineShadow?inter.opt.lineShadow:t.indicator.lineShadow,
+					ls = inter.opt.lineStroke?inter.opt.lineStroke:t.indicator.lineStroke,
+							ol = inter.opt.lineOutline?inter.opt.lineOutline:t.indicator.lineOutline;
+			if(sh){
+				this.group.createLine({x1: x1 + sh.dx, y1: y1 + sh.dy, x2: x2 + sh.dx, y2: y2 + sh.dy}).setStroke(sh);
+			}
+			if(ol){
+				ol = dcpc.makeStroke(ol);
+				ol.width = 2 * ol.width + ls.width;
+				this.group.createLine({x1: x1, y1: y1, x2: x2, y2: y2}).setStroke(ol);
+			}
+			this.group.createLine({x1: x1, y1: y1, x2: x2, y2: y2}).setStroke(ls);
+
+			var ms = inter.opt.markerSymbol?inter.opt.markerSymbol:t.indicator.markerSymbol,
+					path = "M" + cx + " " + cy + " " + ms;
+			sh = inter.opt.markerShadow?inter.opt.markerShadow:t.indicator.markerShadow;
+			ls = inter.opt.markerStroke?inter.opt.markerStroke:t.indicator.markerStroke;
+			ol = inter.opt.markerOutline?inter.opt.markerOutline:t.indicator.markerOutline;
+			if(sh){
+				var sp = "M" + (cx + sh.dx) + " " + (cy + sh.dy) + " " + ms;
+				this.group.createPath(sp).setFill(sh.color).setStroke(sh);
+			}
+			if(ol){
+				ol = dcpc.makeStroke(ol);
+				ol.width = 2 * ol.width + ls.width;
+				this.group.createPath(path).setStroke(ol);
+			}
+
+			var shape = this.group.createPath(path);
+			var sf = this._shapeFill(inter.opt.markerFill?inter.opt.markerFill:t.indicator.markerFill, shape.getBoundingBox());
+			shape.setFill(sf).setStroke(ls);
+
+			if(index==0){
+				var text = inter.opt.labelFunc?inter.opt.labelFunc(coord, null, inter.opt.fixed, inter.opt.precision):
+					dcpc.getLabel(v?coord.y:coord.x, inter.opt.fixed, inter.opt.precision);
+				this._renderText(text, inter, t, v?x1:x2+5, v?y2+5:y1, coord);
+			}else{
+				return v?{x: x1, y: y2+5}:{x: x2+5, y: y1};
+			}
+			
+		},
+		_renderText: function(text, inter, t, x, y, c1, c2){
+			var label = dcac.createText.gfx(
+					this.chart,
+					this.group,
+					x, y,
+					"middle",
+					text, inter.opt.font?inter.opt.font:t.indicator.font, inter.opt.fontColor?inter.opt.fontColor:t.indicator.fontColor);
+			var b = getBoundingBox(label);
+			b.x-=2; b.y-=1; b.width+=4; b.height+=2; b.r = inter.opt.radius?inter.opt.radius:t.indicator.radius;
+			sh = inter.opt.shadow?inter.opt.shadow:t.indicator.shadow;
+			ls = inter.opt.stroke?inter.opt.stroke:t.indicator.stroke;
+			ol = inter.opt.outline?inter.opt.outline:t.indicator.outline;
+			if(sh){
+				this.group.createRect(b).setFill(sh.color).setStroke(sh);
+			}
+			if(ol){
+				ol = dcpc.makeStroke(ol);
+				ol.width = 2 * ol.width + ls.width;
+				this.group.createRect(b).setStroke(ol);
+			}
+			var f = inter.opt.fillFunc?inter.opt.fillFunc(c1, c2):(inter.opt.fill?inter.opt.fill:t.indicator.fill);
+			this.group.createRect(b).setFill(this._shapeFill(f, b)).setStroke(ls);
+			label.moveToFront();
+		},
+		_getData: function(cd, attr, v){
+			// we need to find which actual data point is "close" to the data value
+			var data = this.chart.getSeries(this.inter.opt.series).data;
+			// let's consider data are sorted because anyway rendering will be "weird" with unsorted data
+			// i is an index in the array, which is different from a x-axis value even for index based data
+			var i, r, l = data.length;
+			for (i = 0; i < l; ++i){
+				r = data[i];
+				if(r == null){
+					// move to next item
+				}else if(typeof r == "number"){
+					if(i + 1 > cd[attr]){
+						break;
+					}
+				}else if(r[attr] > cd[attr]){
+					break;
+				}
+			}
+			var x,y,px,py;
+			if(typeof r == "number"){
+				x = i+1;
+				y = r;
+				if(i>0){
+					px = i;
+					py = data[i-1];
+				}
+			}else{
+				x = r.x;
+				y = r.y;
+				if(i>0){
+					px = data[i-1].x;
+					py = data[i-1].y;
+				}
+			}
+			if(i>0){
+				var m = v?(x+px)/2:(y+py)/2;
+				if(cd[attr]<=m){
+					x = px;
+					y = py;
+				}
+			}
+			return {x: x, y: y};
+		},
+		cleanGroup: function(creator){
+			//	summary:
+			//		Clean any elements (HTML or GFX-based) out of our group, and create a new one.
+			//	creator: dojox.gfx.Surface?
+			//		An optional surface to work with.
+			//	returns: dojox.charting.Element
+			//		A reference to this object for functional chaining.
+			this.inherited(arguments);
+			// we always want to be above regular plots and not clipped
+			this.group.moveToFront();
+			return this;	//	dojox.charting.Element
+		},
+		clear: function(){
+			//	summary:
+			//		Clear out any parameters set on this plot.
+			//	returns: dojox.charting.action2d._IndicatorElement
+			//		The reference to this plot for functional chaining.
+			this.dirty = true;
+			return this;	//	dojox.charting.plot2d._IndicatorElement
+		},
+		getSeriesStats: function(){
+			//	summary:
+			//		Returns default stats (irrelevant for this type of plot).
+			//	returns: Object
+			//		{hmin, hmax, vmin, vmax} min/max in both directions.
+			return lang.delegate(dcpc.defaultStats);
+		},
+		initializeScalers: function(){
+			//	summary:
+			//		Does nothing (irrelevant for this type of plot).
+			return this;
+		},
+		isDirty: function(){
+			//	summary:
+			//		Return whether or not this plot needs to be redrawn.
+			//	returns: Boolean
+			//		If this plot needs to be rendered, this will return true.
+			return !this._noDirty && (this.dirty || this.inter.plot.isDirty());
+		}
+	});
+});