comt: comparison src/cm/media/js/lib/yui/yui3-3.15.0/build/axis-numeric-base/axis-numeric-base.js

Mercurial Mercurial > comt / comparison

summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help

src/cm/media/js/lib/yui/yui3-3.15.0/build/axis-numeric-base/axis-numeric-base.js

changeset 602

e16a97fb364a

equal deleted inserted replaced

-:d334a616c023
+:e16a97fb364a
+YUI.add('axis-numeric-base', function (Y, NAME) {
+/**
+* Provides functionality for the handling of numeric axis data for a chart.
+*
+* @module charts
+* @submodule axis-numeric-base
+*/
+var Y_Lang = Y.Lang;
+/**
+* NumericImpl contains logic for numeric data. NumericImpl is used by the following classes:
+* <ul>
+*      <li>{{#crossLink "NumericAxisBase"}}{{/crossLink}}</li>
+*      <li>{{#crossLink "NumericAxis"}}{{/crossLink}}</li>
+*  </ul>
+*
+* @class NumericImpl
+* @constructor
+* @submodule axis-numeric-base
+*/
+function NumericImpl()
+{
+}
+NumericImpl.NAME = "numericImpl";
+NumericImpl.ATTRS = {
+/**
+* Indicates whether 0 should always be displayed.
+*
+* @attribute alwaysShowZero
+* @type Boolean
+*/
+alwaysShowZero: {
+value: true
+},
+/**
+* Method used for formatting a label. This attribute allows for the default label formatting method to overridden.
+* The method use would need to implement the arguments below and return a `String` or an `HTMLElement`. The default
+* implementation of the method returns a `String`. The output of this method will be rendered to the DOM using
+* `appendChild`. If you override the `labelFunction` method and return an html string, you will also need to override
+* the Data' `appendLabelFunction` to accept html as a `String`.
+* <dl>
+*      <dt>val</dt><dd>Label to be formatted. (`String`)</dd>
+*      <dt>format</dt><dd>Object containing properties used to format the label. (optional)</dd>
+* </dl>
+*
+* @attribute labelFunction
+* @type Function
+*/
+/**
+* Object containing properties used by the `labelFunction` to format a
+* label.
+*
+* @attribute labelFormat
+* @type Object
+*/
+labelFormat: {
+value: {
+prefix: "",
+thousandsSeparator: "",
+decimalSeparator: "",
+decimalPlaces: "0",
+suffix: ""
+}
+},
+/**
+*Indicates how to round unit values.
+*  <dl>
+*      <dt>niceNumber</dt><dd>Units will be smoothed based on the number of ticks and data range.</dd>
+*      <dt>auto</dt><dd>If the range is greater than 1, the units will be rounded.</dd>
+*      <dt>numeric value</dt><dd>Units will be equal to the numeric value.</dd>
+*      <dt>null</dt><dd>No rounding will occur.</dd>
+*  </dl>
+*
+* @attribute roundingMethod
+* @type String
+* @default niceNumber
+*/
+roundingMethod: {
+value: "niceNumber"
+},
+/**
+* Indicates the scaling for the chart. The default value is `linear`. For a logarithmic axis, set the value
+* to `logarithmic`.
+*
+* @attribute
+* @type String
+* @default linear
+*/
+scaleType: {
+value: "linear"
+}
+};
+NumericImpl.prototype = {
+/**
+* @method initializer
+* @private
+*/
+initializer: function() {
+this.after("alwaysShowZeroChange", this._keyChangeHandler);
+this.after("roundingMethodChange", this._keyChangeHandler);
+this.after("scaleTypeChange", this._keyChangeHandler);
+},
+/**
+* Formats a label based on the axis type and optionally specified format.
+*
+* @method
+* @param {Object} value
+* @param {Object} format Pattern used to format the value.
+* @return String
+*/
+formatLabel: function(val, format)
+{
+if(format)
+{
+return Y.DataType.Number.format(val, format);
+}
+return val;
+},
+/**
+* Returns the sum of all values per key.
+*
+* @method getTotalByKey
+* @param {String} key The identifier for the array whose values will be calculated.
+* @return Number
+*/
+getTotalByKey: function(key)
+{
+var total = 0,
+values = this.getDataByKey(key),
+i = 0,
+val,
+len = values ? values.length : 0;
+for(; i < len; ++i)
+{
+val = parseFloat(values[i]);
+if(!isNaN(val))
+{
+total += val;
+}
+}
+return total;
+},
+/**
+* Returns the value corresponding to the origin on the axis.
+*
+* @method getOrigin
+* @return Number
+*/
+getOrigin: function() {
+var origin = 0,
+min = this.get("minimum"),
+max = this.get("maximum");
+origin = Math.max(origin, min);
+origin = Math.min(origin, max);
+return origin;
+},
+/**
+* Type of data used in `Data`.
+*
+* @property _type
+* @readOnly
+* @private
+*/
+_type: "numeric",
+/**
+* Helper method for getting a `roundingUnit` when calculating the minimum and maximum values.
+*
+* @method _getMinimumUnit
+* @param {Number} max Maximum number
+* @param {Number} min Minimum number
+* @param {Number} units Number of units on the axis
+* @return Number
+* @private
+*/
+_getMinimumUnit:function(max, min, units)
+{
+return this._getNiceNumber(Math.ceil((max - min)/units));
+},
+/**
+* Calculates a nice rounding unit based on the range.
+*
+* @method _getNiceNumber
+* @param {Number} roundingUnit The calculated rounding unit.
+* @return Number
+* @private
+*/
+_getNiceNumber: function(roundingUnit)
+{
+var tempMajorUnit = roundingUnit,
+order = Math.ceil(Math.log(tempMajorUnit) * 0.4342944819032518),
+roundedMajorUnit = Math.pow(10, order),
+roundedDiff;
+if (roundedMajorUnit / 2 >= tempMajorUnit)
+{
+roundedDiff = Math.floor((roundedMajorUnit / 2 - tempMajorUnit) / (Math.pow(10,order-1)/2));
+tempMajorUnit = roundedMajorUnit/2 - roundedDiff*Math.pow(10,order-1)/2;
+}
+else
+{
+tempMajorUnit = roundedMajorUnit;
+}
+if(!isNaN(tempMajorUnit))
+{
+return tempMajorUnit;
+}
+return roundingUnit;
+},
+/**
+* Calculates the maximum and minimum values for the `Data`.
+*
+* @method _updateMinAndMax
+* @private
+*/
+_updateMinAndMax: function()
+{
+var data = this.get("data"),
+max,
+min,
+len,
+num,
+i = 0,
+setMax = this.get("setMax"),
+setMin = this.get("setMin");
+if(!setMax || !setMin)
+{
+if(data && data.length && data.length > 0)
+{
+len = data.length;
+for(; i < len; i++)
+{
+num = data[i];
+if(isNaN(num))
+{
+max = setMax ? this._setMaximum : max;
+min = setMin ? this._setMinimum : min;
+continue;
+}
+if(setMin)
+{
+min = this._setMinimum;
+}
+else if(min === undefined)
+{
+min = num;
+}
+else
+{
+min = Math.min(num, min);
+}
+if(setMax)
+{
+max = this._setMaximum;
+}
+else if(max === undefined)
+{
+max = num;
+}
+else
+{
+max = Math.max(num, max);
+}
+this._actualMaximum = max;
+this._actualMinimum = min;
+}
+}
+if(this.get("scaleType") !== "logarithmic")
+{
+this._roundMinAndMax(min, max, setMin, setMax);
+}
+else
+{
+this._dataMaximum = max;
+this._dataMinimum = min;
+}
+}
+},
+/**
+* Rounds the mimimum and maximum values based on the `roundingUnit` attribute.
+*
+* @method _roundMinAndMax
+* @param {Number} min Minimum value
+* @param {Number} max Maximum value
+* @private
+*/
+_roundMinAndMax: function(min, max, setMin, setMax)
+{
+var roundingUnit,
+minimumRange,
+minGreaterThanZero = min >= 0,
+maxGreaterThanZero = max > 0,
+dataRangeGreater,
+maxRound,
+minRound,
+topTicks,
+botTicks,
+tempMax,
+tempMin,
+units = this.getTotalMajorUnits() - 1,
+alwaysShowZero = this.get("alwaysShowZero"),
+roundingMethod = this.get("roundingMethod"),
+useIntegers = (max - min)/units >= 1;
+if(roundingMethod)
+{
+if(roundingMethod === "niceNumber")
+{
+roundingUnit = this._getMinimumUnit(max, min, units);
+if(minGreaterThanZero && maxGreaterThanZero)
+{
+if((alwaysShowZero || min < roundingUnit) && !setMin)
+{
+min = 0;
+roundingUnit = this._getMinimumUnit(max, min, units);
+}
+else
+{
+min = this._roundDownToNearest(min, roundingUnit);
+}
+if(setMax)
+{
+if(!alwaysShowZero)
+{
+min = max - (roundingUnit * units);
+}
+}
+else if(setMin)
+{
+max = min + (roundingUnit * units);
+}
+else
+{
+max = this._roundUpToNearest(max, roundingUnit);
+}
+}
+else if(maxGreaterThanZero && !minGreaterThanZero)
+{
+if(alwaysShowZero)
+{
+topTicks = Math.round(units/((-1 * min)/max + 1));
+topTicks = Math.max(Math.min(topTicks, units - 1), 1);
+botTicks = units - topTicks;
+tempMax = Math.ceil( max/topTicks );
+tempMin = Math.floor( min/botTicks ) * -1;
+if(setMin)
+{
+while(tempMin < tempMax && botTicks >= 0)
+{
+botTicks--;
+topTicks++;
+tempMax = Math.ceil( max/topTicks );
+tempMin = Math.floor( min/botTicks ) * -1;
+}
+//if there are any bottom ticks left calcualate the maximum by multiplying by the tempMin value
+//if not, it's impossible to ensure that a zero is shown. skip it
+if(botTicks > 0)
+{
+max = tempMin * topTicks;
+}
+else
+{
+max = min + (roundingUnit * units);
+}
+}
+else if(setMax)
+{
+while(tempMax < tempMin && topTicks >= 0)
+{
+botTicks++;
+topTicks--;
+tempMin = Math.floor( min/botTicks ) * -1;
+tempMax = Math.ceil( max/topTicks );
+}
+//if there are any top ticks left calcualate the minimum by multiplying by the tempMax value
+//if not, it's impossible to ensure that a zero is shown. skip it
+if(topTicks > 0)
+{
+min = tempMax * botTicks * -1;
+}
+else
+{
+min = max - (roundingUnit * units);
+}
+}
+else
+{
+roundingUnit = Math.max(tempMax, tempMin);
+roundingUnit = this._getNiceNumber(roundingUnit);
+max = roundingUnit * topTicks;
+min = roundingUnit * botTicks * -1;
+}
+}
+else
+{
+if(setMax)
+{
+min = max - (roundingUnit * units);
+}
+else if(setMin)
+{
+max = min + (roundingUnit * units);
+}
+else
+{
+min = this._roundDownToNearest(min, roundingUnit);
+max = this._roundUpToNearest(max, roundingUnit);
+}
+}
+}
+else
+{
+if(setMin)
+{
+if(alwaysShowZero)
+{
+max = 0;
+}
+else
+{
+max = min + (roundingUnit * units);
+}
+}
+else if(!setMax)
+{
+if(alwaysShowZero || max === 0 || max + roundingUnit > 0)
+{
+max = 0;
+roundingUnit = this._getMinimumUnit(max, min, units);
+min = max - (roundingUnit * units);
+}
+else
+{
+min = this._roundDownToNearest(min, roundingUnit);
+max = this._roundUpToNearest(max, roundingUnit);
+}
+}
+else
+{
+min = max - (roundingUnit * units);
+}
+}
+}
+else if(roundingMethod === "auto")
+{
+if(minGreaterThanZero && maxGreaterThanZero)
+{
+if((alwaysShowZero || min < (max-min)/units) && !setMin)
+{
+min = 0;
+}
+roundingUnit = (max - min)/units;
+if(useIntegers)
+{
+roundingUnit = Math.ceil(roundingUnit);
+max = min + (roundingUnit * units);
+}
+else
+{
+max = min + Math.ceil(roundingUnit * units * 100000)/100000;
+}
+}
+else if(maxGreaterThanZero && !minGreaterThanZero)
+{
+if(alwaysShowZero)
+{
+topTicks = Math.round( units / ( (-1 * min) /max + 1) );
+topTicks = Math.max(Math.min(topTicks, units - 1), 1);
+botTicks = units - topTicks;
+if(useIntegers)
+{
+tempMax = Math.ceil( max/topTicks );
+tempMin = Math.floor( min/botTicks ) * -1;
+roundingUnit = Math.max(tempMax, tempMin);
+max = roundingUnit * topTicks;
+min = roundingUnit * botTicks * -1;
+}
+else
+{
+tempMax = max/topTicks;
+tempMin = min/botTicks * -1;
+roundingUnit = Math.max(tempMax, tempMin);
+max = Math.ceil(roundingUnit * topTicks * 100000)/100000;
+min = Math.ceil(roundingUnit * botTicks * 100000)/100000 * -1;
+}
+}
+else
+{
+roundingUnit = (max - min)/units;
+if(useIntegers)
+{
+roundingUnit = Math.ceil(roundingUnit);
+}
+min = Math.round(this._roundDownToNearest(min, roundingUnit) * 100000)/100000;
+max = Math.round(this._roundUpToNearest(max, roundingUnit) * 100000)/100000;
+}
+}
+else
+{
+roundingUnit = (max - min)/units;
+if(useIntegers)
+{
+roundingUnit = Math.ceil(roundingUnit);
+}
+if(alwaysShowZero || max === 0 || max + roundingUnit > 0)
+{
+max = 0;
+roundingUnit = (max - min)/units;
+if(useIntegers)
+{
+Math.ceil(roundingUnit);
+min = max - (roundingUnit * units);
+}
+else
+{
+min = max - Math.ceil(roundingUnit * units * 100000)/100000;
+}
+}
+else
+{
+min = this._roundDownToNearest(min, roundingUnit);
+max = this._roundUpToNearest(max, roundingUnit);
+}
+}
+}
+else if(!isNaN(roundingMethod) && isFinite(roundingMethod))
+{
+roundingUnit = roundingMethod;
+minimumRange = roundingUnit * units;
+dataRangeGreater = (max - min) > minimumRange;
+minRound = this._roundDownToNearest(min, roundingUnit);
+maxRound = this._roundUpToNearest(max, roundingUnit);
+if(setMax)
+{
+min = max - minimumRange;
+}
+else if(setMin)
+{
+max = min + minimumRange;
+}
+else if(minGreaterThanZero && maxGreaterThanZero)
+{
+if(alwaysShowZero || minRound <= 0)
+{
+min = 0;
+}
+else
+{
+min = minRound;
+}
+max = min + minimumRange;
+}
+else if(maxGreaterThanZero && !minGreaterThanZero)
+{
+min = minRound;
+max = maxRound;
+}
+else
+{
+if(alwaysShowZero || maxRound >= 0)
+{
+max = 0;
+}
+else
+{
+max = maxRound;
+}
+min = max - minimumRange;
+}
+}
+}
+this._dataMaximum = max;
+this._dataMinimum = min;
+},
+/**
+* Rounds a Number to the nearest multiple of an input. For example, by rounding
+* 16 to the nearest 10, you will receive 20. Similar to the built-in function Math.round().
+*
+* @method _roundToNearest
+* @param {Number} number Number to round
+* @param {Number} nearest Multiple to round towards.
+* @return Number
+* @private
+*/
+_roundToNearest: function(number, nearest)
+{
+nearest = nearest || 1;
+var roundedNumber = Math.round(this._roundToPrecision(number / nearest, 10)) * nearest;
+return this._roundToPrecision(roundedNumber, 10);
+},
+/**
+* Rounds a Number up to the nearest multiple of an input. For example, by rounding
+* 16 up to the nearest 10, you will receive 20. Similar to the built-in function Math.ceil().
+*
+* @method _roundUpToNearest
+* @param {Number} number Number to round
+* @param {Number} nearest Multiple to round towards.
+* @return Number
+* @private
+*/
+_roundUpToNearest: function(number, nearest)
+{
+nearest = nearest || 1;
+return Math.ceil(this._roundToPrecision(number / nearest, 10)) * nearest;
+},
+/**
+* Rounds a Number down to the nearest multiple of an input. For example, by rounding
+* 16 down to the nearest 10, you will receive 10. Similar to the built-in function Math.floor().
+*
+* @method _roundDownToNearest
+* @param {Number} number Number to round
+* @param {Number} nearest Multiple to round towards.
+* @return Number
+* @private
+*/
+_roundDownToNearest: function(number, nearest)
+{
+nearest = nearest || 1;
+return Math.floor(this._roundToPrecision(number / nearest, 10)) * nearest;
+},
+/**
+* Returns a coordinate corresponding to a data values.
+*
+* @method _getCoordFromValue
+* @param {Number} min The minimum for the axis.
+* @param {Number} max The maximum for the axis.
+* @param {Number} length The distance that the axis spans.
+* @param {Number} dataValue A value used to ascertain the coordinate.
+* @param {Number} offset Value in which to offset the coordinates.
+* @param {Boolean} reverse Indicates whether the coordinates should start from
+* the end of an axis. Only used in the numeric implementation.
+* @return Number
+* @private
+*/
+_getCoordFromValue: function(min, max, length, dataValue, offset, reverse)
+{
+var range,
+multiplier,
+valuecoord,
+isNumber = Y_Lang.isNumber;
+dataValue = parseFloat(dataValue);
+if(isNumber(dataValue))
+{
+if(this.get("scaleType") === "logarithmic" && min > 0)
+{
+min = Math.log(min);
+max = Math.log(max);
+dataValue = Math.log(dataValue);
+}
+range = max - min;
+multiplier = length/range;
+valuecoord = (dataValue - min) * multiplier;
+valuecoord = reverse ? offset - valuecoord : offset + valuecoord;
+}
+else
+{
+valuecoord = NaN;
+}
+return valuecoord;
+},
+/**
+* Rounds a number to a certain level of precision. Useful for limiting the number of
+* decimal places on a fractional number.
+*
+* @method _roundToPrecision
+* @param {Number} number Number to round
+* @param {Number} precision Multiple to round towards.
+* @return Number
+* @private
+*/
+_roundToPrecision: function(number, precision)
+{
+precision = precision || 0;
+var decimalPlaces = Math.pow(10, precision);
+return Math.round(decimalPlaces * number) / decimalPlaces;
+}
+};
+Y.NumericImpl = NumericImpl;
+/**
+* NumericAxisBase manages numeric data for an axis.
+*
+* @class NumericAxisBase
+* @constructor
+* @extends AxisBase
+* @uses NumericImpl
+* @param {Object} config (optional) Configuration parameters.
+* @submodule axis-numeric-base
+*/
+Y.NumericAxisBase = Y.Base.create("numericAxisBase", Y.AxisBase, [Y.NumericImpl]);
+}, '@VERSION@', {"requires": ["axis-base"]});

comt