Move stock data into tests/data.js
[dygraphs.git] / src / dygraph-utils.js
1 /**
2 * @license
3 * Copyright 2011 Dan Vanderkam (danvdk@gmail.com)
4 * MIT-licensed (http://opensource.org/licenses/MIT)
5 */
6
7 /**
8 * @fileoverview This file contains utility functions used by dygraphs. These
9 * are typically static (i.e. not related to any particular dygraph). Examples
10 * include date/time formatting functions, basic algorithms (e.g. binary
11 * search) and generic DOM-manipulation functions.
12 */
13
14 (function() {
15
16 /*global Dygraph:false, Node:false */
17 "use strict";
18
19 Dygraph.LOG_SCALE = 10;
20 Dygraph.LN_TEN = Math.log(Dygraph.LOG_SCALE);
21
22 /**
23 * @private
24 * @param {number} x
25 * @return {number}
26 */
27 Dygraph.log10 = function(x) {
28 return Math.log(x) / Dygraph.LN_TEN;
29 };
30
31 /** A dotted line stroke pattern. */
32 Dygraph.DOTTED_LINE = [2, 2];
33 /** A dashed line stroke pattern. */
34 Dygraph.DASHED_LINE = [7, 3];
35 /** A dot dash stroke pattern. */
36 Dygraph.DOT_DASH_LINE = [7, 2, 2, 2];
37
38 /**
39 * Return the 2d context for a dygraph canvas.
40 *
41 * This method is only exposed for the sake of replacing the function in
42 * automated tests, e.g.
43 *
44 * var oldFunc = Dygraph.getContext();
45 * Dygraph.getContext = function(canvas) {
46 * var realContext = oldFunc(canvas);
47 * return new Proxy(realContext);
48 * };
49 * @param {!HTMLCanvasElement} canvas
50 * @return {!CanvasRenderingContext2D}
51 * @private
52 */
53 Dygraph.getContext = function(canvas) {
54 return /** @type{!CanvasRenderingContext2D}*/(canvas.getContext("2d"));
55 };
56
57 /**
58 * Add an event handler.
59 * @param {!Node} elem The element to add the event to.
60 * @param {string} type The type of the event, e.g. 'click' or 'mousemove'.
61 * @param {function(Event):(boolean|undefined)} fn The function to call
62 * on the event. The function takes one parameter: the event object.
63 * @private
64 */
65 Dygraph.addEvent = function addEvent(elem, type, fn) {
66 elem.addEventListener(type, fn, false);
67 };
68
69 /**
70 * Add an event handler. This event handler is kept until the graph is
71 * destroyed with a call to graph.destroy().
72 *
73 * @param {!Node} elem The element to add the event to.
74 * @param {string} type The type of the event, e.g. 'click' or 'mousemove'.
75 * @param {function(Event):(boolean|undefined)} fn The function to call
76 * on the event. The function takes one parameter: the event object.
77 * @private
78 */
79 Dygraph.prototype.addAndTrackEvent = function(elem, type, fn) {
80 Dygraph.addEvent(elem, type, fn);
81 this.registeredEvents_.push({ elem : elem, type : type, fn : fn });
82 };
83
84 /**
85 * Remove an event handler.
86 * @param {!Node} elem The element to remove the event from.
87 * @param {string} type The type of the event, e.g. 'click' or 'mousemove'.
88 * @param {function(Event):(boolean|undefined)} fn The function to call
89 * on the event. The function takes one parameter: the event object.
90 * @private
91 */
92 Dygraph.removeEvent = function(elem, type, fn) {
93 elem.removeEventListener(type, fn, false);
94 };
95
96 Dygraph.prototype.removeTrackedEvents_ = function() {
97 if (this.registeredEvents_) {
98 for (var idx = 0; idx < this.registeredEvents_.length; idx++) {
99 var reg = this.registeredEvents_[idx];
100 Dygraph.removeEvent(reg.elem, reg.type, reg.fn);
101 }
102 }
103
104 this.registeredEvents_ = [];
105 };
106
107 /**
108 * Cancels further processing of an event. This is useful to prevent default
109 * browser actions, e.g. highlighting text on a double-click.
110 * Based on the article at
111 * http://www.switchonthecode.com/tutorials/javascript-tutorial-the-scroll-wheel
112 * @param {!Event} e The event whose normal behavior should be canceled.
113 * @private
114 */
115 Dygraph.cancelEvent = function(e) {
116 e = e ? e : window.event;
117 if (e.stopPropagation) {
118 e.stopPropagation();
119 }
120 if (e.preventDefault) {
121 e.preventDefault();
122 }
123 e.cancelBubble = true;
124 e.cancel = true;
125 e.returnValue = false;
126 return false;
127 };
128
129 /**
130 * Convert hsv values to an rgb(r,g,b) string. Taken from MochiKit.Color. This
131 * is used to generate default series colors which are evenly spaced on the
132 * color wheel.
133 * @param { number } hue Range is 0.0-1.0.
134 * @param { number } saturation Range is 0.0-1.0.
135 * @param { number } value Range is 0.0-1.0.
136 * @return { string } "rgb(r,g,b)" where r, g and b range from 0-255.
137 * @private
138 */
139 Dygraph.hsvToRGB = function (hue, saturation, value) {
140 var red;
141 var green;
142 var blue;
143 if (saturation === 0) {
144 red = value;
145 green = value;
146 blue = value;
147 } else {
148 var i = Math.floor(hue * 6);
149 var f = (hue * 6) - i;
150 var p = value * (1 - saturation);
151 var q = value * (1 - (saturation * f));
152 var t = value * (1 - (saturation * (1 - f)));
153 switch (i) {
154 case 1: red = q; green = value; blue = p; break;
155 case 2: red = p; green = value; blue = t; break;
156 case 3: red = p; green = q; blue = value; break;
157 case 4: red = t; green = p; blue = value; break;
158 case 5: red = value; green = p; blue = q; break;
159 case 6: // fall through
160 case 0: red = value; green = t; blue = p; break;
161 }
162 }
163 red = Math.floor(255 * red + 0.5);
164 green = Math.floor(255 * green + 0.5);
165 blue = Math.floor(255 * blue + 0.5);
166 return 'rgb(' + red + ',' + green + ',' + blue + ')';
167 };
168
169 /**
170 * Find the coordinates of an object relative to the top left of the page.
171 *
172 * @param {Node} obj
173 * @return {{x:number,y:number}}
174 * @private
175 */
176 Dygraph.findPos = function(obj) {
177 var p = obj.getBoundingClientRect(),
178 w = window,
179 d = document.documentElement;
180
181 return {
182 x: p.left + (w.pageXOffset || d.scrollLeft),
183 y: p.top + (w.pageYOffset || d.scrollTop)
184 }
185 };
186
187 /**
188 * Returns the x-coordinate of the event in a coordinate system where the
189 * top-left corner of the page (not the window) is (0,0).
190 * Taken from MochiKit.Signal
191 * @param {!Event} e
192 * @return {number}
193 * @private
194 */
195 Dygraph.pageX = function(e) {
196 return (!e.pageX || e.pageX < 0) ? 0 : e.pageX;
197 };
198
199 /**
200 * Returns the y-coordinate of the event in a coordinate system where the
201 * top-left corner of the page (not the window) is (0,0).
202 * Taken from MochiKit.Signal
203 * @param {!Event} e
204 * @return {number}
205 * @private
206 */
207 Dygraph.pageY = function(e) {
208 return (!e.pageY || e.pageY < 0) ? 0 : e.pageY;
209 };
210
211 /**
212 * Converts page the x-coordinate of the event to pixel x-coordinates on the
213 * canvas (i.e. DOM Coords).
214 * @param {!Event} e Drag event.
215 * @param {!DygraphInteractionContext} context Interaction context object.
216 * @return {number} The amount by which the drag has moved to the right.
217 */
218 Dygraph.dragGetX_ = function(e, context) {
219 return Dygraph.pageX(e) - context.px;
220 };
221
222 /**
223 * Converts page the y-coordinate of the event to pixel y-coordinates on the
224 * canvas (i.e. DOM Coords).
225 * @param {!Event} e Drag event.
226 * @param {!DygraphInteractionContext} context Interaction context object.
227 * @return {number} The amount by which the drag has moved down.
228 */
229 Dygraph.dragGetY_ = function(e, context) {
230 return Dygraph.pageY(e) - context.py;
231 };
232
233 /**
234 * This returns true unless the parameter is 0, null, undefined or NaN.
235 * TODO(danvk): rename this function to something like 'isNonZeroNan'.
236 *
237 * @param {number} x The number to consider.
238 * @return {boolean} Whether the number is zero or NaN.
239 * @private
240 */
241 Dygraph.isOK = function(x) {
242 return !!x && !isNaN(x);
243 };
244
245 /**
246 * @param {{x:?number,y:?number,yval:?number}} p The point to consider, valid
247 * points are {x, y} objects
248 * @param {boolean=} opt_allowNaNY Treat point with y=NaN as valid
249 * @return {boolean} Whether the point has numeric x and y.
250 * @private
251 */
252 Dygraph.isValidPoint = function(p, opt_allowNaNY) {
253 if (!p) return false; // null or undefined object
254 if (p.yval === null) return false; // missing point
255 if (p.x === null || p.x === undefined) return false;
256 if (p.y === null || p.y === undefined) return false;
257 if (isNaN(p.x) || (!opt_allowNaNY && isNaN(p.y))) return false;
258 return true;
259 };
260
261 /**
262 * Number formatting function which mimicks the behavior of %g in printf, i.e.
263 * either exponential or fixed format (without trailing 0s) is used depending on
264 * the length of the generated string. The advantage of this format is that
265 * there is a predictable upper bound on the resulting string length,
266 * significant figures are not dropped, and normal numbers are not displayed in
267 * exponential notation.
268 *
269 * NOTE: JavaScript's native toPrecision() is NOT a drop-in replacement for %g.
270 * It creates strings which are too long for absolute values between 10^-4 and
271 * 10^-6, e.g. '0.00001' instead of '1e-5'. See tests/number-format.html for
272 * output examples.
273 *
274 * @param {number} x The number to format
275 * @param {number=} opt_precision The precision to use, default 2.
276 * @return {string} A string formatted like %g in printf. The max generated
277 * string length should be precision + 6 (e.g 1.123e+300).
278 */
279 Dygraph.floatFormat = function(x, opt_precision) {
280 // Avoid invalid precision values; [1, 21] is the valid range.
281 var p = Math.min(Math.max(1, opt_precision || 2), 21);
282
283 // This is deceptively simple. The actual algorithm comes from:
284 //
285 // Max allowed length = p + 4
286 // where 4 comes from 'e+n' and '.'.
287 //
288 // Length of fixed format = 2 + y + p
289 // where 2 comes from '0.' and y = # of leading zeroes.
290 //
291 // Equating the two and solving for y yields y = 2, or 0.00xxxx which is
292 // 1.0e-3.
293 //
294 // Since the behavior of toPrecision() is identical for larger numbers, we
295 // don't have to worry about the other bound.
296 //
297 // Finally, the argument for toExponential() is the number of trailing digits,
298 // so we take off 1 for the value before the '.'.
299 return (Math.abs(x) < 1.0e-3 && x !== 0.0) ?
300 x.toExponential(p - 1) : x.toPrecision(p);
301 };
302
303 /**
304 * Converts '9' to '09' (useful for dates)
305 * @param {number} x
306 * @return {string}
307 * @private
308 */
309 Dygraph.zeropad = function(x) {
310 if (x < 10) return "0" + x; else return "" + x;
311 };
312
313 /**
314 * Date accessors to get the parts of a calendar date (year, month,
315 * day, hour, minute, second and millisecond) according to local time,
316 * and factory method to call the Date constructor with an array of arguments.
317 */
318 Dygraph.DateAccessorsLocal = {
319 getFullYear: function(d) {return d.getFullYear();},
320 getMonth: function(d) {return d.getMonth();},
321 getDate: function(d) {return d.getDate();},
322 getHours: function(d) {return d.getHours();},
323 getMinutes: function(d) {return d.getMinutes();},
324 getSeconds: function(d) {return d.getSeconds();},
325 getMilliseconds: function(d) {return d.getMilliseconds();},
326 getDay: function(d) {return d.getDay();},
327 makeDate: function(y, m, d, hh, mm, ss, ms) {
328 return new Date(y, m, d, hh, mm, ss, ms);
329 }
330 };
331
332 /**
333 * Date accessors to get the parts of a calendar date (year, month,
334 * day of month, hour, minute, second and millisecond) according to UTC time,
335 * and factory method to call the Date constructor with an array of arguments.
336 */
337 Dygraph.DateAccessorsUTC = {
338 getFullYear: function(d) {return d.getUTCFullYear();},
339 getMonth: function(d) {return d.getUTCMonth();},
340 getDate: function(d) {return d.getUTCDate();},
341 getHours: function(d) {return d.getUTCHours();},
342 getMinutes: function(d) {return d.getUTCMinutes();},
343 getSeconds: function(d) {return d.getUTCSeconds();},
344 getMilliseconds: function(d) {return d.getUTCMilliseconds();},
345 getDay: function(d) {return d.getUTCDay();},
346 makeDate: function(y, m, d, hh, mm, ss, ms) {
347 return new Date(Date.UTC(y, m, d, hh, mm, ss, ms));
348 }
349 };
350
351 /**
352 * Return a string version of the hours, minutes and seconds portion of a date.
353 * @param {number} hh The hours (from 0-23)
354 * @param {number} mm The minutes (from 0-59)
355 * @param {number} ss The seconds (from 0-59)
356 * @return {string} A time of the form "HH:MM" or "HH:MM:SS"
357 * @private
358 */
359 Dygraph.hmsString_ = function(hh, mm, ss) {
360 var zeropad = Dygraph.zeropad;
361 var ret = zeropad(hh) + ":" + zeropad(mm);
362 if (ss) {
363 ret += ":" + zeropad(ss);
364 }
365 return ret;
366 };
367
368 /**
369 * Convert a JS date (millis since epoch) to a formatted string.
370 * @param {number} time The JavaScript time value (ms since epoch)
371 * @param {boolean} utc Wether output UTC or local time
372 * @return {string} A date of one of these forms:
373 * "YYYY/MM/DD", "YYYY/MM/DD HH:MM" or "YYYY/MM/DD HH:MM:SS"
374 * @private
375 */
376 Dygraph.dateString_ = function(time, utc) {
377 var zeropad = Dygraph.zeropad;
378 var accessors = utc ? Dygraph.DateAccessorsUTC : Dygraph.DateAccessorsLocal;
379 var date = new Date(time);
380 var y = accessors.getFullYear(date);
381 var m = accessors.getMonth(date);
382 var d = accessors.getDate(date);
383 var hh = accessors.getHours(date);
384 var mm = accessors.getMinutes(date);
385 var ss = accessors.getSeconds(date);
386 // Get a year string:
387 var year = "" + y;
388 // Get a 0 padded month string
389 var month = zeropad(m + 1); //months are 0-offset, sigh
390 // Get a 0 padded day string
391 var day = zeropad(d);
392 var frac = hh * 3600 + mm * 60 + ss;
393 var ret = year + "/" + month + "/" + day;
394 if (frac) {
395 ret += " " + Dygraph.hmsString_(hh, mm, ss);
396 }
397 return ret;
398 };
399
400 /**
401 * Round a number to the specified number of digits past the decimal point.
402 * @param {number} num The number to round
403 * @param {number} places The number of decimals to which to round
404 * @return {number} The rounded number
405 * @private
406 */
407 Dygraph.round_ = function(num, places) {
408 var shift = Math.pow(10, places);
409 return Math.round(num * shift)/shift;
410 };
411
412 /**
413 * Implementation of binary search over an array.
414 * Currently does not work when val is outside the range of arry's values.
415 * @param {number} val the value to search for
416 * @param {Array.<number>} arry is the value over which to search
417 * @param {number} abs If abs > 0, find the lowest entry greater than val
418 * If abs < 0, find the highest entry less than val.
419 * If abs == 0, find the entry that equals val.
420 * @param {number=} low The first index in arry to consider (optional)
421 * @param {number=} high The last index in arry to consider (optional)
422 * @return {number} Index of the element, or -1 if it isn't found.
423 * @private
424 */
425 Dygraph.binarySearch = function(val, arry, abs, low, high) {
426 if (low === null || low === undefined ||
427 high === null || high === undefined) {
428 low = 0;
429 high = arry.length - 1;
430 }
431 if (low > high) {
432 return -1;
433 }
434 if (abs === null || abs === undefined) {
435 abs = 0;
436 }
437 var validIndex = function(idx) {
438 return idx >= 0 && idx < arry.length;
439 };
440 var mid = parseInt((low + high) / 2, 10);
441 var element = arry[mid];
442 var idx;
443 if (element == val) {
444 return mid;
445 } else if (element > val) {
446 if (abs > 0) {
447 // Accept if element > val, but also if prior element < val.
448 idx = mid - 1;
449 if (validIndex(idx) && arry[idx] < val) {
450 return mid;
451 }
452 }
453 return Dygraph.binarySearch(val, arry, abs, low, mid - 1);
454 } else if (element < val) {
455 if (abs < 0) {
456 // Accept if element < val, but also if prior element > val.
457 idx = mid + 1;
458 if (validIndex(idx) && arry[idx] > val) {
459 return mid;
460 }
461 }
462 return Dygraph.binarySearch(val, arry, abs, mid + 1, high);
463 }
464 return -1; // can't actually happen, but makes closure compiler happy
465 };
466
467 /**
468 * Parses a date, returning the number of milliseconds since epoch. This can be
469 * passed in as an xValueParser in the Dygraph constructor.
470 * TODO(danvk): enumerate formats that this understands.
471 *
472 * @param {string} dateStr A date in a variety of possible string formats.
473 * @return {number} Milliseconds since epoch.
474 * @private
475 */
476 Dygraph.dateParser = function(dateStr) {
477 var dateStrSlashed;
478 var d;
479
480 // Let the system try the format first, with one caveat:
481 // YYYY-MM-DD[ HH:MM:SS] is interpreted as UTC by a variety of browsers.
482 // dygraphs displays dates in local time, so this will result in surprising
483 // inconsistencies. But if you specify "T" or "Z" (i.e. YYYY-MM-DDTHH:MM:SS),
484 // then you probably know what you're doing, so we'll let you go ahead.
485 // Issue: http://code.google.com/p/dygraphs/issues/detail?id=255
486 if (dateStr.search("-") == -1 ||
487 dateStr.search("T") != -1 || dateStr.search("Z") != -1) {
488 d = Dygraph.dateStrToMillis(dateStr);
489 if (d && !isNaN(d)) return d;
490 }
491
492 if (dateStr.search("-") != -1) { // e.g. '2009-7-12' or '2009-07-12'
493 dateStrSlashed = dateStr.replace("-", "/", "g");
494 while (dateStrSlashed.search("-") != -1) {
495 dateStrSlashed = dateStrSlashed.replace("-", "/");
496 }
497 d = Dygraph.dateStrToMillis(dateStrSlashed);
498 } else if (dateStr.length == 8) { // e.g. '20090712'
499 // TODO(danvk): remove support for this format. It's confusing.
500 dateStrSlashed = dateStr.substr(0,4) + "/" + dateStr.substr(4,2) + "/" +
501 dateStr.substr(6,2);
502 d = Dygraph.dateStrToMillis(dateStrSlashed);
503 } else {
504 // Any format that Date.parse will accept, e.g. "2009/07/12" or
505 // "2009/07/12 12:34:56"
506 d = Dygraph.dateStrToMillis(dateStr);
507 }
508
509 if (!d || isNaN(d)) {
510 console.error("Couldn't parse " + dateStr + " as a date");
511 }
512 return d;
513 };
514
515 /**
516 * This is identical to JavaScript's built-in Date.parse() method, except that
517 * it doesn't get replaced with an incompatible method by aggressive JS
518 * libraries like MooTools or Joomla.
519 * @param {string} str The date string, e.g. "2011/05/06"
520 * @return {number} millis since epoch
521 * @private
522 */
523 Dygraph.dateStrToMillis = function(str) {
524 return new Date(str).getTime();
525 };
526
527 // These functions are all based on MochiKit.
528 /**
529 * Copies all the properties from o to self.
530 *
531 * @param {!Object} self
532 * @param {!Object} o
533 * @return {!Object}
534 */
535 Dygraph.update = function(self, o) {
536 if (typeof(o) != 'undefined' && o !== null) {
537 for (var k in o) {
538 if (o.hasOwnProperty(k)) {
539 self[k] = o[k];
540 }
541 }
542 }
543 return self;
544 };
545
546 /**
547 * Copies all the properties from o to self.
548 *
549 * @param {!Object} self
550 * @param {!Object} o
551 * @return {!Object}
552 * @private
553 */
554 Dygraph.updateDeep = function (self, o) {
555 // Taken from http://stackoverflow.com/questions/384286/javascript-isdom-how-do-you-check-if-a-javascript-object-is-a-dom-object
556 function isNode(o) {
557 return (
558 typeof Node === "object" ? o instanceof Node :
559 typeof o === "object" && typeof o.nodeType === "number" && typeof o.nodeName==="string"
560 );
561 }
562
563 if (typeof(o) != 'undefined' && o !== null) {
564 for (var k in o) {
565 if (o.hasOwnProperty(k)) {
566 if (o[k] === null) {
567 self[k] = null;
568 } else if (Dygraph.isArrayLike(o[k])) {
569 self[k] = o[k].slice();
570 } else if (isNode(o[k])) {
571 // DOM objects are shallowly-copied.
572 self[k] = o[k];
573 } else if (typeof(o[k]) == 'object') {
574 if (typeof(self[k]) != 'object' || self[k] === null) {
575 self[k] = {};
576 }
577 Dygraph.updateDeep(self[k], o[k]);
578 } else {
579 self[k] = o[k];
580 }
581 }
582 }
583 }
584 return self;
585 };
586
587 /**
588 * @param {*} o
589 * @return {boolean}
590 * @private
591 */
592 Dygraph.isArrayLike = function(o) {
593 var typ = typeof(o);
594 if (
595 (typ != 'object' && !(typ == 'function' &&
596 typeof(o.item) == 'function')) ||
597 o === null ||
598 typeof(o.length) != 'number' ||
599 o.nodeType === 3
600 ) {
601 return false;
602 }
603 return true;
604 };
605
606 /**
607 * @param {Object} o
608 * @return {boolean}
609 * @private
610 */
611 Dygraph.isDateLike = function (o) {
612 if (typeof(o) != "object" || o === null ||
613 typeof(o.getTime) != 'function') {
614 return false;
615 }
616 return true;
617 };
618
619 /**
620 * Note: this only seems to work for arrays.
621 * @param {!Array} o
622 * @return {!Array}
623 * @private
624 */
625 Dygraph.clone = function(o) {
626 // TODO(danvk): figure out how MochiKit's version works
627 var r = [];
628 for (var i = 0; i < o.length; i++) {
629 if (Dygraph.isArrayLike(o[i])) {
630 r.push(Dygraph.clone(o[i]));
631 } else {
632 r.push(o[i]);
633 }
634 }
635 return r;
636 };
637
638 /**
639 * Create a new canvas element.
640 *
641 * @return {!HTMLCanvasElement}
642 * @private
643 */
644 Dygraph.createCanvas = function() {
645 return document.createElement('canvas');
646 };
647
648 /**
649 * Returns the context's pixel ratio, which is the ratio between the device
650 * pixel ratio and the backing store ratio. Typically this is 1 for conventional
651 * displays, and > 1 for HiDPI displays (such as the Retina MBP).
652 * See http://www.html5rocks.com/en/tutorials/canvas/hidpi/ for more details.
653 *
654 * @param {!CanvasRenderingContext2D} context The canvas's 2d context.
655 * @return {number} The ratio of the device pixel ratio and the backing store
656 * ratio for the specified context.
657 */
658 Dygraph.getContextPixelRatio = function(context) {
659 try {
660 var devicePixelRatio = window.devicePixelRatio;
661 var backingStoreRatio = context.webkitBackingStorePixelRatio ||
662 context.mozBackingStorePixelRatio ||
663 context.msBackingStorePixelRatio ||
664 context.oBackingStorePixelRatio ||
665 context.backingStorePixelRatio || 1;
666 if (devicePixelRatio !== undefined) {
667 return devicePixelRatio / backingStoreRatio;
668 } else {
669 // At least devicePixelRatio must be defined for this ratio to make sense.
670 // We default backingStoreRatio to 1: this does not exist on some browsers
671 // (i.e. desktop Chrome).
672 return 1;
673 }
674 } catch (e) {
675 return 1;
676 }
677 };
678
679 /**
680 * Checks whether the user is on an Android browser.
681 * Android does not fully support the <canvas> tag, e.g. w/r/t/ clipping.
682 * @return {boolean}
683 * @private
684 */
685 Dygraph.isAndroid = function() {
686 return (/Android/).test(navigator.userAgent);
687 };
688
689
690 /**
691 * TODO(danvk): use @template here when it's better supported for classes.
692 * @param {!Array} array
693 * @param {number} start
694 * @param {number} length
695 * @param {function(!Array,?):boolean=} predicate
696 * @constructor
697 */
698 Dygraph.Iterator = function(array, start, length, predicate) {
699 start = start || 0;
700 length = length || array.length;
701 this.hasNext = true; // Use to identify if there's another element.
702 this.peek = null; // Use for look-ahead
703 this.start_ = start;
704 this.array_ = array;
705 this.predicate_ = predicate;
706 this.end_ = Math.min(array.length, start + length);
707 this.nextIdx_ = start - 1; // use -1 so initial advance works.
708 this.next(); // ignoring result.
709 };
710
711 /**
712 * @return {Object}
713 */
714 Dygraph.Iterator.prototype.next = function() {
715 if (!this.hasNext) {
716 return null;
717 }
718 var obj = this.peek;
719
720 var nextIdx = this.nextIdx_ + 1;
721 var found = false;
722 while (nextIdx < this.end_) {
723 if (!this.predicate_ || this.predicate_(this.array_, nextIdx)) {
724 this.peek = this.array_[nextIdx];
725 found = true;
726 break;
727 }
728 nextIdx++;
729 }
730 this.nextIdx_ = nextIdx;
731 if (!found) {
732 this.hasNext = false;
733 this.peek = null;
734 }
735 return obj;
736 };
737
738 /**
739 * Returns a new iterator over array, between indexes start and
740 * start + length, and only returns entries that pass the accept function
741 *
742 * @param {!Array} array the array to iterate over.
743 * @param {number} start the first index to iterate over, 0 if absent.
744 * @param {number} length the number of elements in the array to iterate over.
745 * This, along with start, defines a slice of the array, and so length
746 * doesn't imply the number of elements in the iterator when accept doesn't
747 * always accept all values. array.length when absent.
748 * @param {function(?):boolean=} opt_predicate a function that takes
749 * parameters array and idx, which returns true when the element should be
750 * returned. If omitted, all elements are accepted.
751 * @private
752 */
753 Dygraph.createIterator = function(array, start, length, opt_predicate) {
754 return new Dygraph.Iterator(array, start, length, opt_predicate);
755 };
756
757 // Shim layer with setTimeout fallback.
758 // From: http://paulirish.com/2011/requestanimationframe-for-smart-animating/
759 // Should be called with the window context:
760 // Dygraph.requestAnimFrame.call(window, function() {})
761 Dygraph.requestAnimFrame = (function() {
762 return window.requestAnimationFrame ||
763 window.webkitRequestAnimationFrame ||
764 window.mozRequestAnimationFrame ||
765 window.oRequestAnimationFrame ||
766 window.msRequestAnimationFrame ||
767 function (callback) {
768 window.setTimeout(callback, 1000 / 60);
769 };
770 })();
771
772 /**
773 * Call a function at most maxFrames times at an attempted interval of
774 * framePeriodInMillis, then call a cleanup function once. repeatFn is called
775 * once immediately, then at most (maxFrames - 1) times asynchronously. If
776 * maxFrames==1, then cleanup_fn() is also called synchronously. This function
777 * is used to sequence animation.
778 * @param {function(number)} repeatFn Called repeatedly -- takes the frame
779 * number (from 0 to maxFrames-1) as an argument.
780 * @param {number} maxFrames The max number of times to call repeatFn
781 * @param {number} framePeriodInMillis Max requested time between frames.
782 * @param {function()} cleanupFn A function to call after all repeatFn calls.
783 * @private
784 */
785 Dygraph.repeatAndCleanup = function(repeatFn, maxFrames, framePeriodInMillis,
786 cleanupFn) {
787 var frameNumber = 0;
788 var previousFrameNumber;
789 var startTime = new Date().getTime();
790 repeatFn(frameNumber);
791 if (maxFrames == 1) {
792 cleanupFn();
793 return;
794 }
795 var maxFrameArg = maxFrames - 1;
796
797 (function loop() {
798 if (frameNumber >= maxFrames) return;
799 Dygraph.requestAnimFrame.call(window, function() {
800 // Determine which frame to draw based on the delay so far. Will skip
801 // frames if necessary.
802 var currentTime = new Date().getTime();
803 var delayInMillis = currentTime - startTime;
804 previousFrameNumber = frameNumber;
805 frameNumber = Math.floor(delayInMillis / framePeriodInMillis);
806 var frameDelta = frameNumber - previousFrameNumber;
807 // If we predict that the subsequent repeatFn call will overshoot our
808 // total frame target, so our last call will cause a stutter, then jump to
809 // the last call immediately. If we're going to cause a stutter, better
810 // to do it faster than slower.
811 var predictOvershootStutter = (frameNumber + frameDelta) > maxFrameArg;
812 if (predictOvershootStutter || (frameNumber >= maxFrameArg)) {
813 repeatFn(maxFrameArg); // Ensure final call with maxFrameArg.
814 cleanupFn();
815 } else {
816 if (frameDelta !== 0) { // Don't call repeatFn with duplicate frames.
817 repeatFn(frameNumber);
818 }
819 loop();
820 }
821 });
822 })();
823 };
824
825 // A whitelist of options that do not change pixel positions.
826 var pixelSafeOptions = {
827 'annotationClickHandler': true,
828 'annotationDblClickHandler': true,
829 'annotationMouseOutHandler': true,
830 'annotationMouseOverHandler': true,
831 'axisLabelColor': true,
832 'axisLineColor': true,
833 'axisLineWidth': true,
834 'clickCallback': true,
835 'drawCallback': true,
836 'drawHighlightPointCallback': true,
837 'drawPoints': true,
838 'drawPointCallback': true,
839 'drawGrid': true,
840 'fillAlpha': true,
841 'gridLineColor': true,
842 'gridLineWidth': true,
843 'hideOverlayOnMouseOut': true,
844 'highlightCallback': true,
845 'highlightCircleSize': true,
846 'interactionModel': true,
847 'isZoomedIgnoreProgrammaticZoom': true,
848 'labelsDiv': true,
849 'labelsDivStyles': true,
850 'labelsDivWidth': true,
851 'labelsKMB': true,
852 'labelsKMG2': true,
853 'labelsSeparateLines': true,
854 'labelsShowZeroValues': true,
855 'legend': true,
856 'panEdgeFraction': true,
857 'pixelsPerYLabel': true,
858 'pointClickCallback': true,
859 'pointSize': true,
860 'rangeSelectorPlotFillColor': true,
861 'rangeSelectorPlotFillGradientColor': true,
862 'rangeSelectorPlotStrokeColor': true,
863 'rangeSelectorBackgroundStrokeColor': true,
864 'rangeSelectorBackgroundLineWidth': true,
865 'rangeSelectorPlotLineWidth': true,
866 'rangeSelectorForegroundStrokeColor': true,
867 'rangeSelectorForegroundLineWidth': true,
868 'rangeSelectorAlpha': true,
869 'showLabelsOnHighlight': true,
870 'showRoller': true,
871 'strokeWidth': true,
872 'underlayCallback': true,
873 'unhighlightCallback': true,
874 'zoomCallback': true
875 };
876
877 /**
878 * This function will scan the option list and determine if they
879 * require us to recalculate the pixel positions of each point.
880 * TODO: move this into dygraph-options.js
881 * @param {!Array.<string>} labels a list of options to check.
882 * @param {!Object} attrs
883 * @return {boolean} true if the graph needs new points else false.
884 * @private
885 */
886 Dygraph.isPixelChangingOptionList = function(labels, attrs) {
887 // Assume that we do not require new points.
888 // This will change to true if we actually do need new points.
889
890 // Create a dictionary of series names for faster lookup.
891 // If there are no labels, then the dictionary stays empty.
892 var seriesNamesDictionary = { };
893 if (labels) {
894 for (var i = 1; i < labels.length; i++) {
895 seriesNamesDictionary[labels[i]] = true;
896 }
897 }
898
899 // Scan through a flat (i.e. non-nested) object of options.
900 // Returns true/false depending on whether new points are needed.
901 var scanFlatOptions = function(options) {
902 for (var property in options) {
903 if (options.hasOwnProperty(property) &&
904 !pixelSafeOptions[property]) {
905 return true;
906 }
907 }
908 return false;
909 };
910
911 // Iterate through the list of updated options.
912 for (var property in attrs) {
913 if (!attrs.hasOwnProperty(property)) continue;
914
915 // Find out of this field is actually a series specific options list.
916 if (property == 'highlightSeriesOpts' ||
917 (seriesNamesDictionary[property] && !attrs.series)) {
918 // This property value is a list of options for this series.
919 if (scanFlatOptions(attrs[property])) return true;
920 } else if (property == 'series' || property == 'axes') {
921 // This is twice-nested options list.
922 var perSeries = attrs[property];
923 for (var series in perSeries) {
924 if (perSeries.hasOwnProperty(series) &&
925 scanFlatOptions(perSeries[series])) {
926 return true;
927 }
928 }
929 } else {
930 // If this was not a series specific option list, check if it's a pixel
931 // changing property.
932 if (!pixelSafeOptions[property]) return true;
933 }
934 }
935
936 return false;
937 };
938
939 Dygraph.Circles = {
940 DEFAULT : function(g, name, ctx, canvasx, canvasy, color, radius) {
941 ctx.beginPath();
942 ctx.fillStyle = color;
943 ctx.arc(canvasx, canvasy, radius, 0, 2 * Math.PI, false);
944 ctx.fill();
945 }
946 // For more shapes, include extras/shapes.js
947 };
948
949 /**
950 * To create a "drag" interaction, you typically register a mousedown event
951 * handler on the element where the drag begins. In that handler, you register a
952 * mouseup handler on the window to determine when the mouse is released,
953 * wherever that release happens. This works well, except when the user releases
954 * the mouse over an off-domain iframe. In that case, the mouseup event is
955 * handled by the iframe and never bubbles up to the window handler.
956 *
957 * To deal with this issue, we cover iframes with high z-index divs to make sure
958 * they don't capture mouseup.
959 *
960 * Usage:
961 * element.addEventListener('mousedown', function() {
962 * var tarper = new Dygraph.IFrameTarp();
963 * tarper.cover();
964 * var mouseUpHandler = function() {
965 * ...
966 * window.removeEventListener(mouseUpHandler);
967 * tarper.uncover();
968 * };
969 * window.addEventListener('mouseup', mouseUpHandler);
970 * };
971 *
972 * @constructor
973 */
974 Dygraph.IFrameTarp = function() {
975 /** @type {Array.<!HTMLDivElement>} */
976 this.tarps = [];
977 };
978
979 /**
980 * Find all the iframes in the document and cover them with high z-index
981 * transparent divs.
982 */
983 Dygraph.IFrameTarp.prototype.cover = function() {
984 var iframes = document.getElementsByTagName("iframe");
985 for (var i = 0; i < iframes.length; i++) {
986 var iframe = iframes[i];
987 var pos = Dygraph.findPos(iframe),
988 x = pos.x,
989 y = pos.y,
990 width = iframe.offsetWidth,
991 height = iframe.offsetHeight;
992
993 var div = document.createElement("div");
994 div.style.position = "absolute";
995 div.style.left = x + 'px';
996 div.style.top = y + 'px';
997 div.style.width = width + 'px';
998 div.style.height = height + 'px';
999 div.style.zIndex = 999;
1000 document.body.appendChild(div);
1001 this.tarps.push(div);
1002 }
1003 };
1004
1005 /**
1006 * Remove all the iframe covers. You should call this in a mouseup handler.
1007 */
1008 Dygraph.IFrameTarp.prototype.uncover = function() {
1009 for (var i = 0; i < this.tarps.length; i++) {
1010 this.tarps[i].parentNode.removeChild(this.tarps[i]);
1011 }
1012 this.tarps = [];
1013 };
1014
1015 /**
1016 * Determine whether |data| is delimited by CR, CRLF, LF, LFCR.
1017 * @param {string} data
1018 * @return {?string} the delimiter that was detected (or null on failure).
1019 */
1020 Dygraph.detectLineDelimiter = function(data) {
1021 for (var i = 0; i < data.length; i++) {
1022 var code = data.charAt(i);
1023 if (code === '\r') {
1024 // Might actually be "\r\n".
1025 if (((i + 1) < data.length) && (data.charAt(i + 1) === '\n')) {
1026 return '\r\n';
1027 }
1028 return code;
1029 }
1030 if (code === '\n') {
1031 // Might actually be "\n\r".
1032 if (((i + 1) < data.length) && (data.charAt(i + 1) === '\r')) {
1033 return '\n\r';
1034 }
1035 return code;
1036 }
1037 }
1038
1039 return null;
1040 };
1041
1042 /**
1043 * Is one node contained by another?
1044 * @param {Node} containee The contained node.
1045 * @param {Node} container The container node.
1046 * @return {boolean} Whether containee is inside (or equal to) container.
1047 * @private
1048 */
1049 Dygraph.isNodeContainedBy = function(containee, container) {
1050 if (container === null || containee === null) {
1051 return false;
1052 }
1053 var containeeNode = /** @type {Node} */ (containee);
1054 while (containeeNode && containeeNode !== container) {
1055 containeeNode = containeeNode.parentNode;
1056 }
1057 return (containeeNode === container);
1058 };
1059
1060
1061 // This masks some numeric issues in older versions of Firefox,
1062 // where 1.0/Math.pow(10,2) != Math.pow(10,-2).
1063 /** @type {function(number,number):number} */
1064 Dygraph.pow = function(base, exp) {
1065 if (exp < 0) {
1066 return 1.0 / Math.pow(base, -exp);
1067 }
1068 return Math.pow(base, exp);
1069 };
1070
1071 /**
1072 * Converts any valid CSS color (hex, rgb(), named color) to an RGB tuple.
1073 *
1074 * @param {!string} colorStr Any valid CSS color string.
1075 * @return {{r:number,g:number,b:number}} Parsed RGB tuple.
1076 * @private
1077 */
1078 Dygraph.toRGB_ = function(colorStr) {
1079 // TODO(danvk): cache color parses to avoid repeated DOM manipulation.
1080 var div = document.createElement('div');
1081 div.style.backgroundColor = colorStr;
1082 div.style.visibility = 'hidden';
1083 document.body.appendChild(div);
1084 var rgbStr = window.getComputedStyle(div, null).backgroundColor;
1085 document.body.removeChild(div);
1086 var bits = /^rgb\((\d{1,3}),\s*(\d{1,3}),\s*(\d{1,3})\)$/.exec(rgbStr);
1087 return {
1088 r: parseInt(bits[1], 10),
1089 g: parseInt(bits[2], 10),
1090 b: parseInt(bits[3], 10)
1091 };
1092 };
1093
1094 /**
1095 * Checks whether the browser supports the &lt;canvas&gt; tag.
1096 * @param {HTMLCanvasElement=} opt_canvasElement Pass a canvas element as an
1097 * optimization if you have one.
1098 * @return {boolean} Whether the browser supports canvas.
1099 */
1100 Dygraph.isCanvasSupported = function(opt_canvasElement) {
1101 try {
1102 var canvas = opt_canvasElement || document.createElement("canvas");
1103 canvas.getContext("2d");
1104 } catch (e) {
1105 return false;
1106 }
1107 return true;
1108 };
1109
1110 /**
1111 * Parses the value as a floating point number. This is like the parseFloat()
1112 * built-in, but with a few differences:
1113 * - the empty string is parsed as null, rather than NaN.
1114 * - if the string cannot be parsed at all, an error is logged.
1115 * If the string can't be parsed, this method returns null.
1116 * @param {string} x The string to be parsed
1117 * @param {number=} opt_line_no The line number from which the string comes.
1118 * @param {string=} opt_line The text of the line from which the string comes.
1119 */
1120 Dygraph.parseFloat_ = function(x, opt_line_no, opt_line) {
1121 var val = parseFloat(x);
1122 if (!isNaN(val)) return val;
1123
1124 // Try to figure out what happeend.
1125 // If the value is the empty string, parse it as null.
1126 if (/^ *$/.test(x)) return null;
1127
1128 // If it was actually "NaN", return it as NaN.
1129 if (/^ *nan *$/i.test(x)) return NaN;
1130
1131 // Looks like a parsing error.
1132 var msg = "Unable to parse '" + x + "' as a number";
1133 if (opt_line !== undefined && opt_line_no !== undefined) {
1134 msg += " on line " + (1+(opt_line_no||0)) + " ('" + opt_line + "') of CSV.";
1135 }
1136 console.error(msg);
1137
1138 return null;
1139 };
1140
1141 })();