wp/nwyj/.svn/pristine/4b/4be5744f39299a643ec8dcebac69c1d00b6d043d.svn-base

if (!dojo._hasResource["dojox.charting.axis2d.Default"]) { // _hasResource
															// checks added by
															// build. Do not use
															// _hasResource
															// directly in your
															// code.
	dojo._hasResource["dojox.charting.axis2d.Default"] = true;
	dojo.provide("dojox.charting.axis2d.Default");

	dojo.require("dojox.charting.scaler");
	dojo.require("dojox.charting.axis2d.common");
	dojo.require("dojox.charting.axis2d.Base");

	dojo.require("dojo.colors");
	dojo.require("dojox.gfx");
	dojo.require("dojox.lang.functional");
	dojo.require("dojox.lang.utils");

	(function() {
		var dc = dojox.charting, df = dojox.lang.functional, du = dojox.lang.utils, g = dojox.gfx, labelGap = 4, // in
																													// pixels
		labelFudgeFactor = 0.8; // in percents (to convert font's heigth to
								// label width)

		var eq = function(/* Number */a, /* Number */b) {
			// summary: compare two FP numbers for equality
			return Math.abs(a - b) <= 1e-6 * (Math.abs(a) + Math.abs(b)); // Boolean
		};

		dojo.declare("dojox.charting.axis2d.Default",
				dojox.charting.axis2d.Base, {
					defaultParams : {
						vertical : false, // true for vertical axis
						fixUpper : "none", // align the upper on ticks:
											// "major", "minor", "micro", "none"
						fixLower : "none", // align the lower on ticks:
											// "major", "minor", "micro", "none"
						natural : false, // all tick marks should be made on
											// natural numbers
						leftBottom : true, // position of the axis, used with
											// "vertical"
						includeZero : false, // 0 should be included
						fixed : true, // all labels are fixed numbers
						majorLabels : true, // draw major labels
						minorTicks : true, // draw minor ticks
						minorLabels : true, // draw minor labels
						microTicks : false, // draw micro ticks
						htmlLabels : true
						// use HTML to draw labels
					},
					optionalParams : {
						"min" : 0, // minimal value on this axis
						"max" : 1, // maximal value on this axis
						"majorTickStep" : 4, // major tick step
						"minorTickStep" : 2, // minor tick step
						"microTickStep" : 1, // micro tick step
						"labels" : [], // array of labels for major ticks
						// with corresponding numeric values
						// ordered by values
						// theme components
						"stroke" : {}, // stroke for an axis
						"majorTick" : {}, // stroke + length for a tick
						"minorTick" : {}, // stroke + length for a tick
						"font" : "", // font for labels
						"fontColor" : "" // color for labels as a string
					},

					constructor : function(chart, kwArgs) {
						this.opt = dojo.clone(this.defaultParams);
						du.updateWithObject(this.opt, kwArgs);
						du.updateWithPattern(this.opt, kwArgs,
								this.optionalParams);
					},
					dependOnData : function() {
						return !("min" in this.opt) || !("max" in this.opt);
					},
					clear : function() {
						delete this.scaler;
						this.dirty = true;
						return this;
					},
					initialized : function() {
						return "scaler" in this;
					},
					calculate : function(min, max, span, labels) {
						if (this.initialized()) {
							return this;
						}
						this.labels = "labels" in this.opt
								? this.opt.labels
								: labels;
						if ("min" in this.opt) {
							min = this.opt.min;
						}
						if ("max" in this.opt) {
							max = this.opt.max;
						}
						if (this.opt.includeZero) {
							if (min > 0) {
								min = 0;
							}
							if (max < 0) {
								max = 0;
							}
						}
						var minMinorStep = 0, ta = this.chart.theme.axis, taFont = "font" in this.opt
								? this.opt.font
								: ta.font, size = taFont ? g.normalizedLength(g
								.splitFontString(taFont).size) : 0;
						if (this.vertical) {
							if (size) {
								minMinorStep = size + labelGap;
							}
						} else {
							if (size) {
								var labelLength = Math.ceil(Math.log(Math.max(
										Math.abs(min), Math.abs(max)))
										/ Math.LN10);
								if (min < 0 || max < 0) {
									++labelLength;
								}
								var precision = Math.floor(Math.log(max - min)
										/ Math.LN10);
								if (precision > 0) {
									labelLength += precision;
								}
								if (this.labels) {
									labelLength = df.foldl(df.map(this.labels,
													"x.text.length"),
											"Math.max(a, b)", labelLength);
								}
								minMinorStep = Math.floor(size * labelLength
										* labelFudgeFactor)
										+ labelGap;
							}
						}
						var kwArgs = {
							fixUpper : this.opt.fixUpper,
							fixLower : this.opt.fixLower,
							natural : this.opt.natural
						};
						if ("majorTickStep" in this.opt) {
							kwArgs.majorTick = this.opt.majorTickStep;
						}
						if ("minorTickStep" in this.opt) {
							kwArgs.minorTick = this.opt.minorTickStep;
						}
						if ("microTickStep" in this.opt) {
							kwArgs.microTick = this.opt.microTickStep;
						}
						this.scaler = dojox.charting.scaler(min, max, span,
								kwArgs);
						this.scaler.minMinorStep = minMinorStep;
						return this;
					},
					getScaler : function() {
						return this.scaler;
					},
					getOffsets : function() {
						var offsets = {
							l : 0,
							r : 0,
							t : 0,
							b : 0
						};
						var offset = 0, ta = this.chart.theme.axis, taFont = "font" in this.opt
								? this.opt.font
								: ta.font, taMajorTick = "majorTick" in this.opt
								? this.opt.majorTick
								: ta.majorTick, taMinorTick = "minorTick" in this.opt
								? this.opt.minorTick
								: ta.minorTick, size = taFont
								? g
										.normalizedLength(g
												.splitFontString(taFont).size)
								: 0;
						if (this.vertical) {
							if (size) {
								var s = this.scaler, a = this._getLabel(
										s.major.start, s.major.prec).length, b = this
										._getLabel(s.major.start
														+ s.major.count
														* s.major.tick,
												s.major.prec).length, c = this
										._getLabel(s.minor.start, s.minor.prec).length, d = this
										._getLabel(s.minor.start
														+ s.minor.count
														* s.minor.tick,
												s.minor.prec).length, labelLength = Math
										.max(a, b, c, d);
								if (this.labels) {
									labelLength = df.foldl(df.map(this.labels,
													"x.text.length"),
											"Math.max(a, b)", labelLength);
								}
								offset = Math.floor(size * labelLength
										* labelFudgeFactor)
										+ labelGap;
							}
							offset += labelGap
									+ Math.max(taMajorTick.length,
											taMinorTick.length);
							offsets[this.opt.leftBottom ? "l" : "r"] = offset;
							offsets.t = offsets.b = size / 2;
						} else {
							if (size) {
								offset = size + labelGap;
							}
							offset += labelGap
									+ Math.max(taMajorTick.length,
											taMinorTick.length);
							offsets[this.opt.leftBottom ? "b" : "t"] = offset;
							if (size) {
								var s = this.scaler, a = this._getLabel(
										s.major.start, s.major.prec).length, b = this
										._getLabel(s.major.start
														+ s.major.count
														* s.major.tick,
												s.major.prec).length, c = this
										._getLabel(s.minor.start, s.minor.prec).length, d = this
										._getLabel(s.minor.start
														+ s.minor.count
														* s.minor.tick,
												s.minor.prec).length, labelLength = Math
										.max(a, b, c, d);
								if (this.labels) {
									labelLength = df.foldl(df.map(this.labels,
													"x.text.length"),
											"Math.max(a, b)", labelLength);
								}
								offsets.l = offsets.r = Math.floor(size
										* labelLength * labelFudgeFactor)
										/ 2;
							}
						}
						return offsets;
					},
					render : function(dim, offsets) {
						if (!this.dirty) {
							return this;
						}
						// prepare variable
						var start, stop, axisVector, tickVector, labelOffset, labelAlign, ta = this.chart.theme.axis, taStroke = "stroke" in this.opt
								? this.opt.stroke
								: ta.stroke, taMajorTick = "majorTick" in this.opt
								? this.opt.majorTick
								: ta.majorTick, taMinorTick = "minorTick" in this.opt
								? this.opt.minorTick
								: ta.minorTick, taFont = "font" in this.opt
								? this.opt.font
								: ta.font, taFontColor = "fontColor" in this.opt
								? this.opt.fontColor
								: ta.fontColor, tickSize = Math.max(
								taMajorTick.length, taMinorTick.length), size = taFont
								? g
										.normalizedLength(g
												.splitFontString(taFont).size)
								: 0;
						if (this.vertical) {
							start = {
								y : dim.height - offsets.b
							};
							stop = {
								y : offsets.t
							};
							axisVector = {
								x : 0,
								y : -1
							};
							if (this.opt.leftBottom) {
								start.x = stop.x = offsets.l;
								tickVector = {
									x : -1,
									y : 0
								};
								labelAlign = "end";
							} else {
								start.x = stop.x = dim.width - offsets.r;
								tickVector = {
									x : 1,
									y : 0
								};
								labelAlign = "start";
							}
							labelOffset = {
								x : tickVector.x * (tickSize + labelGap),
								y : size * 0.4
							};
						} else {
							start = {
								x : offsets.l
							};
							stop = {
								x : dim.width - offsets.r
							};
							axisVector = {
								x : 1,
								y : 0
							};
							labelAlign = "middle";
							if (this.opt.leftBottom) {
								start.y = stop.y = dim.height - offsets.b;
								tickVector = {
									x : 0,
									y : 1
								};
								labelOffset = {
									y : tickSize + labelGap + size
								};
							} else {
								start.y = stop.y = offsets.t;
								tickVector = {
									x : 0,
									y : -1
								};
								labelOffset = {
									y : -tickSize - labelGap
								};
							}
							labelOffset.x = 0;
						}

						// render shapes
						this.cleanGroup();
						var s = this.group, c = this.scaler, step, next, nextMajor = c.major.start, nextMinor = c.minor.start, nextMicro = c.micro.start;
						s.createLine({
									x1 : start.x,
									y1 : start.y,
									x2 : stop.x,
									y2 : stop.y
								}).setStroke(taStroke);
						if (this.opt.microTicks && c.micro.tick) {
							step = c.micro.tick, next = nextMicro;
						} else if (this.opt.minorTicks && c.minor.tick) {
							step = c.minor.tick, next = nextMinor;
						} else if (c.major.tick) {
							step = c.major.tick, next = nextMajor;
						} else {
							// don't draw anything
							return this;
						}
						while (next <= c.bounds.upper + 1 / c.scale) {
							var offset = (next - c.bounds.lower) * c.scale, x = start.x
									+ axisVector.x * offset, y = start.y
									+ axisVector.y * offset;
							if (Math.abs(nextMajor - next) < step / 2) {
								// major tick
								s.createLine({
											x1 : x,
											y1 : y,
											x2 : x + tickVector.x
													* taMajorTick.length,
											y2 : y + tickVector.y
													* taMajorTick.length
										}).setStroke(taMajorTick);
								if (this.opt.majorLabels) {
									var elem = dc.axis2d.common.createText[this.opt.htmlLabels
											? "html"
											: "gfx"](this.chart, s, x
													+ labelOffset.x, y
													+ labelOffset.y,
											labelAlign, this._getLabel(
													nextMajor, c.major.prec),
											taFont, taFontColor);
									if (this.opt.htmlLabels) {
										this.htmlElements.push(elem);
									}
								}
								nextMajor += c.major.tick;
								nextMinor += c.minor.tick;
								nextMicro += c.micro.tick;
							} else if (Math.abs(nextMinor - next) < step / 2) {
								// minor tick
								if (this.opt.minorTicks) {
									s.createLine({
										x1 : x,
										y1 : y,
										x2 : x + tickVector.x
												* taMinorTick.length,
										y2 : y + tickVector.y
												* taMinorTick.length
									}).setStroke(taMinorTick);
									if (this.opt.minorLabels
											&& (c.minMinorStep <= c.minor.tick
													* c.scale)) {
										var elem = dc.axis2d.common.createText[this.opt.htmlLabels
												? "html"
												: "gfx"](this.chart, s, x
														+ labelOffset.x, y
														+ labelOffset.y,
												labelAlign, this
														._getLabel(nextMinor,
																c.minor.prec),
												taFont, taFontColor);
										if (this.opt.htmlLabels) {
											this.htmlElements.push(elem);
										}
									}
								}
								nextMinor += c.minor.tick;
								nextMicro += c.micro.tick;
							} else {
								// micro tick
								if (this.opt.microTicks) {
									s.createLine({
										x1 : x,
										y1 : y,
										// use minor ticks for now
										x2 : x + tickVector.x
												* taMinorTick.length,
										y2 : y + tickVector.y
												* taMinorTick.length
									}).setStroke(taMinorTick);
								}
								nextMicro += c.micro.tick;
							}
							next += step;
						}
						this.dirty = false;
						return this;
					},

					// utilities
					_getLabel : function(number, precision) {
						if (this.opt.labels) {
							// classic binary search
							var l = this.opt.labels, lo = 0, hi = l.length;
							while (lo < hi) {
								var mid = Math.floor((lo + hi) / 2), val = l[mid].value;
								if (val < number) {
									lo = mid + 1;
								} else {
									hi = mid;
								}
							}
							// lets take into account FP errors
							if (lo < l.length && eq(l[lo].value, number)) {
								return l[lo].text;
							}
							--lo;
							if (lo < l.length && eq(l[lo].value, number)) {
								return l[lo].text;
							}
							lo += 2;
							if (lo < l.length && eq(l[lo].value, number)) {
								return l[lo].text;
							}
							// otherwise we will produce a number
						}
						return this.opt.fixed ? number.toFixed(precision < 0
								? -precision
								: 0) : number.toString();
					}
				});
	})();

}