--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/cm/media/js/lib/yui/yui_3.10.3/build/axis-numeric/axis-numeric-debug.js	Tue Jul 16 14:29:46 2013 +0200
@@ -0,0 +1,180 @@
+/*
+YUI 3.10.3 (build 2fb5187)
+Copyright 2013 Yahoo! Inc. All rights reserved.
+Licensed under the BSD License.
+http://yuilibrary.com/license/
+*/
+
+YUI.add('axis-numeric', function (Y, NAME) {
+
+/**
+ * Provides functionality for drawing a numeric axis for use with a chart.
+ *
+ * @module charts
+ * @submodule axis-numeric
+ */
+Y_Lang = Y.Lang;
+/**
+ * NumericAxis draws a numeric axis.
+ *
+ * @class NumericAxis
+ * @constructor
+ * @extends Axis
+ * @uses NumericImpl
+ * @param {Object} config (optional) Configuration parameters.
+ * @submodule axis-numeric
+ */
+Y.NumericAxis = Y.Base.create("numericAxis", Y.Axis, [Y.NumericImpl], {
+    /**
+     * Calculates and returns a value based on the number of labels and the index of
+     * the current label.
+     *
+     * @method getLabelByIndex
+     * @param {Number} i Index of the label.
+     * @param {Number} l Total number of labels.
+     * @return String
+     * @private
+     */
+    _getLabelByIndex: function(i, l)
+    {
+        var min = this.get("minimum"),
+            max = this.get("maximum"),
+            increm = (max - min)/(l-1),
+            label,
+            roundingMethod = this.get("roundingMethod");
+            l -= 1;
+        //respect the min and max. calculate all other labels.
+        if(i === 0)
+        {
+            label = min;
+        }
+        else if(i === l)
+        {
+            label = max;
+        }
+        else
+        {
+            label = (i * increm);
+            if(roundingMethod === "niceNumber")
+            {
+                label = this._roundToNearest(label, increm);
+            }
+            label += min;
+        }
+        return parseFloat(label);
+    },
+
+    /**
+     * Calculates points based off the majorUnit count or distance of the Axis.
+     *
+     * @method _getPoints
+     * @param {Object} startPoint An object literal containing the x and y coordinates of the first
+     * point on the axis.
+     * @param {Number} len The number of points on an axis.
+     * @param {Number} edgeOffset The distance from the start of the axis and the point.
+     * @param {Number} majorUnitDistance The distance between points on an axis.
+     * @param {String} direction Indicates whether the axis is horizontal or vertical.
+     * @return Array
+     * @private
+     */
+    _getPoints: function(startPoint, len, edgeOffset, majorUnitDistance, direction)
+    {
+        var points = Y.NumericAxis.superclass._getPoints.apply(this, arguments);
+        if(direction === "vertical")
+        {
+            points.reverse();
+        }
+        return points;
+    },
+
+    /**
+     * Calculates the position of ticks and labels based on an array of specified label values. Returns
+     * an object containing an array of values to be used for labels and an array of objects containing
+     * x and y coordinates for each label.
+     *
+     * @method _getDataFromLabelValues
+     * @param {Object} startPoint An object containing the x and y coordinates for the start of the axis.
+     * @param {Array} labelValues An array containing values to be used for determining the number and
+     * position of labels and ticks on the axis.
+     * @param {Number} edgeOffset The distance, in pixels, on either edge of the axis.
+     * @param {Number} layoutLength The length, in pixels, of the axis. If the axis is vertical, the length
+     * is equal to the height. If the axis is horizontal, the length is equal to the width.
+     * @return Object
+     * @private
+     */
+    _getDataFromLabelValues: function(startPoint, labelValues, edgeOffset, layoutLength, direction)
+    {
+        var points = [],
+            labelValue,
+            i,
+            len = labelValues.length,
+            staticCoord,
+            dynamicCoord,
+            constantVal,
+            newPoint,
+            max = this.get("maximum"),
+            min = this.get("minimum"),
+            values = [],
+            scaleFactor = (layoutLength - (edgeOffset * 2)) / (max - min);
+        if(direction === "vertical")
+        {
+            staticCoord = "x";
+            dynamicCoord = "y";
+        }
+        else
+        {
+            staticCoord = "y";
+            dynamicCoord = "x";
+        }
+        constantVal = startPoint[staticCoord];
+        for(i = 0; i < len; i = i + 1)
+        {
+            labelValue = labelValues[i];
+            if(Y.Lang.isNumber(labelValue) && labelValue >= min && labelValue <= max)
+            {
+                newPoint = {};
+                newPoint[staticCoord] = constantVal;
+                newPoint[dynamicCoord] = (layoutLength - edgeOffset) - (labelValue - min) * scaleFactor;
+                points.push(newPoint);
+                values.push(labelValue);
+            }
+        }
+        return {
+            points: points,
+            values: values
+        };
+    },
+
+    /**
+     * Checks to see if data extends beyond the range of the axis. If so,
+     * that data will need to be hidden. This method is internal, temporary and subject
+     * to removal in the future.
+     *
+     * @method _hasDataOverflow
+     * @protected
+     * @return Boolean
+     */
+    _hasDataOverflow: function()
+    {
+        var roundingMethod,
+            min,
+            max;
+        if(this.get("setMin") || this.get("setMax"))
+        {
+            return true;
+        }
+        roundingMethod = this.get("roundingMethod");
+        min = this._actualMinimum;
+        max = this._actualMaximum;
+        if(Y_Lang.isNumber(roundingMethod) &&
+            ((Y_Lang.isNumber(max) && max > this._dataMaximum) || (Y_Lang.isNumber(min) && min < this._dataMinimum)))
+        {
+            return true;
+        }
+        return false;
+    }
+});
+
+
+
+}, '3.10.3', {"requires": ["axis", "axis-numeric-base"]});