Show:
                            /**
                             * The axis-base submodule contains functionality for the handling of axis data in a chart.
                             *
                             * @module charts
                             * @submodule axis-base
                             */
                            /**
                             * An abstract class that provides the core functionality used by the following classes:
                             * <ul>
                             *      <li>{{#crossLink "CategoryAxisBase"}}{{/crossLink}}</li>
                             *      <li>{{#crossLink "NumericAxisBase"}}{{/crossLink}}</li>
                             *      <li>{{#crossLink "StackedAxisBase"}}{{/crossLink}}</li>
                             *      <li>{{#crossLink "TimeAxisBase"}}{{/crossLink}}</li>
                             *      <li>{{#crossLink "CategoryAxis"}}{{/crossLink}}</li>
                             *      <li>{{#crossLink "NumericAxis"}}{{/crossLink}}</li>
                             *      <li>{{#crossLink "StackedAxis"}}{{/crossLink}}</li>
                             *      <li>{{#crossLink "TimeAxis"}}{{/crossLink}}</li>
                             *  </ul>
                             *
                             * @class AxisBase
                             * @constructor
                             * @extends Base
                             * @uses Renderer
                             * @param {Object} config (optional) Configuration parameters.
                             * @submodule axis-base
                             */
                            Y.AxisBase = Y.Base.create("axisBase", Y.Base, [Y.Renderer], {
                                /**
                                 * @method initializer
                                 * @private
                                 */
                                initializer: function()
                                {
                                    this.after("minimumChange", Y.bind(this._keyChangeHandler, this));
                                    this.after("maximumChange", Y.bind(this._keyChangeHandler, this));
                                    this.after("keysChange", this._keyChangeHandler);
                                    this.after("dataProviderChange", this._dataProviderChangeHandler);
                                },
                            
                                /**
                                 * Returns the value corresponding to the origin on the axis.
                                 *
                                 * @method getOrigin
                                 * @return Number
                                 */
                                getOrigin: function() {
                                    return this.get("minimum");
                                },
                            
                                /**
                                 * Handles changes to `dataProvider`.
                                 *
                                 * @method _dataProviderChangeHandler
                                 * @param {Object} e Event object.
                                 * @private
                                 */
                                _dataProviderChangeHandler: function()
                                {
                                    var keyCollection = this.get("keyCollection").concat(),
                                        keys = this.get("keys"),
                                        i;
                                    if(keys)
                                    {
                                        for(i in keys)
                                        {
                                            if(keys.hasOwnProperty(i))
                                            {
                                                delete keys[i];
                                            }
                                        }
                                    }
                                    if(keyCollection && keyCollection.length)
                                    {
                                        this.set("keys", keyCollection);
                                    }
                                },
                            
                                /**
                                 * Calculates the maximum and minimum values for the `Data`.
                                 *
                                 * @method _updateMinAndMax
                                 * @private
                                 */
                                _updateMinAndMax: function() {
                                },
                            
                                /**
                                 * Constant used to generate unique id.
                                 *
                                 * @property GUID
                                 * @type String
                                 * @private
                                 */
                                GUID: "yuibaseaxis",
                            
                                /**
                                 * Type of data used in `Axis`.
                                 *
                                 * @property _type
                                 * @type String
                                 * @readOnly
                                 * @private
                                 */
                                _type: null,
                            
                                /**
                                 * Storage for `setMaximum` attribute.
                                 *
                                 * @property _setMaximum
                                 * @type Object
                                 * @private
                                 */
                                _setMaximum: null,
                            
                                /**
                                 * Storage for `setMinimum` attribute.
                                 *
                                 * @property _setMinimum
                                 * @type Object
                                 * @private
                                 */
                                _setMinimum: null,
                            
                                /**
                                 * Reference to data array.
                                 *
                                 * @property _data
                                 * @type Array
                                 * @private
                                 */
                                _data: null,
                            
                                /**
                                 * Indicates whether the all data is up to date.
                                 *
                                 * @property _updateTotalDataFlag
                                 * @type Boolean
                                 * @private
                                 */
                                _updateTotalDataFlag: true,
                            
                                /**
                                 * Storage for `dataReady` attribute.
                                 *
                                 * @property _dataReady
                                 * @type Boolean
                                 * @readOnly
                                 * @private
                                 */
                                _dataReady: false,
                            
                                /**
                                 * Adds an array to the key hash.
                                 *
                                 * @method addKey
                                 * @param value Indicates what key to use in retrieving
                                 * the array.
                                 */
                                addKey: function (value)
                            	{
                                    this.set("keys", value);
                            	},
                            
                                /**
                                 * Gets an array of values based on a key.
                                 *
                                 * @method _getKeyArray
                                 * @param {String} key Value key associated with the data array.
                                 * @param {Array} data Array in which the data resides.
                                 * @return Array
                                 * @private
                                 */
                                _getKeyArray: function(key, data)
                                {
                                    var i = 0,
                                        obj,
                                        keyArray = [],
                                        len = data.length;
                                    for(; i < len; ++i)
                                    {
                                        obj = data[i];
                                        keyArray[i] = obj[key];
                                    }
                                    return keyArray;
                                },
                            
                                /**
                                 * Updates the total data array.
                                 *
                                 * @method _updateTotalData
                                 * @private
                                 */
                                _updateTotalData: function()
                                {
                            		var keys = this.get("keys"),
                                        i;
                                    this._data = [];
                                    for(i in keys)
                                    {
                                        if(keys.hasOwnProperty(i))
                                        {
                                            this._data = this._data.concat(keys[i]);
                                        }
                                    }
                                    this._updateTotalDataFlag = false;
                                },
                            
                                /**
                                 * Removes an array from the key hash.
                                 *
                                 * @method removeKey
                                 * @param {String} value Indicates what key to use in removing from
                                 * the hash.
                                 */
                                removeKey: function(value)
                                {
                                    var keys = this.get("keys");
                                    if(keys.hasOwnProperty(value))
                                    {
                                        delete keys[value];
                                        this._keyChangeHandler();
                                    }
                                },
                            
                                /**
                                 * Returns a value based of a key value and an index.
                                 *
                                 * @method getKeyValueAt
                                 * @param {String} key value used to look up the correct array
                                 * @param {Number} index within the array
                                 * @return Number
                                 */
                                getKeyValueAt: function(key, index)
                                {
                                    var value = NaN,
                                        keys = this.get("keys");
                                    if(keys[key] && Y_Lang.isNumber(parseFloat(keys[key][index])))
                                    {
                                        value = keys[key][index];
                                    }
                                    return parseFloat(value);
                                },
                            
                                /**
                                 * Returns values based on key identifiers. When a string is passed as an argument, an array of values is returned.
                                 * When an array of keys is passed as an argument, an object literal with an array of values mapped to each key is
                                 * returned.
                                 *
                                 * @method getDataByKey
                                 * @param {String|Array} value value used to identify the array
                                 * @return Array|Object
                                 */
                                getDataByKey: function (value)
                                {
                                    var obj,
                                        i,
                                        len,
                                        key,
                                        keys = this.get("keys");
                                    if(Y_Lang.isArray(value))
                                    {
                                        obj = {};
                                        len = value.length;
                                        for(i = 0; i < len; i = i + 1)
                                        {
                                            key = value[i];
                                            if(keys[key])
                                            {
                                                obj[key] = this.getDataByKey(key);
                                            }
                                        }
                                    }
                                    else if(keys[value])
                                    {
                                        obj = keys[value];
                                    }
                                    else
                                    {
                                        obj = null;
                                    }
                                    return obj;
                                },
                            
                                /**
                                 * Returns the total number of majorUnits that will appear on an axis.
                                 *
                                 * @method getTotalMajorUnits
                                 * @return Number
                                 */
                                getTotalMajorUnits: function()
                                {
                                    var units,
                                        majorUnit = this.get("styles").majorUnit;
                                    units = majorUnit.count;
                                    return units;
                                },
                            
                                /**
                                 * Gets the distance that the first and last ticks are offset from there respective
                                 * edges.
                                 *
                                 * @method getEdgeOffset
                                 * @param {Number} ct Number of ticks on the axis.
                                 * @param {Number} l Length (in pixels) of the axis.
                                 * @return Number
                                 */
                                getEdgeOffset: function(ct, l)
                                {
                                    var edgeOffset;
                                    if(this.get("calculateEdgeOffset")) {
                                        edgeOffset = (l/ct)/2;
                                    } else {
                                        edgeOffset = 0;
                                    }
                                    return edgeOffset;
                                },
                            
                                /**
                                 * Updates the `Axis` after a change in keys.
                                 *
                                 * @method _keyChangeHandler
                                 * @param {Object} e Event object.
                                 * @private
                                 */
                                _keyChangeHandler: function()
                                {
                                    this._updateMinAndMax();
                                    this._updateTotalDataFlag = true;
                                    this.fire("dataUpdate");
                                },
                            
                                /**
                                 * Gets the default value for the `styles` attribute. Overrides
                                 * base implementation.
                                 *
                                 * @method _getDefaultStyles
                                 * @return Object
                                 * @protected
                                 */
                                _getDefaultStyles: function()
                                {
                                    var axisstyles = {
                                        majorUnit: {
                                            determinant:"count",
                                            count:11,
                                            distance:75
                                        }
                                    };
                                    return axisstyles;
                                },
                            
                                /**
                                 * Getter method for maximum attribute.
                                 *
                                 * @method _maximumGetter
                                 * @return Number
                                 * @private
                                 */
                                _maximumGetter: function ()
                                {
                                    var max = this.get("dataMaximum"),
                                        min = this.get("minimum");
                                    //If all values are zero, force a range so that the Axis and related series
                                    //will still render.
                                    if(min === 0 && max === 0)
                                    {
                                        max = 10;
                                    }
                                    if(Y_Lang.isNumber(this._setMaximum))
                                    {
                                        max = this._setMaximum;
                                    }
                                    return parseFloat(max);
                                },
                            
                                /**
                                 * Setter method for maximum attribute.
                                 *
                                 * @method _maximumSetter
                                 * @param {Object} value
                                 * @private
                                 */
                                _maximumSetter: function (value)
                                {
                                    this._setMaximum = parseFloat(value);
                                    return value;
                                },
                            
                                /**
                                 * Getter method for minimum attribute.
                                 *
                                 * @method _minimumGetter
                                 * @return Number
                                 * @private
                                 */
                                _minimumGetter: function ()
                                {
                                    var min = this.get("dataMinimum");
                                    if(Y_Lang.isNumber(this._setMinimum))
                                    {
                                        min = this._setMinimum;
                                    }
                                    return parseFloat(min);
                                },
                            
                                /**
                                 * Setter method for minimum attribute.
                                 *
                                 * @method _minimumSetter
                                 * @param {Object} value
                                 * @private
                                 */
                                _minimumSetter: function(val)
                                {
                                    this._setMinimum = parseFloat(val);
                                    return val;
                                },
                            
                                /**
                                 * Indicates whether or not the maximum attribute has been explicitly set.
                                 *
                                 * @method _getSetMax
                                 * @return Boolean
                                 * @private
                                 */
                                _getSetMax: function()
                                {
                                    return Y_Lang.isNumber(this._setMaximum);
                                },
                            
                            
                                /**
                                 * Returns and array of coordinates corresponding to an array of data values.
                                 *
                                 * @method _getCoordsFromValues
                                 * @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 {Array} dataValues An array of values.
                                 * @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 Array
                                 * @private
                                 */
                                _getCoordsFromValues: function(min, max, length, dataValues, offset, reverse)
                                {
                                    var i,
                                        valuecoords = [],
                                        len = dataValues.length;
                                    for(i = 0; i < len; i = i + 1)
                                    {
                                        valuecoords.push(this._getCoordFromValue.apply(this, [min, max, length, dataValues[i], offset, reverse]));
                                    }
                                    return valuecoords;
                                },
                            
                                /**
                                 * Returns and array of data values based on the axis' range and number of values.
                                 *
                                 * @method _getDataValuesByCount
                                 * @param {Number} count The number of values to be used.
                                 * @param {Number} min The minimum value of the axis.
                                 * @param {Number} max The maximum value of the axis.
                                 * @return Array
                                 * @private
                                 */
                                _getDataValuesByCount: function(count, min, max)
                                {
                                    var dataValues = [],
                                        dataValue = min,
                                        len = count - 1,
                                        range = max - min,
                                        increm = range/len,
                                        i;
                                    for(i = 0; i < len; i = i + 1)
                                    {
                                        dataValues.push(dataValue);
                                        dataValue = dataValue + increm;
                                    }
                                    dataValues.push(max);
                                    return dataValues;
                                },
                            
                                /**
                                 * Indicates whether or not the minimum attribute has been explicitly set.
                                 *
                                 * @method _getSetMin
                                 * @return Boolean
                                 * @private
                                 */
                                _getSetMin: function()
                                {
                                    return Y_Lang.isNumber(this._setMinimum);
                                }
                            }, {
                                ATTRS: {
                                    /**
                                     * Determines whether and offset is automatically calculated for the edges of the axis.
                                     *
                                     * @attribute calculateEdgeOffset
                                     * @type Boolean
                                     */
                                    calculateEdgeOffset: {
                                        value: false
                                    },
                            
                                    labelFunction: {
                                        valueFn: function() {
                                            return this.formatLabel;
                                        }
                                    },
                            
                                    /**
                                     * Hash of array identifed by a string value.
                                     *
                                     * @attribute keys
                                     * @type Object
                                     */
                                    keys: {
                                        value: {},
                            
                                        setter: function(val)
                                        {
                                            var keys = {},
                                                i,
                                                len,
                                                data = this.get("dataProvider");
                                            if(Y_Lang.isArray(val))
                                            {
                                                len = val.length;
                                                for(i = 0; i < len; ++i)
                                                {
                                                    keys[val[i]] = this._getKeyArray(val[i], data);
                                                }
                            
                                            }
                                            else if(Y_Lang.isString(val))
                                            {
                                                keys = this.get("keys");
                                                keys[val] = this._getKeyArray(val, data);
                                            }
                                            else
                                            {
                                                for(i in val)
                                                {
                                                    if(val.hasOwnProperty(i))
                                                    {
                                                        keys[i] = this._getKeyArray(i, data);
                                                    }
                                                }
                                            }
                                            this._updateTotalDataFlag = true;
                                            return keys;
                                        }
                                    },
                            
                                    /**
                                     *Returns the type of axis data
                                     *  <dl>
                                     *      <dt>time</dt><dd>Manages time data</dd>
                                     *      <dt>stacked</dt><dd>Manages stacked numeric data</dd>
                                     *      <dt>numeric</dt><dd>Manages numeric data</dd>
                                     *      <dt>category</dt><dd>Manages categorical data</dd>
                                     *  </dl>
                                     *
                                     * @attribute type
                                     * @type String
                                     */
                                    type:
                                    {
                                        readOnly: true,
                            
                                        getter: function ()
                                        {
                                            return this._type;
                                        }
                                    },
                            
                                    /**
                                     * Instance of `ChartDataProvider` that the class uses
                                     * to build its own data.
                                     *
                                     * @attribute dataProvider
                                     * @type Array
                                     */
                                    dataProvider:{
                                        setter: function (value)
                                        {
                                            return value;
                                        }
                                    },
                            
                                    /**
                                     * The maximum value contained in the `data` array. Used for
                                     * `maximum` when `autoMax` is true.
                                     *
                                     * @attribute dataMaximum
                                     * @type Number
                                     */
                                    dataMaximum: {
                                        getter: function ()
                                        {
                                            if(!Y_Lang.isNumber(this._dataMaximum))
                                            {
                                                this._updateMinAndMax();
                                            }
                                            return this._dataMaximum;
                                        }
                                    },
                            
                                    /**
                                     * The maximum value that will appear on an axis.
                                     *
                                     * @attribute maximum
                                     * @type Number
                                     */
                                    maximum: {
                                        lazyAdd: false,
                            
                                        getter: "_maximumGetter",
                            
                                        setter: "_maximumSetter"
                                    },
                            
                                    /**
                                     * The minimum value contained in the `data` array. Used for
                                     * `minimum` when `autoMin` is true.
                                     *
                                     * @attribute dataMinimum
                                     * @type Number
                                     */
                                    dataMinimum: {
                                        getter: function ()
                                        {
                                            if(!Y_Lang.isNumber(this._dataMinimum))
                                            {
                                                this._updateMinAndMax();
                                            }
                                            return this._dataMinimum;
                                        }
                                    },
                            
                                    /**
                                     * The minimum value that will appear on an axis.
                                     *
                                     * @attribute minimum
                                     * @type Number
                                     */
                                    minimum: {
                                        lazyAdd: false,
                            
                                        getter: "_minimumGetter",
                            
                                        setter: "_minimumSetter"
                                    },
                            
                                    /**
                                     * Determines whether the maximum is calculated or explicitly
                                     * set by the user.
                                     *
                                     * @attribute setMax
                                     * @type Boolean
                                     */
                                    setMax: {
                                        readOnly: true,
                            
                                        getter: "_getSetMax"
                                    },
                            
                                    /**
                                     * Determines whether the minimum is calculated or explicitly
                                     * set by the user.
                                     *
                                     * @attribute setMin
                                     * @type Boolean
                                     */
                                    setMin: {
                                        readOnly: true,
                            
                                        getter: "_getSetMin"
                                    },
                            
                                    /**
                                     * Array of axis data
                                     *
                                     * @attribute data
                                     * @type Array
                                     */
                                    data: {
                                        getter: function ()
                                        {
                                            if(!this._data || this._updateTotalDataFlag)
                                            {
                                                this._updateTotalData();
                                            }
                                            return this._data;
                                        }
                                    },
                            
                                    /**
                                     * Array containing all the keys in the axis.
                            
                                     * @attribute keyCollection
                                     * @type Array
                                     */
                                    keyCollection: {
                                        getter: function()
                                        {
                                            var keys = this.get("keys"),
                                                i,
                                                col = [];
                                            for(i in keys)
                                            {
                                                if(keys.hasOwnProperty(i))
                                                {
                                                    col.push(i);
                                                }
                                            }
                                            return col;
                                        },
                                        readOnly: true
                                    },
                            
                                    /**
                                     * Object which should have by the labelFunction
                                     *
                                     * @attribute labelFunctionScope
                                     * @type Object
                                     */
                                    labelFunctionScope: {}
                                }
                            });