← Back to branch summary

~ubuntu-branches/ubuntu/utopic/moodle/utopic

« back to all changes in this revision

Viewing changes to lib/yuilib/3.13.0/axis-time-base/axis-time-base-debug.js

  • Committer: Package Import Robot
  • Author(s): Thijs Kinkhorst
  • Date: 2014-05-12 16:10:38 UTC
  • mfrom: (36.1.3 sid)
  • Revision ID: package-import@ubuntu.com-20140512161038-puyqf65k4e0s8ytz
Tags: 2.6.3-1
New upstream release.

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/yuilib/3.13.0/axis-time-base/axis-time-base-debug.js
 
1
/*
 
2
YUI 3.13.0 (build 508226d)
 
3
Copyright 2013 Yahoo! Inc. All rights reserved.
 
4
Licensed under the BSD License.
 
5
http://yuilibrary.com/license/
 
6
*/
 
7
 
 
8
YUI.add('axis-time-base', function (Y, NAME) {
 
9
 
 
10
/**
 
11
 * Provides functionality for the handling of time axis data for a chart.
 
12
 *
 
13
 * @module charts
 
14
 * @submodule axis-time-base
 
15
 */
 
16
var Y_Lang = Y.Lang;
 
17
 
 
18
/**
 
19
 * TimeImpl contains logic for time data. TimeImpl is used by the following classes:
 
20
 * <ul>
 
21
 *      <li>{{#crossLink "TimeAxisBase"}}{{/crossLink}}</li>
 
22
 *      <li>{{#crossLink "TimeAxis"}}{{/crossLink}}</li>
 
23
 *  </ul>
 
24
 *
 
25
 * @class TimeImpl
 
26
 * @constructor
 
27
 * @submodule axis-time-base
 
28
 */
 
29
function TimeImpl()
 
30
{
 
31
}
 
32
 
 
33
TimeImpl.NAME = "timeImpl";
 
34
 
 
35
TimeImpl.ATTRS =
 
36
{
 
37
    /**
 
38
     * Method used for formatting a label. This attribute allows for the default label formatting method to overridden.
 
39
     * The method use would need to implement the arguments below and return a `String` or an `HTMLElement`. The default
 
40
     * implementation of the method returns a `String`. The output of this method will be rendered to the DOM using
 
41
     * `appendChild`. If you override the `labelFunction` method and return an html string, you will also need to override
 
42
     * the Axis' `appendLabelFunction` to accept html as a `String`.
 
43
     * <dl>
 
44
     *      <dt>val</dt><dd>Label to be formatted. (`String`)</dd>
 
45
     *      <dt>format</dt><dd>STRFTime string used to format the label. (optional)</dd>
 
46
     * </dl>
 
47
     *
 
48
     * @attribute labelFunction
 
49
     * @type Function
 
50
     */
 
51
 
 
52
    /**
 
53
     * Pattern used by the `labelFunction` to format a label.
 
54
     *
 
55
     * @attribute labelFormat
 
56
     * @type String
 
57
     */
 
58
    labelFormat: {
 
59
        value: "%b %d, %y"
 
60
    }
 
61
};
 
62
 
 
63
TimeImpl.prototype = {
 
64
    /**
 
65
     * Type of data used in `Data`.
 
66
     *
 
67
     * @property _type
 
68
     * @readOnly
 
69
     * @private
 
70
     */
 
71
    _type: "time",
 
72
 
 
73
    /**
 
74
     * Getter method for maximum attribute.
 
75
     *
 
76
     * @method _maximumGetter
 
77
     * @return Number
 
78
     * @private
 
79
     */
 
80
    _maximumGetter: function ()
 
81
    {
 
82
        var max = this._getNumber(this._setMaximum);
 
83
        if(!Y_Lang.isNumber(max))
 
84
        {
 
85
            max = this._getNumber(this.get("dataMaximum"));
 
86
        }
 
87
        return parseFloat(max);
 
88
    },
 
89
 
 
90
    /**
 
91
     * Setter method for maximum attribute.
 
92
     *
 
93
     * @method _maximumSetter
 
94
     * @param {Object} value
 
95
     * @private
 
96
     */
 
97
    _maximumSetter: function (value)
 
98
    {
 
99
        this._setMaximum = this._getNumber(value);
 
100
        return value;
 
101
    },
 
102
 
 
103
    /**
 
104
     * Getter method for minimum attribute.
 
105
     *
 
106
     * @method _minimumGetter
 
107
     * @return Number
 
108
     * @private
 
109
     */
 
110
    _minimumGetter: function ()
 
111
    {
 
112
        var min = this._getNumber(this._setMinimum);
 
113
        if(!Y_Lang.isNumber(min))
 
114
        {
 
115
            min = this._getNumber(this.get("dataMinimum"));
 
116
        }
 
117
        return parseFloat(min);
 
118
    },
 
119
 
 
120
    /**
 
121
     * Setter method for minimum attribute.
 
122
     *
 
123
     * @method _minimumSetter
 
124
     * @param {Object} value
 
125
     * @private
 
126
     */
 
127
    _minimumSetter: function (value)
 
128
    {
 
129
        this._setMinimum = this._getNumber(value);
 
130
        return value;
 
131
    },
 
132
 
 
133
    /**
 
134
     * Indicates whether or not the maximum attribute has been explicitly set.
 
135
     *
 
136
     * @method _getSetMax
 
137
     * @return Boolean
 
138
     * @private
 
139
     */
 
140
    _getSetMax: function()
 
141
    {
 
142
        var max = this._getNumber(this._setMaximum);
 
143
        return (Y_Lang.isNumber(max));
 
144
    },
 
145
 
 
146
    /**
 
147
     * Indicates whether or not the minimum attribute has been explicitly set.
 
148
     *
 
149
     * @method _getSetMin
 
150
     * @return Boolean
 
151
     * @private
 
152
     */
 
153
    _getSetMin: function()
 
154
    {
 
155
        var min = this._getNumber(this._setMinimum);
 
156
        return (Y_Lang.isNumber(min));
 
157
    },
 
158
 
 
159
    /**
 
160
     * Formats a label based on the axis type and optionally specified format.
 
161
     *
 
162
     * @method formatLabel
 
163
     * @param {Object} value
 
164
     * @param {Object} format Pattern used to format the value.
 
165
     * @return String
 
166
     */
 
167
    formatLabel: function(val, format)
 
168
    {
 
169
        val = Y.DataType.Date.parse(val);
 
170
        if(format)
 
171
        {
 
172
            return Y.DataType.Date.format(val, {format:format});
 
173
        }
 
174
        return val;
 
175
    },
 
176
 
 
177
    /**
 
178
     * Constant used to generate unique id.
 
179
     *
 
180
     * @property GUID
 
181
     * @type String
 
182
     * @private
 
183
     */
 
184
    GUID: "yuitimeaxis",
 
185
 
 
186
    /**
 
187
     * Type of data used in `Axis`.
 
188
     *
 
189
     * @property _dataType
 
190
     * @readOnly
 
191
     * @private
 
192
     */
 
193
    _dataType: "time",
 
194
 
 
195
    /**
 
196
     * Gets an array of values based on a key.
 
197
     *
 
198
     * @method _getKeyArray
 
199
     * @param {String} key Value key associated with the data array.
 
200
     * @param {Array} data Array in which the data resides.
 
201
     * @return Array
 
202
     * @private
 
203
     */
 
204
    _getKeyArray: function(key, data)
 
205
    {
 
206
        var obj,
 
207
            keyArray = [],
 
208
            i = 0,
 
209
            val,
 
210
            len = data.length;
 
211
        for(; i < len; ++i)
 
212
        {
 
213
            obj = data[i][key];
 
214
            if(Y_Lang.isDate(obj))
 
215
            {
 
216
                val = obj.valueOf();
 
217
            }
 
218
            else
 
219
            {
 
220
                val = new Date(obj);
 
221
                if(Y_Lang.isDate(val))
 
222
                {
 
223
                    val = val.valueOf();
 
224
                }
 
225
                else if(!Y_Lang.isNumber(obj))
 
226
                {
 
227
                    if(Y_Lang.isNumber(parseFloat(obj)))
 
228
                    {
 
229
                        val = parseFloat(obj);
 
230
                    }
 
231
                    else
 
232
                    {
 
233
                        if(typeof obj !== "string")
 
234
                        {
 
235
                            obj = obj;
 
236
                        }
 
237
                        val = new Date(obj).valueOf();
 
238
                    }
 
239
                }
 
240
                else
 
241
                {
 
242
                    val = obj;
 
243
                }
 
244
            }
 
245
            keyArray[i] = val;
 
246
        }
 
247
        return keyArray;
 
248
    },
 
249
 
 
250
    /**
 
251
     * Calculates the maximum and minimum values for the `Axis`.
 
252
     *
 
253
     * @method _updateMinAndMax
 
254
     * @private
 
255
     */
 
256
    _updateMinAndMax: function()
 
257
    {
 
258
        var data = this.get("data"),
 
259
            max = 0,
 
260
            min = 0,
 
261
            len,
 
262
            num,
 
263
            i;
 
264
        if(data && data.length && data.length > 0)
 
265
        {
 
266
            len = data.length;
 
267
            max = min = data[0];
 
268
            if(len > 1)
 
269
            {
 
270
                for(i = 1; i < len; i++)
 
271
                {
 
272
                    num = data[i];
 
273
                    if(isNaN(num))
 
274
                    {
 
275
                        continue;
 
276
                    }
 
277
                    max = Math.max(num, max);
 
278
                    min = Math.min(num, min);
 
279
                }
 
280
            }
 
281
        }
 
282
        this._dataMaximum = max;
 
283
        this._dataMinimum = min;
 
284
    },
 
285
 
 
286
    /**
 
287
     * Returns a coordinate corresponding to a data values.
 
288
     *
 
289
     * @method _getCoordFromValue
 
290
     * @param {Number} min The minimum for the axis.
 
291
     * @param {Number} max The maximum for the axis.
 
292
     * @param {length} length The distance that the axis spans.
 
293
     * @param {Number} dataValue A value used to ascertain the coordinate.
 
294
     * @param {Number} offset Value in which to offset the coordinates.
 
295
     * @param {Boolean} reverse Indicates whether the coordinates should start from
 
296
     * the end of an axis. Only used in the numeric implementation.
 
297
     * @return Number
 
298
     * @private
 
299
     */
 
300
    _getCoordFromValue: function(min, max, length, dataValue, offset)
 
301
    {
 
302
        var range,
 
303
            multiplier,
 
304
            valuecoord,
 
305
            isNumber = Y_Lang.isNumber;
 
306
            dataValue = this._getNumber(dataValue);
 
307
        if(isNumber(dataValue))
 
308
        {
 
309
            range = max - min;
 
310
            multiplier = length/range;
 
311
            valuecoord = (dataValue - min) * multiplier;
 
312
            valuecoord = offset + valuecoord;
 
313
        }
 
314
        else
 
315
        {
 
316
            valuecoord = NaN;
 
317
        }
 
318
        return valuecoord;
 
319
    },
 
320
 
 
321
    /**
 
322
     * Parses value into a number.
 
323
     *
 
324
     * @method _getNumber
 
325
     * @param val {Object} Value to parse into a number
 
326
     * @return Number
 
327
     * @private
 
328
     */
 
329
    _getNumber: function(val)
 
330
    {
 
331
        if(Y_Lang.isDate(val))
 
332
        {
 
333
            val = val.valueOf();
 
334
        }
 
335
        else if(!Y_Lang.isNumber(val) && val)
 
336
        {
 
337
            val = new Date(val).valueOf();
 
338
        }
 
339
 
 
340
        return val;
 
341
    }
 
342
};
 
343
 
 
344
Y.TimeImpl = TimeImpl;
 
345
 
 
346
/**
 
347
 * TimeAxisBase manages time data for an axis.
 
348
 *
 
349
 * @class TimeAxisBase
 
350
 * @extends AxisBase
 
351
 * @uses TimeImpl
 
352
 * @constructor
 
353
 * @param {Object} config (optional) Configuration parameters.
 
354
 * @submodule axis-time-base
 
355
 */
 
356
Y.TimeAxisBase = Y.Base.create("timeAxisBase", Y.AxisBase, [Y.TimeImpl]);
 
357
 
 
358
 
 
359
}, '3.13.0', {"requires": ["axis-base"]});