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