-
Notifications
You must be signed in to change notification settings - Fork 1.3k
/
NumericAxis.js
170 lines (166 loc) · 5.36 KB
/
NumericAxis.js
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
/**
* 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()
{
var i = arguments[0],
l = arguments[1],
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;
}
});