X-Git-Url: https://adrianiainlam.tk/git/?a=blobdiff_plain;f=dygraph-utils.js;h=73777b91828d3574aa96d2139fd00d3f0d40968a;hb=e8c635cc4e3c265e88f66b46b689e291531330b6;hp=dd8c620f70b47dd9a9d637016305e0bf7adc310a;hpb=e276946939d737f58e904c94fa067e937a263d1e;p=dygraphs.git diff --git a/dygraph-utils.js b/dygraph-utils.js index dd8c620..73777b9 100644 --- a/dygraph-utils.js +++ b/dygraph-utils.js @@ -12,29 +12,21 @@ */ /*jshint globalstrict: true */ -/*global Dygraph:false, G_vmlCanvasManager:false, Node:false, printStackTrace: false */ +/*global Dygraph:false, G_vmlCanvasManager:false, Node:false */ "use strict"; Dygraph.LOG_SCALE = 10; Dygraph.LN_TEN = Math.log(Dygraph.LOG_SCALE); -/** @private */ +/** + * @private + * @param {number} x + * @return {number} + */ Dygraph.log10 = function(x) { return Math.log(x) / Dygraph.LN_TEN; }; -// Various logging levels. -Dygraph.DEBUG = 1; -Dygraph.INFO = 2; -Dygraph.WARNING = 3; -Dygraph.ERROR = 3; - -// Set this to log stack traces on warnings, etc. -// This requires stacktrace.js, which is up to you to provide. -// A copy can be found in the dygraphs repo, or at -// https://github.com/eriwen/javascript-stacktrace -Dygraph.LOG_STACK_TRACES = false; - /** A dotted line stroke pattern. */ Dygraph.DOTTED_LINE = [2, 2]; /** A dashed line stroke pattern. */ @@ -43,79 +35,6 @@ Dygraph.DASHED_LINE = [7, 3]; Dygraph.DOT_DASH_LINE = [7, 2, 2, 2]; /** - * @private - * Log an error on the JS console at the given severity. - * @param { Integer } severity One of Dygraph.{DEBUG,INFO,WARNING,ERROR} - * @param { String } The message to log. - */ -Dygraph.log = function(severity, message) { - var st; - if (typeof(printStackTrace) != 'undefined') { - try { - // Remove uninteresting bits: logging functions and paths. - st = printStackTrace({guess:false}); - while (st[0].indexOf("stacktrace") != -1) { - st.splice(0, 1); - } - - st.splice(0, 2); - for (var i = 0; i < st.length; i++) { - st[i] = st[i].replace(/\([^)]*\/(.*)\)/, '@$1') - .replace(/\@.*\/([^\/]*)/, '@$1') - .replace('[object Object].', ''); - } - var top_msg = st.splice(0, 1)[0]; - message += ' (' + top_msg.replace(/^.*@ ?/, '') + ')'; - } catch(e) { - // Oh well, it was worth a shot! - } - } - - if (typeof(console) != 'undefined') { - switch (severity) { - case Dygraph.DEBUG: - console.debug('dygraphs: ' + message); - break; - case Dygraph.INFO: - console.info('dygraphs: ' + message); - break; - case Dygraph.WARNING: - console.warn('dygraphs: ' + message); - break; - case Dygraph.ERROR: - console.error('dygraphs: ' + message); - break; - } - } - - if (Dygraph.LOG_STACK_TRACES) { - console.log(st.join('\n')); - } -}; - -/** @private */ -Dygraph.info = function(message) { - Dygraph.log(Dygraph.INFO, message); -}; -/** @private */ -Dygraph.prototype.info = Dygraph.info; - -/** @private */ -Dygraph.warn = function(message) { - Dygraph.log(Dygraph.WARNING, message); -}; -/** @private */ -Dygraph.prototype.warn = Dygraph.warn; - -/** @private */ -Dygraph.error = function(message) { - Dygraph.log(Dygraph.ERROR, message); -}; -/** @private */ -Dygraph.prototype.error = Dygraph.error; - -/** - * @private * Return the 2d context for a dygraph canvas. * * This method is only exposed for the sake of replacing the function in @@ -126,19 +45,22 @@ Dygraph.prototype.error = Dygraph.error; * var realContext = oldFunc(canvas); * return new Proxy(realContext); * }; + * @param {!HTMLCanvasElement} canvas + * @return {!CanvasRenderingContext2D} + * @private */ Dygraph.getContext = function(canvas) { - return canvas.getContext("2d"); + return /** @type{!CanvasRenderingContext2D}*/(canvas.getContext("2d")); }; /** - * @private * Add an event handler. This smooths a difference between IE and the rest of * the world. - * @param { DOM element } elem The element to add the event to. - * @param { String } type The type of the event, e.g. 'click' or 'mousemove'. - * @param { Function } fn The function to call on the event. The function takes - * one parameter: the event object. + * @param {!Node} elem The element to add the event to. + * @param {string} type The type of the event, e.g. 'click' or 'mousemove'. + * @param {function(Event):(boolean|undefined)} fn The function to call + * on the event. The function takes one parameter: the event object. + * @private */ Dygraph.addEvent = function addEvent(elem, type, fn) { if (elem.addEventListener) { @@ -150,30 +72,30 @@ Dygraph.addEvent = function addEvent(elem, type, fn) { }; /** - * @private * Add an event handler. This event handler is kept until the graph is * destroyed with a call to graph.destroy(). * - * @param { DOM element } elem The element to add the event to. - * @param { String } type The type of the event, e.g. 'click' or 'mousemove'. - * @param { Function } fn The function to call on the event. The function takes - * one parameter: the event object. + * @param {!Node} elem The element to add the event to. + * @param {string} type The type of the event, e.g. 'click' or 'mousemove'. + * @param {function(Event):(boolean|undefined)} fn The function to call + * on the event. The function takes one parameter: the event object. + * @private */ -Dygraph.prototype.addEvent = function addEvent(elem, type, fn) { +Dygraph.prototype.addAndTrackEvent = function(elem, type, fn) { Dygraph.addEvent(elem, type, fn); this.registeredEvents_.push({ elem : elem, type : type, fn : fn }); }; /** + * Remove an event handler. This smooths a difference between IE and the rest + * of the world. + * @param {!Node} elem The element to remove the event from. + * @param {string} type The type of the event, e.g. 'click' or 'mousemove'. + * @param {function(Event):(boolean|undefined)} fn The function to call + * on the event. The function takes one parameter: the event object. * @private - * Remove an event handler. This smooths a difference between IE and the rest of - * the world. - * @param { DOM element } elem The element to add the event to. - * @param { String } type The type of the event, e.g. 'click' or 'mousemove'. - * @param { Function } fn The function to call on the event. The function takes - * one parameter: the event object. */ -Dygraph.removeEvent = function addEvent(elem, type, fn) { +Dygraph.removeEvent = function(elem, type, fn) { if (elem.removeEventListener) { elem.removeEventListener(type, fn, false); } else { @@ -187,13 +109,24 @@ Dygraph.removeEvent = function addEvent(elem, type, fn) { } }; +Dygraph.prototype.removeTrackedEvents_ = function() { + if (this.registeredEvents_) { + for (var idx = 0; idx < this.registeredEvents_.length; idx++) { + var reg = this.registeredEvents_[idx]; + Dygraph.removeEvent(reg.elem, reg.type, reg.fn); + } + } + + this.registeredEvents_ = []; +}; + /** - * @private * Cancels further processing of an event. This is useful to prevent default * browser actions, e.g. highlighting text on a double-click. * Based on the article at * http://www.switchonthecode.com/tutorials/javascript-tutorial-the-scroll-wheel - * @param { Event } e The event whose normal behavior should be canceled. + * @param {!Event} e The event whose normal behavior should be canceled. + * @private */ Dygraph.cancelEvent = function(e) { e = e ? e : window.event; @@ -213,10 +146,10 @@ Dygraph.cancelEvent = function(e) { * Convert hsv values to an rgb(r,g,b) string. Taken from MochiKit.Color. This * is used to generate default series colors which are evenly spaced on the * color wheel. - * @param { Number } hue Range is 0.0-1.0. - * @param { Number } saturation Range is 0.0-1.0. - * @param { Number } value Range is 0.0-1.0. - * @return { String } "rgb(r,g,b)" where r, g and b range from 0-255. + * @param { number } hue Range is 0.0-1.0. + * @param { number } saturation Range is 0.0-1.0. + * @param { number } value Range is 0.0-1.0. + * @return { string } "rgb(r,g,b)" where r, g and b range from 0-255. * @private */ Dygraph.hsvToRGB = function (hue, saturation, value) { @@ -255,70 +188,62 @@ Dygraph.hsvToRGB = function (hue, saturation, value) { // ... and modifications to support scrolling divs. /** - * Find the x-coordinate of the supplied object relative to the left side - * of the page. + * Find the coordinates of an object relative to the top left of the page. + * + * TODO(danvk): change obj type from Node -> !Node + * @param {Node} obj + * @return {{x:number,y:number}} * @private */ -Dygraph.findPosX = function(obj) { - var curleft = 0; - if(obj.offsetParent) { +Dygraph.findPos = function(obj) { + var curleft = 0, curtop = 0; + if (obj.offsetParent) { var copyObj = obj; - while(1) { - curleft += copyObj.offsetLeft; - if(!copyObj.offsetParent) { - break; + while (1) { + // NOTE: the if statement here is for IE8. + var borderLeft = "0", borderTop = "0"; + if (window.getComputedStyle) { + var computedStyle = window.getComputedStyle(copyObj, null); + borderLeft = computedStyle.borderLeft || "0"; + borderTop = computedStyle.borderTop || "0"; } - copyObj = copyObj.offsetParent; - } - } else if(obj.x) { - curleft += obj.x; - } - // This handles the case where the object is inside a scrolled div. - while(obj && obj != document.body) { - curleft -= obj.scrollLeft; - obj = obj.parentNode; - } - return curleft; -}; - -/** - * Find the y-coordinate of the supplied object relative to the top of the - * page. - * @private - */ -Dygraph.findPosY = function(obj) { - var curtop = 0; - if(obj.offsetParent) { - var copyObj = obj; - while(1) { + curleft += parseInt(borderLeft, 10) ; + curtop += parseInt(borderTop, 10) ; + curleft += copyObj.offsetLeft; curtop += copyObj.offsetTop; - if(!copyObj.offsetParent) { + if (!copyObj.offsetParent) { break; } copyObj = copyObj.offsetParent; } - } else if(obj.y) { - curtop += obj.y; + } else { + // TODO(danvk): why would obj ever have these properties? + if (obj.x) curleft += obj.x; + if (obj.y) curtop += obj.y; } + // This handles the case where the object is inside a scrolled div. - while(obj && obj != document.body) { + while (obj && obj != document.body) { + curleft -= obj.scrollLeft; curtop -= obj.scrollTop; obj = obj.parentNode; } - return curtop; + return {x: curleft, y: curtop}; }; /** - * @private * Returns the x-coordinate of the event in a coordinate system where the * top-left corner of the page (not the window) is (0,0). * Taken from MochiKit.Signal + * @param {!Event} e + * @return {number} + * @private */ Dygraph.pageX = function(e) { if (e.pageX) { return (!e.pageX || e.pageX < 0) ? 0 : e.pageX; } else { - var de = document; + var de = document.documentElement; var b = document.body; return e.clientX + (de.scrollLeft || b.scrollLeft) - @@ -327,16 +252,18 @@ Dygraph.pageX = function(e) { }; /** - * @private * Returns the y-coordinate of the event in a coordinate system where the * top-left corner of the page (not the window) is (0,0). * Taken from MochiKit.Signal + * @param {!Event} e + * @return {number} + * @private */ Dygraph.pageY = function(e) { if (e.pageY) { return (!e.pageY || e.pageY < 0) ? 0 : e.pageY; } else { - var de = document; + var de = document.documentElement; var b = document.body; return e.clientY + (de.scrollTop || b.scrollTop) - @@ -345,28 +272,52 @@ Dygraph.pageY = function(e) { }; /** + * Converts page the x-coordinate of the event to pixel x-coordinates on the + * canvas (i.e. DOM Coords). + * @param {!Event} e Drag event. + * @param {!DygraphInteractionContext} context Interaction context object. + * @return {number} The amount by which the drag has moved to the right. + */ +Dygraph.dragGetX_ = function(e, context) { + return Dygraph.pageX(e) - context.px; +}; + +/** + * Converts page the y-coordinate of the event to pixel y-coordinates on the + * canvas (i.e. DOM Coords). + * @param {!Event} e Drag event. + * @param {!DygraphInteractionContext} context Interaction context object. + * @return {number} The amount by which the drag has moved down. + */ +Dygraph.dragGetY_ = function(e, context) { + return Dygraph.pageY(e) - context.py; +}; + +/** + * This returns true unless the parameter is 0, null, undefined or NaN. + * TODO(danvk): rename this function to something like 'isNonZeroNan'. + * + * @param {number} x The number to consider. + * @return {boolean} Whether the number is zero or NaN. * @private - * @param { Number } x The number to consider. - * @return { Boolean } Whether the number is zero or NaN. */ -// TODO(danvk): rename this function to something like 'isNonZeroNan'. -// TODO(danvk): determine when else this returns false (e.g. for undefined or null) Dygraph.isOK = function(x) { - return x && !isNaN(x); + return !!x && !isNaN(x); }; /** + * @param {{x:?number,y:?number,yval:?number}} p The point to consider, valid + * points are {x, y} objects + * @param {boolean=} opt_allowNaNY Treat point with y=NaN as valid + * @return {boolean} Whether the point has numeric x and y. * @private - * @param { Object } p The point to consider, valid points are {x, y} objects - * @param { Boolean } allowNaNY Treat point with y=NaN as valid - * @return { Boolean } Whether the point has numeric x and y. */ -Dygraph.isValidPoint = function(p, allowNaNY) { - if (!p) return false; // null or undefined object - if (p.yval === null) return false; // missing point +Dygraph.isValidPoint = function(p, opt_allowNaNY) { + if (!p) return false; // null or undefined object + if (p.yval === null) return false; // missing point if (p.x === null || p.x === undefined) return false; if (p.y === null || p.y === undefined) return false; - if (isNaN(p.x) || (!allowNaNY && isNaN(p.y))) return false; + if (isNaN(p.x) || (!opt_allowNaNY && isNaN(p.y))) return false; return true; }; @@ -383,9 +334,9 @@ Dygraph.isValidPoint = function(p, allowNaNY) { * 10^-6, e.g. '0.00001' instead of '1e-5'. See tests/number-format.html for * output examples. * - * @param {Number} x The number to format - * @param {Number} opt_precision The precision to use, default 2. - * @return {String} A string formatted like %g in printf. The max generated + * @param {number} x The number to format + * @param {number=} opt_precision The precision to use, default 2. + * @return {string} A string formatted like %g in printf. The max generated * string length should be precision + 6 (e.g 1.123e+300). */ Dygraph.floatFormat = function(x, opt_precision) { @@ -413,36 +364,107 @@ Dygraph.floatFormat = function(x, opt_precision) { }; /** - * @private * Converts '9' to '09' (useful for dates) + * @param {number} x + * @return {string} + * @private */ Dygraph.zeropad = function(x) { if (x < 10) return "0" + x; else return "" + x; }; /** + * Date accessors to get the parts of a calendar date (year, month, + * day, hour, minute, second and millisecond) according to local time, + * and factory method to call the Date constructor with an array of arguments. + */ +Dygraph.DateAccessorsLocal = { + getFullYear: function(d) {return d.getFullYear();}, + getMonth: function(d) {return d.getMonth();}, + getDate: function(d) {return d.getDate();}, + getHours: function(d) {return d.getHours();}, + getMinutes: function(d) {return d.getMinutes();}, + getSeconds: function(d) {return d.getSeconds();}, + getMilliseconds: function(d) {return d.getMilliseconds();}, + getDay: function(d) {return d.getDay();}, + makeDate: function(y, m, d, hh, mm, ss, ms) { + return new Date(y, m, d, hh, mm, ss, ms); + } +}; + +/** + * Date accessors to get the parts of a calendar date (year, month, + * day of month, hour, minute, second and millisecond) according to UTC time, + * and factory method to call the Date constructor with an array of arguments. + */ +Dygraph.DateAccessorsUTC = { + getFullYear: function(d) {return d.getUTCFullYear();}, + getMonth: function(d) {return d.getUTCMonth();}, + getDate: function(d) {return d.getUTCDate();}, + getHours: function(d) {return d.getUTCHours();}, + getMinutes: function(d) {return d.getUTCMinutes();}, + getSeconds: function(d) {return d.getUTCSeconds();}, + getMilliseconds: function(d) {return d.getUTCMilliseconds();}, + getDay: function(d) {return d.getUTCDay();}, + makeDate: function(y, m, d, hh, mm, ss, ms) { + return new Date(Date.UTC(y, m, d, hh, mm, ss, ms)); + } +}; + +/** * Return a string version of the hours, minutes and seconds portion of a date. - * @param {Number} date The JavaScript date (ms since epoch) - * @return {String} A time of the form "HH:MM:SS" + * @param {number} hh The hours (from 0-23) + * @param {number} mm The minutes (from 0-59) + * @param {number} ss The seconds (from 0-59) + * @return {string} A time of the form "HH:MM" or "HH:MM:SS" * @private */ -Dygraph.hmsString_ = function(date) { +Dygraph.hmsString_ = function(hh, mm, ss) { var zeropad = Dygraph.zeropad; - var d = new Date(date); - if (d.getSeconds()) { - return zeropad(d.getHours()) + ":" + - zeropad(d.getMinutes()) + ":" + - zeropad(d.getSeconds()); - } else { - return zeropad(d.getHours()) + ":" + zeropad(d.getMinutes()); + var ret = zeropad(hh) + ":" + zeropad(mm); + if (ss) { + ret += ":" + zeropad(ss); + } + return ret; +}; + +/** + * Convert a JS date (millis since epoch) to a formatted string. + * @param {number} time The JavaScript time value (ms since epoch) + * @param {boolean} utc Wether output UTC or local time + * @return {string} A date of one of these forms: + * "YYYY/MM/DD", "YYYY/MM/DD HH:MM" or "YYYY/MM/DD HH:MM:SS" + * @private + */ +Dygraph.dateString_ = function(time, utc) { + var zeropad = Dygraph.zeropad; + var accessors = utc ? Dygraph.DateAccessorsUTC : Dygraph.DateAccessorsLocal; + var date = new Date(time); + var y = accessors.getFullYear(date); + var m = accessors.getMonth(date); + var d = accessors.getDate(date); + var hh = accessors.getHours(date); + var mm = accessors.getMinutes(date); + var ss = accessors.getSeconds(date); + // Get a year string: + var year = "" + y; + // Get a 0 padded month string + var month = zeropad(m + 1); //months are 0-offset, sigh + // Get a 0 padded day string + var day = zeropad(d); + var frac = hh * 3600 + mm * 60 + ss; + var ret = year + "/" + month + "/" + day; + if (frac) { + ret += " " + Dygraph.hmsString_(hh, mm, ss); } + return ret; }; /** * Round a number to the specified number of digits past the decimal point. - * @param {Number} num The number to round - * @param {Number} places The number of decimals to which to round - * @return {Number} The rounded number + * @param {number} num The number to round + * @param {number} places The number of decimals to which to round + * @return {number} The rounded number * @private */ Dygraph.round_ = function(num, places) { @@ -451,16 +473,17 @@ Dygraph.round_ = function(num, places) { }; /** - * @private * Implementation of binary search over an array. * Currently does not work when val is outside the range of arry's values. - * @param { Integer } val the value to search for - * @param { Integer[] } arry is the value over which to search - * @param { Integer } abs If abs > 0, find the lowest entry greater than val - * If abs < 0, find the highest entry less than val. - * if abs == 0, find the entry that equals val. - * @param { Integer } [low] The first index in arry to consider (optional) - * @param { Integer } [high] The last index in arry to consider (optional) + * @param {number} val the value to search for + * @param {Array.} arry is the value over which to search + * @param {number} abs If abs > 0, find the lowest entry greater than val + * If abs < 0, find the highest entry less than val. + * If abs == 0, find the entry that equals val. + * @param {number=} low The first index in arry to consider (optional) + * @param {number=} high The last index in arry to consider (optional) + * @return {number} Index of the element, or -1 if it isn't found. + * @private */ Dygraph.binarySearch = function(val, arry, abs, low, high) { if (low === null || low === undefined || @@ -479,12 +502,10 @@ Dygraph.binarySearch = function(val, arry, abs, low, high) { }; var mid = parseInt((low + high) / 2, 10); var element = arry[mid]; + var idx; if (element == val) { return mid; - } - - var idx; - if (element > val) { + } else if (element > val) { if (abs > 0) { // Accept if element > val, but also if prior element < val. idx = mid - 1; @@ -493,8 +514,7 @@ Dygraph.binarySearch = function(val, arry, abs, low, high) { } } return Dygraph.binarySearch(val, arry, abs, low, mid - 1); - } - if (element < val) { + } else if (element < val) { if (abs < 0) { // Accept if element < val, but also if prior element > val. idx = mid + 1; @@ -504,15 +524,17 @@ Dygraph.binarySearch = function(val, arry, abs, low, high) { } return Dygraph.binarySearch(val, arry, abs, mid + 1, high); } + return -1; // can't actually happen, but makes closure compiler happy }; /** - * @private * Parses a date, returning the number of milliseconds since epoch. This can be * passed in as an xValueParser in the Dygraph constructor. * TODO(danvk): enumerate formats that this understands. - * @param {String} A date in YYYYMMDD format. - * @return {Number} Milliseconds since epoch. + * + * @param {string} dateStr A date in a variety of possible string formats. + * @return {number} Milliseconds since epoch. + * @private */ Dygraph.dateParser = function(dateStr) { var dateStrSlashed; @@ -548,18 +570,18 @@ Dygraph.dateParser = function(dateStr) { } if (!d || isNaN(d)) { - Dygraph.error("Couldn't parse " + dateStr + " as a date"); + console.error("Couldn't parse " + dateStr + " as a date"); } return d; }; /** - * @private * This is identical to JavaScript's built-in Date.parse() method, except that * it doesn't get replaced with an incompatible method by aggressive JS * libraries like MooTools or Joomla. - * @param { String } str The date string, e.g. "2011/05/06" - * @return { Integer } millis since epoch + * @param {string} str The date string, e.g. "2011/05/06" + * @return {number} millis since epoch + * @private */ Dygraph.dateStrToMillis = function(str) { return new Date(str).getTime(); @@ -569,9 +591,11 @@ Dygraph.dateStrToMillis = function(str) { /** * Copies all the properties from o to self. * - * @private + * @param {!Object} self + * @param {!Object} o + * @return {!Object} */ -Dygraph.update = function (self, o) { +Dygraph.update = function(self, o) { if (typeof(o) != 'undefined' && o !== null) { for (var k in o) { if (o.hasOwnProperty(k)) { @@ -585,6 +609,9 @@ Dygraph.update = function (self, o) { /** * Copies all the properties from o to self. * + * @param {!Object} self + * @param {!Object} o + * @return {!Object} * @private */ Dygraph.updateDeep = function (self, o) { @@ -621,9 +648,11 @@ Dygraph.updateDeep = function (self, o) { }; /** + * @param {*} o + * @return {boolean} * @private */ -Dygraph.isArrayLike = function (o) { +Dygraph.isArrayLike = function(o) { var typ = typeof(o); if ( (typ != 'object' && !(typ == 'function' && @@ -638,6 +667,8 @@ Dygraph.isArrayLike = function (o) { }; /** + * @param {Object} o + * @return {boolean} * @private */ Dygraph.isDateLike = function (o) { @@ -650,6 +681,8 @@ Dygraph.isDateLike = function (o) { /** * Note: this only seems to work for arrays. + * @param {!Array} o + * @return {!Array} * @private */ Dygraph.clone = function(o) { @@ -666,30 +699,74 @@ Dygraph.clone = function(o) { }; /** - * @private * Create a new canvas element. This is more complex than a simple * document.createElement("canvas") because of IE and excanvas. + * + * @return {!HTMLCanvasElement} + * @private */ Dygraph.createCanvas = function() { var canvas = document.createElement("canvas"); var isIE = (/MSIE/.test(navigator.userAgent) && !window.opera); if (isIE && (typeof(G_vmlCanvasManager) != 'undefined')) { - canvas = G_vmlCanvasManager.initElement(canvas); + canvas = G_vmlCanvasManager.initElement( + /**@type{!HTMLCanvasElement}*/(canvas)); } return canvas; }; /** - * @private + * Returns the context's pixel ratio, which is the ratio between the device + * pixel ratio and the backing store ratio. Typically this is 1 for conventional + * displays, and > 1 for HiDPI displays (such as the Retina MBP). + * See http://www.html5rocks.com/en/tutorials/canvas/hidpi/ for more details. + * + * @param {!CanvasRenderingContext2D} context The canvas's 2d context. + * @return {number} The ratio of the device pixel ratio and the backing store + * ratio for the specified context. + */ +Dygraph.getContextPixelRatio = function(context) { + try { + var devicePixelRatio = window.devicePixelRatio; + var backingStoreRatio = context.webkitBackingStorePixelRatio || + context.mozBackingStorePixelRatio || + context.msBackingStorePixelRatio || + context.oBackingStorePixelRatio || + context.backingStorePixelRatio; + if (devicePixelRatio !== undefined && + backingStorePixelRatio !== undefined) { + return devicePixelRatio / backingStoreRatio; + } else { + // If either value is undefined, the ratio is meaningless so we want to + // return 1. + return 1; + } + } catch (e) { + return 1; + } +}; + +/** * Checks whether the user is on an Android browser. * Android does not fully support the tag, e.g. w/r/t/ clipping. + * @return {boolean} + * @private */ Dygraph.isAndroid = function() { return (/Android/).test(navigator.userAgent); }; + +/** + * TODO(danvk): use @template here when it's better supported for classes. + * @param {!Array} array + * @param {number} start + * @param {number} length + * @param {function(!Array,?):boolean=} predicate + * @constructor + */ Dygraph.Iterator = function(array, start, length, predicate) { start = start || 0; length = length || array.length; @@ -703,6 +780,9 @@ Dygraph.Iterator = function(array, start, length, predicate) { this.next(); // ignoring result. }; +/** + * @return {Object} + */ Dygraph.Iterator.prototype.next = function() { if (!this.hasNext) { return null; @@ -728,67 +808,99 @@ Dygraph.Iterator.prototype.next = function() { }; /** - * @private - * Returns a new iterator over array, between indexes start and + * Returns a new iterator over array, between indexes start and * start + length, and only returns entries that pass the accept function * - * @param array the array to iterate over. - * @param start the first index to iterate over, 0 if absent. - * @param length the number of elements in the array to iterate over. - * This, along with start, defines a slice of the array, and so length - * doesn't imply the number of elements in the iterator when accept - * doesn't always accept all values. array.length when absent. - * @param predicate a function that takes parameters array and idx, which - * returns true when the element should be returned. If omitted, all - * elements are accepted. + * @param {!Array} array the array to iterate over. + * @param {number} start the first index to iterate over, 0 if absent. + * @param {number} length the number of elements in the array to iterate over. + * This, along with start, defines a slice of the array, and so length + * doesn't imply the number of elements in the iterator when accept doesn't + * always accept all values. array.length when absent. + * @param {function(?):boolean=} opt_predicate a function that takes + * parameters array and idx, which returns true when the element should be + * returned. If omitted, all elements are accepted. + * @private */ -Dygraph.createIterator = function(array, start, length, predicate) { - return new Dygraph.Iterator(array, start, length, predicate); +Dygraph.createIterator = function(array, start, length, opt_predicate) { + return new Dygraph.Iterator(array, start, length, opt_predicate); }; +// Shim layer with setTimeout fallback. +// From: http://paulirish.com/2011/requestanimationframe-for-smart-animating/ +// Should be called with the window context: +// Dygraph.requestAnimFrame.call(window, function() {}) +Dygraph.requestAnimFrame = (function() { + return window.requestAnimationFrame || + window.webkitRequestAnimationFrame || + window.mozRequestAnimationFrame || + window.oRequestAnimationFrame || + window.msRequestAnimationFrame || + function (callback) { + window.setTimeout(callback, 1000 / 60); + }; +})(); + /** - * @private - * Call a function N times at a given interval, then call a cleanup function - * once. repeat_fn is called once immediately, then (times - 1) times - * asynchronously. If times=1, then cleanup_fn() is also called synchronously. - * @param repeat_fn {Function} Called repeatedly -- takes the number of calls - * (from 0 to times-1) as an argument. - * @param times {number} The number of times to call repeat_fn - * @param every_ms {number} Milliseconds between calls - * @param cleanup_fn {Function} A function to call after all repeat_fn calls. + * Call a function at most maxFrames times at an attempted interval of + * framePeriodInMillis, then call a cleanup function once. repeatFn is called + * once immediately, then at most (maxFrames - 1) times asynchronously. If + * maxFrames==1, then cleanup_fn() is also called synchronously. This function + * is used to sequence animation. + * @param {function(number)} repeatFn Called repeatedly -- takes the frame + * number (from 0 to maxFrames-1) as an argument. + * @param {number} maxFrames The max number of times to call repeatFn + * @param {number} framePeriodInMillis Max requested time between frames. + * @param {function()} cleanupFn A function to call after all repeatFn calls. * @private */ -Dygraph.repeatAndCleanup = function(repeat_fn, times, every_ms, cleanup_fn) { - var count = 0; - var start_time = new Date().getTime(); - repeat_fn(count); - if (times == 1) { - cleanup_fn(); +Dygraph.repeatAndCleanup = function(repeatFn, maxFrames, framePeriodInMillis, + cleanupFn) { + var frameNumber = 0; + var previousFrameNumber; + var startTime = new Date().getTime(); + repeatFn(frameNumber); + if (maxFrames == 1) { + cleanupFn(); return; } + var maxFrameArg = maxFrames - 1; (function loop() { - if (count >= times) return; - var target_time = start_time + (1 + count) * every_ms; - setTimeout(function() { - count++; - repeat_fn(count); - if (count >= times - 1) { - cleanup_fn(); + if (frameNumber >= maxFrames) return; + Dygraph.requestAnimFrame.call(window, function() { + // Determine which frame to draw based on the delay so far. Will skip + // frames if necessary. + var currentTime = new Date().getTime(); + var delayInMillis = currentTime - startTime; + previousFrameNumber = frameNumber; + frameNumber = Math.floor(delayInMillis / framePeriodInMillis); + var frameDelta = frameNumber - previousFrameNumber; + // If we predict that the subsequent repeatFn call will overshoot our + // total frame target, so our last call will cause a stutter, then jump to + // the last call immediately. If we're going to cause a stutter, better + // to do it faster than slower. + var predictOvershootStutter = (frameNumber + frameDelta) > maxFrameArg; + if (predictOvershootStutter || (frameNumber >= maxFrameArg)) { + repeatFn(maxFrameArg); // Ensure final call with maxFrameArg. + cleanupFn(); } else { + if (frameDelta !== 0) { // Don't call repeatFn with duplicate frames. + repeatFn(frameNumber); + } loop(); } - }, target_time - new Date().getTime()); - // TODO(danvk): adjust every_ms to produce evenly-timed function calls. + }); })(); }; /** - * @private * This function will scan the option list and determine if they * require us to recalculate the pixel positions of each point. - * @param { List } a list of options to check. - * @return { Boolean } true if the graph needs new points else false. + * @param {!Array.} labels a list of options to check. + * @param {!Object} attrs + * @return {boolean} true if the graph needs new points else false. + * @private */ Dygraph.isPixelChangingOptionList = function(labels, attrs) { // A whitelist of options that do not change pixel positions. @@ -888,130 +1000,210 @@ Dygraph.isPixelChangingOptionList = function(labels, attrs) { return requiresNewPoints; }; +Dygraph.Circles = { + DEFAULT : function(g, name, ctx, canvasx, canvasy, color, radius) { + ctx.beginPath(); + ctx.fillStyle = color; + ctx.arc(canvasx, canvasy, radius, 0, 2 * Math.PI, false); + ctx.fill(); + } + // For more shapes, include extras/shapes.js +}; + /** - * Compares two arrays to see if they are equal. If either parameter is not an - * array it will return false. Does a shallow compare - * Dygraph.compareArrays([[1,2], [3, 4]], [[1,2], [3,4]]) === false. - * @param array1 first array - * @param array2 second array - * @return True if both parameters are arrays, and contents are equal. + * To create a "drag" interaction, you typically register a mousedown event + * handler on the element where the drag begins. In that handler, you register a + * mouseup handler on the window to determine when the mouse is released, + * wherever that release happens. This works well, except when the user releases + * the mouse over an off-domain iframe. In that case, the mouseup event is + * handled by the iframe and never bubbles up to the window handler. + * + * To deal with this issue, we cover iframes with high z-index divs to make sure + * they don't capture mouseup. + * + * Usage: + * element.addEventListener('mousedown', function() { + * var tarper = new Dygraph.IFrameTarp(); + * tarper.cover(); + * var mouseUpHandler = function() { + * ... + * window.removeEventListener(mouseUpHandler); + * tarper.uncover(); + * }; + * window.addEventListener('mouseup', mouseUpHandler); + * }; + * + * @constructor */ -Dygraph.compareArrays = function(array1, array2) { - if (!Dygraph.isArrayLike(array1) || !Dygraph.isArrayLike(array2)) { - return false; - } - if (array1.length !== array2.length) { - return false; +Dygraph.IFrameTarp = function() { + /** @type {Array.} */ + this.tarps = []; +}; + +/** + * Find all the iframes in the document and cover them with high z-index + * transparent divs. + */ +Dygraph.IFrameTarp.prototype.cover = function() { + var iframes = document.getElementsByTagName("iframe"); + for (var i = 0; i < iframes.length; i++) { + var iframe = iframes[i]; + var pos = Dygraph.findPos(iframe), + x = pos.x, + y = pos.y, + width = iframe.offsetWidth, + height = iframe.offsetHeight; + + var div = document.createElement("div"); + div.style.position = "absolute"; + div.style.left = x + 'px'; + div.style.top = y + 'px'; + div.style.width = width + 'px'; + div.style.height = height + 'px'; + div.style.zIndex = 999; + document.body.appendChild(div); + this.tarps.push(div); } - for (var i = 0; i < array1.length; i++) { - if (array1[i] !== array2[i]) { - return false; - } +}; + +/** + * Remove all the iframe covers. You should call this in a mouseup handler. + */ +Dygraph.IFrameTarp.prototype.uncover = function() { + for (var i = 0; i < this.tarps.length; i++) { + this.tarps[i].parentNode.removeChild(this.tarps[i]); } - return true; + this.tarps = []; }; /** - * ctx: the canvas context - * sides: the number of sides in the shape. - * radius: the radius of the image. - * cx: center x coordate - * cy: center y coordinate - * rotationRadians: the shift of the initial angle, in radians. - * delta: the angle shift for each line. If missing, creates a regular - * polygon. + * Determine whether |data| is delimited by CR, CRLF, LF, LFCR. + * @param {string} data + * @return {?string} the delimiter that was detected (or null on failure). */ -Dygraph.regularShape_ = function( - ctx, sides, radius, cx, cy, rotationRadians, delta) { - rotationRadians = rotationRadians ? rotationRadians : 0; - delta = delta ? delta : Math.PI * 2 / sides; +Dygraph.detectLineDelimiter = function(data) { + for (var i = 0; i < data.length; i++) { + var code = data.charAt(i); + if (code === '\r') { + // Might actually be "\r\n". + if (((i + 1) < data.length) && (data.charAt(i + 1) === '\n')) { + return '\r\n'; + } + return code; + } + if (code === '\n') { + // Might actually be "\n\r". + if (((i + 1) < data.length) && (data.charAt(i + 1) === '\r')) { + return '\n\r'; + } + return code; + } + } - ctx.beginPath(); - var first = true; - var initialAngle = rotationRadians; - var angle = initialAngle; + return null; +}; - var computeCoordinates = function() { - var x = cx + (Math.sin(angle) * radius); - var y = cy + (-Math.cos(angle) * radius); - return [x, y]; - }; +/** + * Is one node contained by another? + * @param {Node} containee The contained node. + * @param {Node} container The container node. + * @return {boolean} Whether containee is inside (or equal to) container. + * @private + */ +Dygraph.isNodeContainedBy = function(containee, container) { + if (container === null || containee === null) { + return false; + } + var containeeNode = /** @type {Node} */ (containee); + while (containeeNode && containeeNode !== container) { + containeeNode = containeeNode.parentNode; + } + return (containeeNode === container); +}; - var initialCoordinates = computeCoordinates(); - var x = initialCoordinates[0]; - var y = initialCoordinates[1]; - ctx.moveTo(x, y); - for (var idx = 0; idx < sides; idx++) { - angle = (idx == sides - 1) ? initialAngle : (angle + delta); - var coords = computeCoordinates(); - ctx.lineTo(coords[0], coords[1]); +// This masks some numeric issues in older versions of Firefox, +// where 1.0/Math.pow(10,2) != Math.pow(10,-2). +/** @type {function(number,number):number} */ +Dygraph.pow = function(base, exp) { + if (exp < 0) { + return 1.0 / Math.pow(base, -exp); } - ctx.fill(); - ctx.stroke(); + return Math.pow(base, exp); }; -Dygraph.shapeFunction_ = function(sides, rotationRadians, delta) { - return function(g, name, ctx, cx, cy, color, radius) { - ctx.strokeStyle = color; - ctx.fillStyle = "white"; - Dygraph.regularShape_(ctx, sides, radius, cx, cy, rotationRadians, delta); +/** + * Converts any valid CSS color (hex, rgb(), named color) to an RGB tuple. + * + * @param {!string} colorStr Any valid CSS color string. + * @return {{r:number,g:number,b:number}} Parsed RGB tuple. + * @private + */ +Dygraph.toRGB_ = function(colorStr) { + // TODO(danvk): cache color parses to avoid repeated DOM manipulation. + var div = document.createElement('div'); + div.style.backgroundColor = colorStr; + div.style.visibility = 'hidden'; + document.body.appendChild(div); + var rgbStr = window.getComputedStyle(div, null).backgroundColor; + document.body.removeChild(div); + var bits = /^rgb\((\d{1,3}),\s*(\d{1,3}),\s*(\d{1,3})\)$/.exec(rgbStr); + return { + r: parseInt(bits[1], 10), + g: parseInt(bits[2], 10), + b: parseInt(bits[3], 10) }; }; -Dygraph.DrawPolygon_ = function(sides, rotationRadians, ctx, cx, cy, color, radius, delta) { - new Dygraph.RegularShape_(sides, rotationRadians, delta).draw(ctx, cx, cy, radius); +/** + * Checks whether the browser supports the <canvas> tag. + * @param {HTMLCanvasElement=} opt_canvasElement Pass a canvas element as an + * optimization if you have one. + * @return {boolean} Whether the browser supports canvas. + */ +Dygraph.isCanvasSupported = function(opt_canvasElement) { + var canvas; + try { + canvas = opt_canvasElement || document.createElement("canvas"); + canvas.getContext("2d"); + } + catch (e) { + var ie = navigator.appVersion.match(/MSIE (\d\.\d)/); + var opera = (navigator.userAgent.toLowerCase().indexOf("opera") != -1); + if ((!ie) || (ie[1] < 6) || (opera)) + return false; + return true; + } + return true; }; -Dygraph.Circles = { - DEFAULT : function(g, name, ctx, canvasx, canvasy, color, radius) { - ctx.beginPath(); - ctx.fillStyle = color; - ctx.arc(canvasx, canvasy, radius, 0, 2 * Math.PI, false); - ctx.fill(); - }, - TRIANGLE : Dygraph.shapeFunction_(3), - SQUARE : Dygraph.shapeFunction_(4, Math.PI / 4), - DIAMOND : Dygraph.shapeFunction_(4), - PENTAGON : Dygraph.shapeFunction_(5), - HEXAGON : Dygraph.shapeFunction_(6), - CIRCLE : function(g, name, ctx, cx, cy, color, radius) { - ctx.beginPath(); - ctx.strokeStyle = color; - ctx.fillStyle = "white"; - ctx.arc(cx, cy, radius, 0, 2 * Math.PI, false); - ctx.fill(); - ctx.stroke(); - }, - STAR : Dygraph.shapeFunction_(5, 0, 4 * Math.PI / 5), - PLUS : function(g, name, ctx, cx, cy, color, radius) { - ctx.strokeStyle = color; - - ctx.beginPath(); - ctx.moveTo(cx + radius, cy); - ctx.lineTo(cx - radius, cy); - ctx.closePath(); - ctx.stroke(); +/** + * Parses the value as a floating point number. This is like the parseFloat() + * built-in, but with a few differences: + * - the empty string is parsed as null, rather than NaN. + * - if the string cannot be parsed at all, an error is logged. + * If the string can't be parsed, this method returns null. + * @param {string} x The string to be parsed + * @param {number=} opt_line_no The line number from which the string comes. + * @param {string=} opt_line The text of the line from which the string comes. + */ +Dygraph.parseFloat_ = function(x, opt_line_no, opt_line) { + var val = parseFloat(x); + if (!isNaN(val)) return val; - ctx.beginPath(); - ctx.moveTo(cx, cy + radius); - ctx.lineTo(cx, cy - radius); - ctx.closePath(); - ctx.stroke(); - }, - EX : function(g, name, ctx, cx, cy, color, radius) { - ctx.strokeStyle = color; + // Try to figure out what happeend. + // If the value is the empty string, parse it as null. + if (/^ *$/.test(x)) return null; - ctx.beginPath(); - ctx.moveTo(cx + radius, cy + radius); - ctx.lineTo(cx - radius, cy - radius); - ctx.closePath(); - ctx.stroke(); + // If it was actually "NaN", return it as NaN. + if (/^ *nan *$/i.test(x)) return NaN; - ctx.beginPath(); - ctx.moveTo(cx + radius, cy - radius); - ctx.lineTo(cx - radius, cy + radius); - ctx.closePath(); - ctx.stroke(); + // Looks like a parsing error. + var msg = "Unable to parse '" + x + "' as a number"; + if (opt_line !== undefined && opt_line_no !== undefined) { + msg += " on line " + (1+(opt_line_no||0)) + " ('" + opt_line + "') of CSV."; } + console.error(msg); + + return null; };