X-Git-Url: https://adrianiainlam.tk/git/?a=blobdiff_plain;ds=sidebyside;f=dygraph.js;h=1d33570a77aa1c9152dabb0b5798a698cde865de;hb=0c25c918a6a8027b76f73800efb0640d5f48f37a;hp=83d4e8c33e3de5944e15fe27f741f8e0c47e2a49;hpb=25f76ae32a735757d6c5570e966a9d3774f64117;p=dygraphs.git
diff --git a/dygraph.js b/dygraph.js
index 83d4e8c..1d33570 100644
--- a/dygraph.js
+++ b/dygraph.js
@@ -1,5 +1,8 @@
-// Copyright 2006 Dan Vanderkam (danvdk@gmail.com)
-// All Rights Reserved.
+/**
+ * @license
+ * Copyright 2006 Dan Vanderkam (danvdk@gmail.com)
+ * MIT-licensed (http://opensource.org/licenses/MIT)
+ */
/**
* @fileoverview Creates an interactive, zoomable graph based on a CSV file or
@@ -40,6 +43,10 @@
*/
+/*jshint globalstrict: true */
+/*global DygraphLayout:false, DygraphCanvasRenderer:false, DygraphOptions:false, G_vmlCanvasManager:false,ActiveXObject:false */
+"use strict";
+
/**
* Creates an interactive, zoomable chart.
*
@@ -54,22 +61,26 @@
* whether the input data contains error ranges. For a complete list of
* options, see http://dygraphs.com/options.html.
*/
-Dygraph = function(div, data, opts) {
- if (arguments.length > 0) {
- if (arguments.length == 4) {
- // Old versions of dygraphs took in the series labels as a constructor
- // parameter. This doesn't make sense anymore, but it's easy to continue
- // to support this usage.
- this.warn("Using deprecated four-argument dygraph constructor");
- this.__old_init__(div, data, arguments[2], arguments[3]);
- } else {
- this.__init__(div, data, opts);
- }
+var Dygraph = function(div, data, opts, opt_fourth_param) {
+ // These have to go above the "Hack for IE" in __init__ since .ready() can be
+ // called as soon as the constructor returns. Once support for OldIE is
+ // dropped, this can go down with the rest of the initializers.
+ this.is_initial_draw_ = true;
+ this.readyFns_ = [];
+
+ if (opt_fourth_param !== undefined) {
+ // Old versions of dygraphs took in the series labels as a constructor
+ // parameter. This doesn't make sense anymore, but it's easy to continue
+ // to support this usage.
+ this.warn("Using deprecated four-argument dygraph constructor");
+ this.__old_init__(div, data, opts, opt_fourth_param);
+ } else {
+ this.__init__(div, data, opts);
}
};
Dygraph.NAME = "Dygraph";
-Dygraph.VERSION = "1.2";
+Dygraph.VERSION = "1.0.1";
Dygraph.__repr__ = function() {
return "[" + this.NAME + " " + this.VERSION + "]";
};
@@ -86,11 +97,166 @@ Dygraph.DEFAULT_ROLL_PERIOD = 1;
Dygraph.DEFAULT_WIDTH = 480;
Dygraph.DEFAULT_HEIGHT = 320;
+// For max 60 Hz. animation:
+Dygraph.ANIMATION_STEPS = 12;
+Dygraph.ANIMATION_DURATION = 200;
+
+// Label constants for the labelsKMB and labelsKMG2 options.
+// (i.e. '100000' -> '100K')
+Dygraph.KMB_LABELS = [ 'K', 'M', 'B', 'T', 'Q' ];
+Dygraph.KMG2_BIG_LABELS = [ 'k', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y' ];
+Dygraph.KMG2_SMALL_LABELS = [ 'm', 'u', 'n', 'p', 'f', 'a', 'z', 'y' ];
+
+// These are defined before DEFAULT_ATTRS so that it can refer to them.
+/**
+ * @private
+ * Return a string version of a number. This respects the digitsAfterDecimal
+ * and maxNumberWidth options.
+ * @param {Number} x The number to be formatted
+ * @param {Dygraph} opts An options view
+ * @param {String} name The name of the point's data series
+ * @param {Dygraph} g The dygraph object
+ */
+Dygraph.numberValueFormatter = function(x, opts, pt, g) {
+ var sigFigs = opts('sigFigs');
+
+ if (sigFigs !== null) {
+ // User has opted for a fixed number of significant figures.
+ return Dygraph.floatFormat(x, sigFigs);
+ }
+
+ var digits = opts('digitsAfterDecimal');
+ var maxNumberWidth = opts('maxNumberWidth');
+
+ var kmb = opts('labelsKMB');
+ var kmg2 = opts('labelsKMG2');
+
+ var label;
+
+ // switch to scientific notation if we underflow or overflow fixed display.
+ if (x !== 0.0 &&
+ (Math.abs(x) >= Math.pow(10, maxNumberWidth) ||
+ Math.abs(x) < Math.pow(10, -digits))) {
+ label = x.toExponential(digits);
+ } else {
+ label = '' + Dygraph.round_(x, digits);
+ }
+
+ if (kmb || kmg2) {
+ var k;
+ var k_labels = [];
+ var m_labels = [];
+ if (kmb) {
+ k = 1000;
+ k_labels = Dygraph.KMB_LABELS;
+ }
+ if (kmg2) {
+ if (kmb) Dygraph.warn("Setting both labelsKMB and labelsKMG2. Pick one!");
+ k = 1024;
+ k_labels = Dygraph.KMG2_BIG_LABELS;
+ m_labels = Dygraph.KMG2_SMALL_LABELS;
+ }
+
+ var absx = Math.abs(x);
+ var n = Dygraph.pow(k, k_labels.length);
+ for (var j = k_labels.length - 1; j >= 0; j--, n /= k) {
+ if (absx >= n) {
+ label = Dygraph.round_(x / n, digits) + k_labels[j];
+ break;
+ }
+ }
+ if (kmg2) {
+ // TODO(danvk): clean up this logic. Why so different than kmb?
+ var x_parts = String(x.toExponential()).split('e-');
+ if (x_parts.length === 2 && x_parts[1] >= 3 && x_parts[1] <= 24) {
+ if (x_parts[1] % 3 > 0) {
+ label = Dygraph.round_(x_parts[0] /
+ Dygraph.pow(10, (x_parts[1] % 3)),
+ digits);
+ } else {
+ label = Number(x_parts[0]).toFixed(2);
+ }
+ label += m_labels[Math.floor(x_parts[1] / 3) - 1];
+ }
+ }
+ }
+
+ return label;
+};
+
+/**
+ * variant for use as an axisLabelFormatter.
+ * @private
+ */
+Dygraph.numberAxisLabelFormatter = function(x, granularity, opts, g) {
+ return Dygraph.numberValueFormatter(x, opts, g);
+};
+
+/**
+ * Convert a JS date (millis since epoch) to YYYY/MM/DD
+ * @param {Number} date The JavaScript date (ms since epoch)
+ * @return {String} A date of the form "YYYY/MM/DD"
+ * @private
+ */
+Dygraph.dateString_ = function(date) {
+ var zeropad = Dygraph.zeropad;
+ var d = new Date(date);
+
+ // Get the year:
+ var year = "" + d.getFullYear();
+ // Get a 0 padded month string
+ var month = zeropad(d.getMonth() + 1); //months are 0-offset, sigh
+ // Get a 0 padded day string
+ var day = zeropad(d.getDate());
+
+ var ret = "";
+ var frac = d.getHours() * 3600 + d.getMinutes() * 60 + d.getSeconds();
+ if (frac) ret = " " + Dygraph.hmsString_(date);
+
+ return year + "/" + month + "/" + day + ret;
+};
+
+/**
+ * Convert a JS date to a string appropriate to display on an axis that
+ * is displaying values at the stated granularity.
+ * @param {Date} date The date to format
+ * @param {Number} granularity One of the Dygraph granularity constants
+ * @return {String} The formatted date
+ * @private
+ */
+Dygraph.dateAxisFormatter = function(date, granularity) {
+ if (granularity >= Dygraph.DECADAL) {
+ return date.strftime('%Y');
+ } else if (granularity >= Dygraph.MONTHLY) {
+ return date.strftime('%b %y');
+ } else {
+ var frac = date.getHours() * 3600 + date.getMinutes() * 60 + date.getSeconds() + date.getMilliseconds();
+ if (frac === 0 || granularity >= Dygraph.DAILY) {
+ return new Date(date.getTime() + 3600*1000).strftime('%d%b');
+ } else {
+ return Dygraph.hmsString_(date.getTime());
+ }
+ }
+};
+
+/**
+ * Standard plotters. These may be used by clients.
+ * Available plotters are:
+ * - Dygraph.Plotters.linePlotter: draws central lines (most common)
+ * - Dygraph.Plotters.errorPlotter: draws error bars
+ * - Dygraph.Plotters.fillPlotter: draws fills under lines (used with fillGraph)
+ *
+ * By default, the plotter is [fillPlotter, errorPlotter, linePlotter].
+ * This causes all the lines to be drawn over all the fills/error bars.
+ */
+Dygraph.Plotters = DygraphCanvasRenderer._Plotters;
+
+
// Default attribute values.
Dygraph.DEFAULT_ATTRS = {
highlightCircleSize: 3,
- pixelsPerXLabel: 60,
- pixelsPerYLabel: 30,
+ highlightSeriesOpts: null,
+ highlightSeriesBackgroundAlpha: 0.5,
labelsDivWidth: 250,
labelsDivStyles: {
@@ -102,24 +268,22 @@ Dygraph.DEFAULT_ATTRS = {
labelsKMG2: false,
showLabelsOnHighlight: true,
- yValueFormatter: function(a,b) { return Dygraph.numberFormatter(a,b); },
digitsAfterDecimal: 2,
maxNumberWidth: 6,
sigFigs: null,
strokeWidth: 1.0,
+ strokeBorderWidth: 0,
+ strokeBorderColor: "white",
axisTickSize: 3,
axisLabelFontSize: 14,
xAxisLabelWidth: 50,
yAxisLabelWidth: 50,
- xAxisLabelFormatter: Dygraph.dateAxisFormatter,
rightGap: 5,
showRoller: false,
- xValueFormatter: Dygraph.dateString_,
xValueParser: Dygraph.dateParser,
- xTicker: Dygraph.dateTicker,
delimiter: ',',
@@ -133,6 +297,7 @@ Dygraph.DEFAULT_ATTRS = {
connectSeparatedPoints: false,
stackedGraph: false,
+ stackedGraphNaNFill: 'all',
hideOverlayOnMouseOut: true,
// TODO(danvk): support 'onmouseover' and 'never', and remove synonyms.
@@ -140,6 +305,9 @@ Dygraph.DEFAULT_ATTRS = {
stepPlot: false,
avoidMinZero: false,
+ xRangePad: 0,
+ yRangePad: null,
+ drawAxesAtZero: false,
// Sizes of the various chart labels.
titleHeight: 28,
@@ -158,7 +326,52 @@ Dygraph.DEFAULT_ATTRS = {
drawXGrid: true,
gridLineColor: "rgb(128,128,128)",
- interactionModel: null // will be set to Dygraph.Interaction.defaultModel
+ interactionModel: null, // will be set to Dygraph.Interaction.defaultModel
+ animatedZooms: false, // (for now)
+
+ // Range selector options
+ showRangeSelector: false,
+ rangeSelectorHeight: 40,
+ rangeSelectorPlotStrokeColor: "#808FAB",
+ rangeSelectorPlotFillColor: "#A7B1C4",
+
+ // The ordering here ensures that central lines always appear above any
+ // fill bars/error bars.
+ plotter: [
+ Dygraph.Plotters.fillPlotter,
+ Dygraph.Plotters.errorPlotter,
+ Dygraph.Plotters.linePlotter
+ ],
+
+ plugins: [ ],
+
+ // per-axis options
+ axes: {
+ x: {
+ pixelsPerLabel: 60,
+ axisLabelFormatter: Dygraph.dateAxisFormatter,
+ valueFormatter: Dygraph.dateString_,
+ drawGrid: true,
+ independentTicks: true,
+ ticker: null // will be set in dygraph-tickers.js
+ },
+ y: {
+ pixelsPerLabel: 30,
+ valueFormatter: Dygraph.numberValueFormatter,
+ axisLabelFormatter: Dygraph.numberAxisLabelFormatter,
+ drawGrid: true,
+ independentTicks: true,
+ ticker: null // will be set in dygraph-tickers.js
+ },
+ y2: {
+ pixelsPerLabel: 30,
+ valueFormatter: Dygraph.numberValueFormatter,
+ axisLabelFormatter: Dygraph.numberAxisLabelFormatter,
+ drawGrid: false,
+ independentTicks: false,
+ ticker: null // will be set in dygraph-tickers.js
+ }
+ }
};
// Directions for panning and zooming. Use bit operations when combined
@@ -166,6 +379,11 @@ Dygraph.DEFAULT_ATTRS = {
Dygraph.HORIZONTAL = 1;
Dygraph.VERTICAL = 2;
+// Installed plugins, in order of precedence (most-general to most-specific).
+// Plugins are installed after they are defined, in plugins/install.js.
+Dygraph.PLUGINS = [
+];
+
// Used for initializing annotation CSS rules only once.
Dygraph.addedAnnotationCSS = false;
@@ -173,7 +391,7 @@ Dygraph.prototype.__old_init__ = function(div, file, labels, attrs) {
// Labels is no longer a constructor parameter, since it's typically set
// directly from the data source. It also conains a name for the x-axis,
// which the previous constructor form did not.
- if (labels != null) {
+ if (labels !== null) {
var new_labels = ["Date"];
for (var i = 0; i < labels.length; i++) new_labels.push(labels[i]);
Dygraph.update(attrs, { 'labels': new_labels });
@@ -198,11 +416,25 @@ Dygraph.prototype.__init__ = function(div, file, attrs) {
typeof(G_vmlCanvasManager) != 'undefined' &&
document.readyState != 'complete') {
var self = this;
- setTimeout(function() { self.__init__(div, file, attrs) }, 100);
+ setTimeout(function() { self.__init__(div, file, attrs); }, 100);
+ return;
}
// Support two-argument constructor
- if (attrs == null) { attrs = {}; }
+ if (attrs === null || attrs === undefined) { attrs = {}; }
+
+ attrs = Dygraph.mapLegacyOptions_(attrs);
+
+ if (typeof(div) == 'string') {
+ div = document.getElementById(div);
+ }
+
+ if (!div) {
+ Dygraph.error("Constructing dygraph with a non-existent div!");
+ return;
+ }
+
+ this.isUsingExcanvas_ = typeof(G_vmlCanvasManager) != 'undefined';
// Copy the important bits into the object
// TODO(danvk): most of these should just stay in the attrs_ dictionary.
@@ -213,8 +445,6 @@ Dygraph.prototype.__init__ = function(div, file, attrs) {
this.fractions_ = attrs.fractions || false;
this.dateWindow_ = attrs.dateWindow || null;
- this.wilsonInterval_ = attrs.wilsonInterval || true;
- this.is_initial_draw_ = true;
this.annotations_ = [];
// Zoomed indicators - These indicate when the graph has been zoomed and on what axis.
@@ -225,38 +455,37 @@ Dygraph.prototype.__init__ = function(div, file, attrs) {
// div, then only one will be drawn.
div.innerHTML = "";
- // If the div isn't already sized then inherit from our attrs or
- // give it a default size.
- if (div.style.width == '') {
- div.style.width = (attrs.width || Dygraph.DEFAULT_WIDTH) + "px";
+ // For historical reasons, the 'width' and 'height' options trump all CSS
+ // rules _except_ for an explicit 'width' or 'height' on the div.
+ // As an added convenience, if the div has zero height (like
does
+ // without any styles), then we use a default height/width.
+ if (div.style.width === '' && attrs.width) {
+ div.style.width = attrs.width + "px";
}
- if (div.style.height == '') {
- div.style.height = (attrs.height || Dygraph.DEFAULT_HEIGHT) + "px";
- }
- this.width_ = parseInt(div.style.width, 10);
- this.height_ = parseInt(div.style.height, 10);
- // The div might have been specified as percent of the current window size,
- // convert that to an appropriate number of pixels.
- if (div.style.width.indexOf("%") == div.style.width.length - 1) {
- this.width_ = div.offsetWidth;
- }
- if (div.style.height.indexOf("%") == div.style.height.length - 1) {
- this.height_ = div.offsetHeight;
- }
-
- if (this.width_ == 0) {
- this.error("dygraph has zero width. Please specify a width in pixels.");
+ if (div.style.height === '' && attrs.height) {
+ div.style.height = attrs.height + "px";
}
- if (this.height_ == 0) {
- this.error("dygraph has zero height. Please specify a height in pixels.");
+ if (div.style.height === '' && div.clientHeight === 0) {
+ div.style.height = Dygraph.DEFAULT_HEIGHT + "px";
+ if (div.style.width === '') {
+ div.style.width = Dygraph.DEFAULT_WIDTH + "px";
+ }
}
+ // These will be zero if the dygraph's div is hidden. In that case,
+ // use the user-specified attributes if present. If not, use zero
+ // and assume the user will call resize to fix things later.
+ this.width_ = div.clientWidth || attrs.width || 0;
+ this.height_ = div.clientHeight || attrs.height || 0;
// TODO(danvk): set fillGraph to be part of attrs_ here, not user_attrs_.
- if (attrs['stackedGraph']) {
- attrs['fillGraph'] = true;
+ if (attrs.stackedGraph) {
+ attrs.fillGraph = true;
// TODO(nikhilk): Add any other stackedGraph checks here.
}
+ // DEPRECATION WARNING: All option processing should be moved from
+ // attrs_ and user_attrs_ to options_, which holds all this information.
+ //
// Dygraphs has many options, some of which interact with one another.
// To keep track of everything, we maintain two sets of options:
//
@@ -269,31 +498,119 @@ Dygraph.prototype.__init__ = function(div, file, attrs) {
this.user_attrs_ = {};
Dygraph.update(this.user_attrs_, attrs);
+ // This sequence ensures that Dygraph.DEFAULT_ATTRS is never modified.
this.attrs_ = {};
- Dygraph.update(this.attrs_, Dygraph.DEFAULT_ATTRS);
+ Dygraph.updateDeep(this.attrs_, Dygraph.DEFAULT_ATTRS);
this.boundaryIds_ = [];
+ this.setIndexByName_ = {};
+ this.datasetIndex_ = [];
+
+ this.registeredEvents_ = [];
+ this.eventListeners_ = {};
+
+ this.attributes_ = new DygraphOptions(this);
// Create the containing DIV and other interactive elements
this.createInterface_();
+ // Activate plugins.
+ this.plugins_ = [];
+ var plugins = Dygraph.PLUGINS.concat(this.getOption('plugins'));
+ for (var i = 0; i < plugins.length; i++) {
+ var Plugin = plugins[i];
+ var pluginInstance = new Plugin();
+ var pluginDict = {
+ plugin: pluginInstance,
+ events: {},
+ options: {},
+ pluginOptions: {}
+ };
+
+ var handlers = pluginInstance.activate(this);
+ for (var eventName in handlers) {
+ // TODO(danvk): validate eventName.
+ pluginDict.events[eventName] = handlers[eventName];
+ }
+
+ this.plugins_.push(pluginDict);
+ }
+
+ // At this point, plugins can no longer register event handlers.
+ // Construct a map from event -> ordered list of [callback, plugin].
+ for (var i = 0; i < this.plugins_.length; i++) {
+ var plugin_dict = this.plugins_[i];
+ for (var eventName in plugin_dict.events) {
+ if (!plugin_dict.events.hasOwnProperty(eventName)) continue;
+ var callback = plugin_dict.events[eventName];
+
+ var pair = [plugin_dict.plugin, callback];
+ if (!(eventName in this.eventListeners_)) {
+ this.eventListeners_[eventName] = [pair];
+ } else {
+ this.eventListeners_[eventName].push(pair);
+ }
+ }
+ }
+
+ this.createDragInterface_();
+
this.start_();
};
/**
+ * Triggers a cascade of events to the various plugins which are interested in them.
+ * Returns true if the "default behavior" should be performed, i.e. if none of
+ * the event listeners called event.preventDefault().
+ * @private
+ */
+Dygraph.prototype.cascadeEvents_ = function(name, extra_props) {
+ if (!(name in this.eventListeners_)) return true;
+
+ // QUESTION: can we use objects & prototypes to speed this up?
+ var e = {
+ dygraph: this,
+ cancelable: false,
+ defaultPrevented: false,
+ preventDefault: function() {
+ if (!e.cancelable) throw "Cannot call preventDefault on non-cancelable event.";
+ e.defaultPrevented = true;
+ },
+ propagationStopped: false,
+ stopPropagation: function() {
+ e.propagationStopped = true;
+ }
+ };
+ Dygraph.update(e, extra_props);
+
+ var callback_plugin_pairs = this.eventListeners_[name];
+ if (callback_plugin_pairs) {
+ for (var i = callback_plugin_pairs.length - 1; i >= 0; i--) {
+ var plugin = callback_plugin_pairs[i][0];
+ var callback = callback_plugin_pairs[i][1];
+ callback.call(plugin, e);
+ if (e.propagationStopped) break;
+ }
+ }
+ return e.defaultPrevented;
+};
+
+/**
* Returns the zoomed status of the chart for one or both axes.
*
* Axis is an optional parameter. Can be set to 'x' or 'y'.
*
* The zoomed status for an axis is set whenever a user zooms using the mouse
- * or when the dateWindow or valueRange are updated (unless the isZoomedIgnoreProgrammaticZoom
- * option is also specified).
+ * or when the dateWindow or valueRange are updated (unless the
+ * isZoomedIgnoreProgrammaticZoom option is also specified).
*/
Dygraph.prototype.isZoomed = function(axis) {
- if (axis == null) return this.zoomed_x_ || this.zoomed_y_;
- if (axis == 'x') return this.zoomed_x_;
- if (axis == 'y') return this.zoomed_y_;
- throw "axis parameter to Dygraph.isZoomed must be missing, 'x' or 'y'.";
+ if (axis === null || axis === undefined) {
+ return this.zoomed_x_ || this.zoomed_y_;
+ }
+ if (axis === 'x') return this.zoomed_x_;
+ if (axis === 'y') return this.zoomed_y_;
+ throw "axis parameter is [" + axis + "] must be null, 'x' or 'y'.";
};
/**
@@ -301,9 +618,9 @@ Dygraph.prototype.isZoomed = function(axis) {
*/
Dygraph.prototype.toString = function() {
var maindiv = this.maindiv_;
- var id = (maindiv && maindiv.id) ? maindiv.id : maindiv
+ var id = (maindiv && maindiv.id) ? maindiv.id : maindiv;
return "[Dygraph " + id + "]";
-}
+};
/**
* @private
@@ -327,18 +644,62 @@ Dygraph.prototype.attr_ = function(name, seriesName) {
Dygraph.OPTIONS_REFERENCE[name] = true;
}
//
- if (seriesName &&
- typeof(this.user_attrs_[seriesName]) != 'undefined' &&
- this.user_attrs_[seriesName] != null &&
- typeof(this.user_attrs_[seriesName][name]) != 'undefined') {
- return this.user_attrs_[seriesName][name];
- } else if (typeof(this.user_attrs_[name]) != 'undefined') {
- return this.user_attrs_[name];
- } else if (typeof(this.attrs_[name]) != 'undefined') {
- return this.attrs_[name];
- } else {
- return null;
- }
+ return seriesName ? this.attributes_.getForSeries(name, seriesName) : this.attributes_.get(name);
+};
+
+/**
+ * Returns the current value for an option, as set in the constructor or via
+ * updateOptions. You may pass in an (optional) series name to get per-series
+ * values for the option.
+ *
+ * All values returned by this method should be considered immutable. If you
+ * modify them, there is no guarantee that the changes will be honored or that
+ * dygraphs will remain in a consistent state. If you want to modify an option,
+ * use updateOptions() instead.
+ *
+ * @param { String } name The name of the option (e.g. 'strokeWidth')
+ * @param { String } [opt_seriesName] Series name to get per-series values.
+ * @return { ... } The value of the option.
+ */
+Dygraph.prototype.getOption = function(name, opt_seriesName) {
+ return this.attr_(name, opt_seriesName);
+};
+
+Dygraph.prototype.getOptionForAxis = function(name, axis) {
+ return this.attributes_.getForAxis(name, axis);
+};
+
+/**
+ * @private
+ * @param String} axis The name of the axis (i.e. 'x', 'y' or 'y2')
+ * @return { ... } A function mapping string -> option value
+ */
+Dygraph.prototype.optionsViewForAxis_ = function(axis) {
+ var self = this;
+ return function(opt) {
+ var axis_opts = self.user_attrs_.axes;
+ if (axis_opts && axis_opts[axis] && axis_opts[axis].hasOwnProperty(opt)) {
+ return axis_opts[axis][opt];
+ }
+ // user-specified attributes always trump defaults, even if they're less
+ // specific.
+ if (typeof(self.user_attrs_[opt]) != 'undefined') {
+ return self.user_attrs_[opt];
+ }
+
+ axis_opts = self.attrs_.axes;
+ if (axis_opts && axis_opts[axis] && axis_opts[axis].hasOwnProperty(opt)) {
+ return axis_opts[axis][opt];
+ }
+ // check old-style axis options
+ // TODO(danvk): add a deprecation warning if either of these match.
+ if (axis == 'y' && self.axes_[0].hasOwnProperty(opt)) {
+ return self.axes_[0][opt];
+ } else if (axis == 'y2' && self.axes_[1].hasOwnProperty(opt)) {
+ return self.axes_[1][opt];
+ }
+ return self.attr_(opt);
+ };
};
/**
@@ -364,8 +725,18 @@ Dygraph.prototype.xAxisRange = function() {
* data set.
*/
Dygraph.prototype.xAxisExtremes = function() {
+ var pad = this.attr_('xRangePad') / this.plotter_.area.w;
+ if (this.numRows() === 0) {
+ return [0 - pad, 1 + pad];
+ }
var left = this.rawData_[0][0];
var right = this.rawData_[this.rawData_.length - 1][0];
+ if (pad) {
+ // Must keep this in sync with dygraph-layout _evaluateLimits()
+ var range = right - left;
+ left -= range * pad;
+ right += range * pad;
+ }
return [left, right];
};
@@ -418,14 +789,14 @@ Dygraph.prototype.toDomCoords = function(x, y, axis) {
* Returns a single value or null if x is null.
*/
Dygraph.prototype.toDomXCoord = function(x) {
- if (x == null) {
+ if (x === null) {
return null;
- };
+ }
var area = this.plotter_.area;
var xRange = this.xAxisRange();
return area.x + (x - xRange[0]) / (xRange[1] - xRange[0]) * area.w;
-}
+};
/**
* Convert from data x coordinates to canvas/div Y coordinate and optional
@@ -436,12 +807,12 @@ Dygraph.prototype.toDomXCoord = function(x) {
Dygraph.prototype.toDomYCoord = function(y, axis) {
var pct = this.toPercentYCoord(y, axis);
- if (pct == null) {
+ if (pct === null) {
return null;
}
var area = this.plotter_.area;
return area.y + pct * area.h;
-}
+};
/**
* Convert from canvas/div coords to data coordinates.
@@ -462,7 +833,7 @@ Dygraph.prototype.toDataCoords = function(x, y, axis) {
* If x is null, this returns null.
*/
Dygraph.prototype.toDataXCoord = function(x) {
- if (x == null) {
+ if (x === null) {
return null;
}
@@ -478,7 +849,7 @@ Dygraph.prototype.toDataXCoord = function(x) {
* if axis is null, this uses the first axis.
*/
Dygraph.prototype.toDataYCoord = function(y, axis) {
- if (y == null) {
+ if (y === null) {
return null;
}
@@ -486,11 +857,11 @@ Dygraph.prototype.toDataYCoord = function(y, axis) {
var yRange = this.yAxisRange(axis);
if (typeof(axis) == "undefined") axis = 0;
- if (!this.axes_[axis].logscale) {
+ if (!this.attributes_.getForAxis("logscale", axis)) {
return yRange[0] + (area.y + area.h - y) / area.h * (yRange[1] - yRange[0]);
} else {
// Computing the inverse of toDomCoord.
- var pct = (y - area.y) / area.h
+ var pct = (y - area.y) / area.h;
// Computing the inverse of toPercentYCoord. The function was arrived at with
// the following steps:
@@ -533,16 +904,16 @@ Dygraph.prototype.toDataYCoord = function(y, axis) {
* @return { Number } A fraction in [0, 1] where 0 = the top edge.
*/
Dygraph.prototype.toPercentYCoord = function(y, axis) {
- if (y == null) {
+ if (y === null) {
return null;
}
if (typeof(axis) == "undefined") axis = 0;
- var area = this.plotter_.area;
var yRange = this.yAxisRange(axis);
var pct;
- if (!this.axes_[axis].logscale) {
+ var logscale = this.attributes_.getForAxis("logscale", axis);
+ if (!logscale) {
// yRange[1] - y is unit distance from the bottom.
// yRange[1] - yRange[0] is the scale of the range.
// (yRange[1] - y) / (yRange[1] - yRange[0]) is the % from the bottom.
@@ -552,7 +923,7 @@ Dygraph.prototype.toPercentYCoord = function(y, axis) {
pct = (logr1 - Dygraph.log10(y)) / (logr1 - Dygraph.log10(yRange[0]));
}
return pct;
-}
+};
/**
* Converts an x value to a percentage from the left to the right of
@@ -568,7 +939,7 @@ Dygraph.prototype.toPercentYCoord = function(y, axis) {
* @return { Number } A fraction in [0, 1] where 0 = the left edge.
*/
Dygraph.prototype.toPercentXCoord = function(x) {
- if (x == null) {
+ if (x === null) {
return null;
}
@@ -581,7 +952,8 @@ Dygraph.prototype.toPercentXCoord = function(x) {
* @return { Integer } The number of columns.
*/
Dygraph.prototype.numColumns = function() {
- return this.rawData_[0].length;
+ if (!this.rawData_) return 0;
+ return this.rawData_[0] ? this.rawData_[0].length : this.attr_("labels").length;
};
/**
@@ -589,6 +961,7 @@ Dygraph.prototype.numColumns = function() {
* @return { Integer } The number of rows, less any header.
*/
Dygraph.prototype.numRows = function() {
+ if (!this.rawData_) return 0;
return this.rawData_.length;
};
@@ -620,42 +993,76 @@ Dygraph.prototype.createInterface_ = function() {
var enclosing = this.maindiv_;
this.graphDiv = document.createElement("div");
- this.graphDiv.style.width = this.width_ + "px";
- this.graphDiv.style.height = this.height_ + "px";
+
+ // TODO(danvk): any other styles that are useful to set here?
+ this.graphDiv.style.textAlign = 'left'; // This is a CSS "reset"
enclosing.appendChild(this.graphDiv);
// Create the canvas for interactive parts of the chart.
this.canvas_ = Dygraph.createCanvas();
this.canvas_.style.position = "absolute";
- this.canvas_.width = this.width_;
- this.canvas_.height = this.height_;
- this.canvas_.style.width = this.width_ + "px"; // for IE
- this.canvas_.style.height = this.height_ + "px"; // for IE
-
- this.canvas_ctx_ = Dygraph.getContext(this.canvas_);
// ... and for static parts of the chart.
this.hidden_ = this.createPlotKitCanvas_(this.canvas_);
+
+ this.resizeElements_();
+
+ this.canvas_ctx_ = Dygraph.getContext(this.canvas_);
this.hidden_ctx_ = Dygraph.getContext(this.hidden_);
// The interactive parts of the graph are drawn on top of the chart.
this.graphDiv.appendChild(this.hidden_);
this.graphDiv.appendChild(this.canvas_);
- this.mouseEventElement_ = this.canvas_;
+ this.mouseEventElement_ = this.createMouseEventElement_();
+
+ // Create the grapher
+ this.layout_ = new DygraphLayout(this);
var dygraph = this;
- Dygraph.addEvent(this.mouseEventElement_, 'mousemove', function(e) {
+
+ this.mouseMoveHandler_ = function(e) {
dygraph.mouseMove_(e);
- });
- Dygraph.addEvent(this.mouseEventElement_, 'mouseout', function(e) {
- dygraph.mouseOut_(e);
- });
+ };
- // Create the grapher
- this.layout_ = new DygraphLayout(this);
+ this.mouseOutHandler_ = function(e) {
+ // The mouse has left the chart if:
+ // 1. e.target is inside the chart
+ // 2. e.relatedTarget is outside the chart
+ var target = e.target || e.fromElement;
+ var relatedTarget = e.relatedTarget || e.toElement;
+ if (Dygraph.isNodeContainedBy(target, dygraph.graphDiv) &&
+ !Dygraph.isNodeContainedBy(relatedTarget, dygraph.graphDiv)) {
+ dygraph.mouseOut_(e);
+ }
+ };
- this.createStatusMessage_();
- this.createDragInterface_();
+ this.addAndTrackEvent(window, 'mouseout', this.mouseOutHandler_);
+ this.addAndTrackEvent(this.mouseEventElement_, 'mousemove', this.mouseMoveHandler_);
+
+ // Don't recreate and register the resize handler on subsequent calls.
+ // This happens when the graph is resized.
+ if (!this.resizeHandler_) {
+ this.resizeHandler_ = function(e) {
+ dygraph.resize();
+ };
+
+ // Update when the window is resized.
+ // TODO(danvk): drop frames depending on complexity of the chart.
+ this.addAndTrackEvent(window, 'resize', this.resizeHandler_);
+ }
+};
+
+Dygraph.prototype.resizeElements_ = function() {
+ this.graphDiv.style.width = this.width_ + "px";
+ this.graphDiv.style.height = this.height_ + "px";
+ this.canvas_.width = this.width_;
+ this.canvas_.height = this.height_;
+ this.canvas_.style.width = this.width_ + "px"; // for IE
+ this.canvas_.style.height = this.height_ + "px"; // for IE
+ this.hidden_.width = this.width_;
+ this.hidden_.height = this.height_;
+ this.hidden_.style.width = this.width_ + "px"; // for IE
+ this.hidden_.style.height = this.height_ + "px"; // for IE
};
/**
@@ -664,12 +1071,26 @@ Dygraph.prototype.createInterface_ = function() {
* usage. See, e.g., the tests/perf.html example.
*/
Dygraph.prototype.destroy = function() {
+ this.canvas_ctx_.restore();
+ this.hidden_ctx_.restore();
+
var removeRecursive = function(node) {
while (node.hasChildNodes()) {
removeRecursive(node.firstChild);
node.removeChild(node.firstChild);
}
};
+
+ this.removeTrackedEvents_();
+
+ // remove mouse event handlers (This may not be necessary anymore)
+ Dygraph.removeEvent(window, 'mouseout', this.mouseOutHandler_);
+ Dygraph.removeEvent(this.mouseEventElement_, 'mousemove', this.mouseMoveHandler_);
+
+ // remove window handlers
+ Dygraph.removeEvent(window,'resize',this.resizeHandler_);
+ this.resizeHandler_ = null;
+
removeRecursive(this.maindiv_);
var nullOut = function(obj) {
@@ -679,7 +1100,6 @@ Dygraph.prototype.destroy = function() {
}
}
};
-
// These may not all be necessary, but it can't hurt...
nullOut(this.layout_);
nullOut(this.plotter_);
@@ -710,6 +1130,26 @@ Dygraph.prototype.createPlotKitCanvas_ = function(canvas) {
};
/**
+ * Creates an overlay element used to handle mouse events.
+ * @return {Object} The mouse event element.
+ * @private
+ */
+Dygraph.prototype.createMouseEventElement_ = function() {
+ if (this.isUsingExcanvas_) {
+ var elem = document.createElement("div");
+ elem.style.position = 'absolute';
+ elem.style.backgroundColor = 'white';
+ elem.style.filter = 'alpha(opacity=0)';
+ elem.style.width = this.width_ + "px";
+ elem.style.height = this.height_ + "px";
+ this.graphDiv.appendChild(elem);
+ return elem;
+ } else {
+ return this.canvas_;
+ }
+};
+
+/**
* Generate a set of distinct colors for the data series. This is done with a
* color wheel. Saturation/Value are customizable, and the hue is
* equally-spaced around the color wheel. If a custom set of colors is
@@ -717,34 +1157,39 @@ Dygraph.prototype.createPlotKitCanvas_ = function(canvas) {
* @private
*/
Dygraph.prototype.setColors_ = function() {
- var num = this.attr_("labels").length - 1;
+ var labels = this.getLabels();
+ var num = labels.length - 1;
this.colors_ = [];
+ this.colorsMap_ = {};
var colors = this.attr_('colors');
+ var i;
if (!colors) {
var sat = this.attr_('colorSaturation') || 1.0;
var val = this.attr_('colorValue') || 0.5;
var half = Math.ceil(num / 2);
- for (var i = 1; i <= num; i++) {
+ for (i = 1; i <= num; i++) {
if (!this.visibility()[i-1]) continue;
// alternate colors for high contrast.
var idx = i % 2 ? Math.ceil(i / 2) : (half + i / 2);
var hue = (1.0 * idx/ (1 + num));
- this.colors_.push(Dygraph.hsvToRGB(hue, sat, val));
+ var colorStr = Dygraph.hsvToRGB(hue, sat, val);
+ this.colors_.push(colorStr);
+ this.colorsMap_[labels[i]] = colorStr;
}
} else {
- for (var i = 0; i < num; i++) {
+ for (i = 0; i < num; i++) {
if (!this.visibility()[i]) continue;
var colorStr = colors[i % colors.length];
this.colors_.push(colorStr);
+ this.colorsMap_[labels[1 + i]] = colorStr;
}
}
-
- this.plotter_.setColors(this.colors_);
};
/**
* Return the list of colors. This is either the list of colors passed in the
* attributes or the autogenerated list of rgb(r,g,b) strings.
+ * This does not return colors for invisible series.
* @return {Array} The list of colors.
*/
Dygraph.prototype.getColors = function() {
@@ -752,55 +1197,32 @@ Dygraph.prototype.getColors = function() {
};
/**
- * Create the div that contains information on the selected point(s)
- * This goes in the top right of the canvas, unless an external div has already
- * been specified.
- * @private
+ * Returns a few attributes of a series, i.e. its color, its visibility, which
+ * axis it's assigned to, and its column in the original data.
+ * Returns null if the series does not exist.
+ * Otherwise, returns an object with column, visibility, color and axis properties.
+ * The "axis" property will be set to 1 for y1 and 2 for y2.
+ * The "column" property can be fed back into getValue(row, column) to get
+ * values for this series.
*/
-Dygraph.prototype.createStatusMessage_ = function() {
- var userLabelsDiv = this.user_attrs_["labelsDiv"];
- if (userLabelsDiv && null != userLabelsDiv
- && (typeof(userLabelsDiv) == "string" || userLabelsDiv instanceof String)) {
- this.user_attrs_["labelsDiv"] = document.getElementById(userLabelsDiv);
- }
- if (!this.attr_("labelsDiv")) {
- var divWidth = this.attr_('labelsDivWidth');
- var messagestyle = {
- "position": "absolute",
- "fontSize": "14px",
- "zIndex": 10,
- "width": divWidth + "px",
- "top": "0px",
- "left": (this.width_ - divWidth - 2) + "px",
- "background": "white",
- "textAlign": "left",
- "overflow": "hidden"};
- Dygraph.update(messagestyle, this.attr_('labelsDivStyles'));
- var div = document.createElement("div");
- for (var name in messagestyle) {
- if (messagestyle.hasOwnProperty(name)) {
- div.style[name] = messagestyle[name];
- }
+Dygraph.prototype.getPropertiesForSeries = function(series_name) {
+ var idx = -1;
+ var labels = this.getLabels();
+ for (var i = 1; i < labels.length; i++) {
+ if (labels[i] == series_name) {
+ idx = i;
+ break;
}
- this.graphDiv.appendChild(div);
- this.attrs_.labelsDiv = div;
}
-};
+ if (idx == -1) return null;
-/**
- * Position the labels div so that:
- * - its right edge is flush with the right edge of the charting area
- * - its top edge is flush with the top edge of the charting area
- * @private
- */
-Dygraph.prototype.positionLabelsDiv_ = function() {
- // Don't touch a user-specified labelsDiv.
- if (this.user_attrs_.hasOwnProperty("labelsDiv")) return;
-
- var area = this.plotter_.area;
- var div = this.attr_("labelsDiv");
- div.style.left = area.x + area.w - this.attr_("labelsDivWidth") - 1 + "px";
- div.style.top = area.y + "px";
+ return {
+ name: series_name,
+ column: idx,
+ visible: this.visibility()[idx - 1],
+ color: this.colorsMap_[series_name],
+ axis: 1 + this.attributes_.axisForSeries(series_name)
+ };
};
/**
@@ -843,7 +1265,7 @@ Dygraph.prototype.createRollInterface_ = function() {
* canvas (i.e. DOM Coords).
*/
Dygraph.prototype.dragGetX_ = function(e, context) {
- return Dygraph.pageX(e) - context.px
+ return Dygraph.pageX(e) - context.px;
};
/**
@@ -852,7 +1274,7 @@ Dygraph.prototype.dragGetX_ = function(e, context) {
* canvas (i.e. DOM Coords).
*/
Dygraph.prototype.dragGetY_ = function(e, context) {
- return Dygraph.pageY(e) - context.py
+ return Dygraph.pageY(e) - context.py;
};
/**
@@ -866,14 +1288,15 @@ Dygraph.prototype.createDragInterface_ = function() {
isZooming: false,
isPanning: false, // is this drag part of a pan?
is2DPan: false, // if so, is that pan 1- or 2-dimensional?
- dragStartX: null,
- dragStartY: null,
- dragEndX: null,
- dragEndY: null,
+ dragStartX: null, // pixel coordinates
+ dragStartY: null, // pixel coordinates
+ dragEndX: null, // pixel coordinates
+ dragEndY: null, // pixel coordinates
dragDirection: null,
- prevEndX: null,
- prevEndY: null,
+ prevEndX: null, // pixel coordinates
+ prevEndY: null, // pixel coordinates
prevDragDirection: null,
+ cancelNextDblclick: false, // see comment in dygraph-interaction-model.js
// The value on the left side of the graph when a pan operation starts.
initialLeftmostDate: null,
@@ -887,7 +1310,8 @@ Dygraph.prototype.createDragInterface_ = function() {
// panning operation.
dateRange: null,
- // Utility function to convert page-wide coordinates to canvas coords
+ // Top-left corner of the canvas, in DOM coords
+ // TODO(konigsberg): Rename topLeftCanvasX, topLeftCanvasY.
px: 0,
py: 0,
@@ -896,7 +1320,12 @@ Dygraph.prototype.createDragInterface_ = function() {
boundedDates: null, // [minDate, maxDate]
boundedValues: null, // [[minValue, maxValue] ...]
- initializeMouseDown: function(event, g, context) {
+ // We cover iframes during mouse interactions. See comments in
+ // dygraph-utils.js for more info on why this is a good idea.
+ tarp: new Dygraph.IFrameTarp(),
+
+ // contextB is the same thing as this context object but renamed.
+ initializeMouseDown: function(event, g, contextB) {
// prevents mouse drags from selecting page text.
if (event.preventDefault) {
event.preventDefault(); // Firefox, Chrome, etc.
@@ -905,10 +1334,12 @@ Dygraph.prototype.createDragInterface_ = function() {
event.cancelBubble = true;
}
- context.px = Dygraph.findPosX(g.canvas_);
- context.py = Dygraph.findPosY(g.canvas_);
- context.dragStartX = g.dragGetX_(event, context);
- context.dragStartY = g.dragGetY_(event, context);
+ contextB.px = Dygraph.findPosX(g.canvas_);
+ contextB.py = Dygraph.findPosY(g.canvas_);
+ contextB.dragStartX = g.dragGetX_(event, contextB);
+ contextB.dragStartY = g.dragGetY_(event, contextB);
+ contextB.cancelNextDblclick = false;
+ contextB.tarp.cover();
}
};
@@ -926,13 +1357,13 @@ Dygraph.prototype.createDragInterface_ = function() {
for (var eventName in interactionModel) {
if (!interactionModel.hasOwnProperty(eventName)) continue;
- Dygraph.addEvent(this.mouseEventElement_, eventName,
+ this.addAndTrackEvent(this.mouseEventElement_, eventName,
bindHandler(interactionModel[eventName]));
}
// If the user releases the mouse button during a drag, but not over the
// canvas, then it doesn't count as a zooming action.
- Dygraph.addEvent(document, 'mouseup', function(event) {
+ var mouseUpHandler = function(event) {
if (context.isZooming || context.isPanning) {
context.isZooming = false;
context.dragStartX = null;
@@ -948,16 +1379,19 @@ Dygraph.prototype.createDragInterface_ = function() {
delete self.axes_[i].dragValueRange;
}
}
- });
-};
+ context.tarp.uncover();
+ };
+
+ this.addAndTrackEvent(document, 'mouseup', mouseUpHandler);
+};
/**
* Draw a gray zoom rectangle over the desired area of the canvas. Also clears
* up any previous zoom rectangles that were drawn. This could be optimized to
* avoid extra redrawing, but it's tricky to avoid interactions with the status
* dots.
- *
+ *
* @param {Number} direction the direction of the zoom rectangle. Acceptable
* values are Dygraph.HORIZONTAL and Dygraph.VERTICAL.
* @param {Number} startX The X position where the drag started, in canvas
@@ -981,28 +1415,40 @@ Dygraph.prototype.drawZoomRect_ = function(direction, startX, endX, startY,
// Clean up from the previous rect if necessary
if (prevDirection == Dygraph.HORIZONTAL) {
- ctx.clearRect(Math.min(startX, prevEndX), 0,
- Math.abs(startX - prevEndX), this.height_);
- } else if (prevDirection == Dygraph.VERTICAL){
- ctx.clearRect(0, Math.min(startY, prevEndY),
- this.width_, Math.abs(startY - prevEndY));
+ ctx.clearRect(Math.min(startX, prevEndX), this.layout_.getPlotArea().y,
+ Math.abs(startX - prevEndX), this.layout_.getPlotArea().h);
+ } else if (prevDirection == Dygraph.VERTICAL) {
+ ctx.clearRect(this.layout_.getPlotArea().x, Math.min(startY, prevEndY),
+ this.layout_.getPlotArea().w, Math.abs(startY - prevEndY));
}
// Draw a light-grey rectangle to show the new viewing area
if (direction == Dygraph.HORIZONTAL) {
if (endX && startX) {
ctx.fillStyle = "rgba(128,128,128,0.33)";
- ctx.fillRect(Math.min(startX, endX), 0,
- Math.abs(endX - startX), this.height_);
+ ctx.fillRect(Math.min(startX, endX), this.layout_.getPlotArea().y,
+ Math.abs(endX - startX), this.layout_.getPlotArea().h);
}
- }
- if (direction == Dygraph.VERTICAL) {
+ } else if (direction == Dygraph.VERTICAL) {
if (endY && startY) {
ctx.fillStyle = "rgba(128,128,128,0.33)";
- ctx.fillRect(0, Math.min(startY, endY),
- this.width_, Math.abs(endY - startY));
+ ctx.fillRect(this.layout_.getPlotArea().x, Math.min(startY, endY),
+ this.layout_.getPlotArea().w, Math.abs(endY - startY));
}
}
+
+ if (this.isUsingExcanvas_) {
+ this.currentZoomRectArgs_ = [direction, startX, endX, startY, endY, 0, 0, 0];
+ }
+};
+
+/**
+ * Clear the zoom rectangle (and perform no zoom).
+ * @private
+ */
+Dygraph.prototype.clearZoomRect_ = function() {
+ this.currentZoomRectArgs_ = null;
+ this.canvas_ctx_.clearRect(0, 0, this.canvas_.width, this.canvas_.height);
};
/**
@@ -1016,6 +1462,7 @@ Dygraph.prototype.drawZoomRect_ = function(direction, startX, endX, startY,
* @private
*/
Dygraph.prototype.doZoomX_ = function(lowX, highX) {
+ this.currentZoomRectArgs_ = null;
// Find the earliest and latest dates contained in this canvasx range.
// Convert the call to date ranges of the raw data.
var minDate = this.toDataXCoord(lowX);
@@ -1024,6 +1471,16 @@ Dygraph.prototype.doZoomX_ = function(lowX, highX) {
};
/**
+ * Transition function to use in animations. Returns values between 0.0
+ * (totally old values) and 1.0 (totally new values) for each frame.
+ * @private
+ */
+Dygraph.zoomAnimationFunction = function(frame, numFrames) {
+ var k = 1.5;
+ return (1.0 - Math.pow(k, -frame)) / (1.0 - Math.pow(k, -numFrames));
+};
+
+/**
* Zoom to something containing [minDate, maxDate] values. Don't confuse this
* method with doZoomX which accepts pixel coordinates. This function redraws
* the graph.
@@ -1033,12 +1490,18 @@ Dygraph.prototype.doZoomX_ = function(lowX, highX) {
* @private
*/
Dygraph.prototype.doZoomXDates_ = function(minDate, maxDate) {
- this.dateWindow_ = [minDate, maxDate];
+ // TODO(danvk): when yAxisRange is null (i.e. "fit to data", the animation
+ // can produce strange effects. Rather than the y-axis transitioning slowly
+ // between values, it can jerk around.)
+ var old_window = this.xAxisRange();
+ var new_window = [minDate, maxDate];
this.zoomed_x_ = true;
- this.drawGraph_();
- if (this.attr_("zoomCallback")) {
- this.attr_("zoomCallback")(minDate, maxDate, this.yAxisRanges());
- }
+ var that = this;
+ this.doAnimatedZoom(old_window, new_window, null, null, function() {
+ if (that.attr_("zoomCallback")) {
+ that.attr_("zoomCallback")(minDate, maxDate, that.yAxisRanges());
+ }
+ });
};
/**
@@ -1050,44 +1513,44 @@ Dygraph.prototype.doZoomXDates_ = function(minDate, maxDate) {
* @private
*/
Dygraph.prototype.doZoomY_ = function(lowY, highY) {
+ this.currentZoomRectArgs_ = null;
// Find the highest and lowest values in pixel range for each axis.
// Note that lowY (in pixels) corresponds to the max Value (in data coords).
// This is because pixels increase as you go down on the screen, whereas data
// coordinates increase as you go up the screen.
- var valueRanges = [];
+ var oldValueRanges = this.yAxisRanges();
+ var newValueRanges = [];
for (var i = 0; i < this.axes_.length; i++) {
var hi = this.toDataYCoord(lowY, i);
var low = this.toDataYCoord(highY, i);
- this.axes_[i].valueWindow = [low, hi];
- valueRanges.push([low, hi]);
+ newValueRanges.push([low, hi]);
}
this.zoomed_y_ = true;
- this.drawGraph_();
- if (this.attr_("zoomCallback")) {
- var xRange = this.xAxisRange();
- var yRange = this.yAxisRange();
- this.attr_("zoomCallback")(xRange[0], xRange[1], this.yAxisRanges());
- }
+ var that = this;
+ this.doAnimatedZoom(null, null, oldValueRanges, newValueRanges, function() {
+ if (that.attr_("zoomCallback")) {
+ var xRange = that.xAxisRange();
+ that.attr_("zoomCallback")(xRange[0], xRange[1], that.yAxisRanges());
+ }
+ });
};
/**
* Reset the zoom to the original view coordinates. This is the same as
* double-clicking on the graph.
- *
- * @private
*/
-Dygraph.prototype.doUnzoom_ = function() {
- var dirty = false;
- if (this.dateWindow_ != null) {
+Dygraph.prototype.resetZoom = function() {
+ var dirty = false, dirtyX = false, dirtyY = false;
+ if (this.dateWindow_ !== null) {
dirty = true;
- this.dateWindow_ = null;
+ dirtyX = true;
}
for (var i = 0; i < this.axes_.length; i++) {
- if (this.axes_[i].valueWindow != null) {
+ if (typeof(this.axes_[i].valueWindow) !== 'undefined' && this.axes_[i].valueWindow !== null) {
dirty = true;
- delete this.axes_[i].valueWindow;
+ dirtyY = true;
}
}
@@ -1095,192 +1558,400 @@ Dygraph.prototype.doUnzoom_ = function() {
this.clearSelection();
if (dirty) {
- // Putting the drawing operation before the callback because it resets
- // yAxisRange.
this.zoomed_x_ = false;
this.zoomed_y_ = false;
- this.drawGraph_();
- if (this.attr_("zoomCallback")) {
- var minDate = this.rawData_[0][0];
- var maxDate = this.rawData_[this.rawData_.length - 1][0];
- this.attr_("zoomCallback")(minDate, maxDate, this.yAxisRanges());
- }
- }
-};
+
+ var minDate = this.rawData_[0][0];
+ var maxDate = this.rawData_[this.rawData_.length - 1][0];
+
+ // With only one frame, don't bother calculating extreme ranges.
+ // TODO(danvk): merge this block w/ the code below.
+ if (!this.attr_("animatedZooms")) {
+ this.dateWindow_ = null;
+ for (i = 0; i < this.axes_.length; i++) {
+ if (this.axes_[i].valueWindow !== null) {
+ delete this.axes_[i].valueWindow;
+ }
+ }
+ this.drawGraph_();
+ if (this.attr_("zoomCallback")) {
+ this.attr_("zoomCallback")(minDate, maxDate, this.yAxisRanges());
+ }
+ return;
+ }
+
+ var oldWindow=null, newWindow=null, oldValueRanges=null, newValueRanges=null;
+ if (dirtyX) {
+ oldWindow = this.xAxisRange();
+ newWindow = [minDate, maxDate];
+ }
+
+ if (dirtyY) {
+ oldValueRanges = this.yAxisRanges();
+ // TODO(danvk): this is pretty inefficient
+ var packed = this.gatherDatasets_(this.rolledSeries_, null);
+ var extremes = packed.extremes;
+
+ // this has the side-effect of modifying this.axes_.
+ // this doesn't make much sense in this context, but it's convenient (we
+ // need this.axes_[*].extremeValues) and not harmful since we'll be
+ // calling drawGraph_ shortly, which clobbers these values.
+ this.computeYAxisRanges_(extremes);
+
+ newValueRanges = [];
+ for (i = 0; i < this.axes_.length; i++) {
+ var axis = this.axes_[i];
+ newValueRanges.push((axis.valueRange !== null &&
+ axis.valueRange !== undefined) ?
+ axis.valueRange : axis.extremeRange);
+ }
+ }
+
+ var that = this;
+ this.doAnimatedZoom(oldWindow, newWindow, oldValueRanges, newValueRanges,
+ function() {
+ that.dateWindow_ = null;
+ for (var i = 0; i < that.axes_.length; i++) {
+ if (that.axes_[i].valueWindow !== null) {
+ delete that.axes_[i].valueWindow;
+ }
+ }
+ if (that.attr_("zoomCallback")) {
+ that.attr_("zoomCallback")(minDate, maxDate, that.yAxisRanges());
+ }
+ });
+ }
+};
/**
- * When the mouse moves in the canvas, display information about a nearby data
- * point and draw dots over those points in the data series. This function
- * takes care of cleanup of previously-drawn dots.
- * @param {Object} event The mousemove event from the browser.
+ * Combined animation logic for all zoom functions.
+ * either the x parameters or y parameters may be null.
* @private
*/
-Dygraph.prototype.mouseMove_ = function(event) {
- // This prevents JS errors when mousing over the canvas before data loads.
- var points = this.layout_.points;
- if (points === undefined) return;
-
- var canvasx = Dygraph.pageX(event) - Dygraph.findPosX(this.mouseEventElement_);
+Dygraph.prototype.doAnimatedZoom = function(oldXRange, newXRange, oldYRanges, newYRanges, callback) {
+ var steps = this.attr_("animatedZooms") ? Dygraph.ANIMATION_STEPS : 1;
- var lastx = -1;
- var lasty = -1;
+ var windows = [];
+ var valueRanges = [];
+ var step, frac;
- // Loop through all the points and find the date nearest to our current
- // location.
- var minDist = 1e+100;
- var idx = -1;
- for (var i = 0; i < points.length; i++) {
- var point = points[i];
- if (point == null) continue;
- var dist = Math.abs(point.canvasx - canvasx);
- if (dist > minDist) continue;
- minDist = dist;
- idx = i;
+ if (oldXRange !== null && newXRange !== null) {
+ for (step = 1; step <= steps; step++) {
+ frac = Dygraph.zoomAnimationFunction(step, steps);
+ windows[step-1] = [oldXRange[0]*(1-frac) + frac*newXRange[0],
+ oldXRange[1]*(1-frac) + frac*newXRange[1]];
+ }
}
- if (idx >= 0) lastx = points[idx].xval;
- // Extract the points we've selected
- this.selPoints_ = [];
- var l = points.length;
- if (!this.attr_("stackedGraph")) {
- for (var i = 0; i < l; i++) {
- if (points[i].xval == lastx) {
- this.selPoints_.push(points[i]);
+ if (oldYRanges !== null && newYRanges !== null) {
+ for (step = 1; step <= steps; step++) {
+ frac = Dygraph.zoomAnimationFunction(step, steps);
+ var thisRange = [];
+ for (var j = 0; j < this.axes_.length; j++) {
+ thisRange.push([oldYRanges[j][0]*(1-frac) + frac*newYRanges[j][0],
+ oldYRanges[j][1]*(1-frac) + frac*newYRanges[j][1]]);
}
+ valueRanges[step-1] = thisRange;
}
- } else {
- // Need to 'unstack' points starting from the bottom
- var cumulative_sum = 0;
- for (var i = l - 1; i >= 0; i--) {
- if (points[i].xval == lastx) {
- var p = {}; // Clone the point since we modify it
- for (var k in points[i]) {
- p[k] = points[i][k];
- }
- p.yval -= cumulative_sum;
- cumulative_sum += p.yval;
- this.selPoints_.push(p);
+ }
+
+ var that = this;
+ Dygraph.repeatAndCleanup(function(step) {
+ if (valueRanges.length) {
+ for (var i = 0; i < that.axes_.length; i++) {
+ var w = valueRanges[step][i];
+ that.axes_[i].valueWindow = [w[0], w[1]];
}
}
- this.selPoints_.reverse();
+ if (windows.length) {
+ that.dateWindow_ = windows[step];
+ }
+ that.drawGraph_();
+ }, steps, Dygraph.ANIMATION_DURATION / steps, callback);
+};
+
+/**
+ * Get the current graph's area object.
+ *
+ * Returns: {x, y, w, h}
+ */
+Dygraph.prototype.getArea = function() {
+ return this.plotter_.area;
+};
+
+/**
+ * Convert a mouse event to DOM coordinates relative to the graph origin.
+ *
+ * Returns a two-element array: [X, Y].
+ */
+Dygraph.prototype.eventToDomCoords = function(event) {
+ if (event.offsetX && event.offsetY) {
+ return [ event.offsetX, event.offsetY ];
+ } else {
+ var canvasx = Dygraph.pageX(event) - Dygraph.findPosX(this.mouseEventElement_);
+ var canvasy = Dygraph.pageY(event) - Dygraph.findPosY(this.mouseEventElement_);
+ return [canvasx, canvasy];
}
+};
- if (this.attr_("highlightCallback")) {
- var px = this.lastx_;
- if (px !== null && lastx != px) {
- // only fire if the selected point has changed.
- this.attr_("highlightCallback")(event, lastx, this.selPoints_, this.idxToRow_(idx));
+/**
+ * Given a canvas X coordinate, find the closest row.
+ * @param {Number} domX graph-relative DOM X coordinate
+ * Returns: row number, integer
+ * @private
+ */
+Dygraph.prototype.findClosestRow = function(domX) {
+ var minDistX = Infinity;
+ var closestRow = -1;
+ var sets = this.layout_.points;
+ for (var i = 0; i < sets.length; i++) {
+ var points = sets[i];
+ var len = points.length;
+ for (var j = 0; j < len; j++) {
+ var point = points[j];
+ if (!Dygraph.isValidPoint(point, true)) continue;
+ var dist = Math.abs(point.canvasx - domX);
+ if (dist < minDistX) {
+ minDistX = dist;
+ closestRow = point.idx;
+ }
}
}
- // Save last x position for callbacks.
- this.lastx_ = lastx;
-
- this.updateSelection_();
+ return closestRow;
};
/**
- * Transforms layout_.points index into data row number.
- * @param int layout_.points index
- * @return int row number, or -1 if none could be found.
+ * Given canvas X,Y coordinates, find the closest point.
+ *
+ * This finds the individual data point across all visible series
+ * that's closest to the supplied DOM coordinates using the standard
+ * Euclidean X,Y distance.
+ *
+ * @param {Number} domX graph-relative DOM X coordinate
+ * @param {Number} domY graph-relative DOM Y coordinate
+ * Returns: {row, seriesName, point}
* @private
*/
-Dygraph.prototype.idxToRow_ = function(idx) {
- if (idx < 0) return -1;
-
- for (var i in this.layout_.datasets) {
- if (idx < this.layout_.datasets[i].length) {
- return this.boundaryIds_[0][0]+idx;
+Dygraph.prototype.findClosestPoint = function(domX, domY) {
+ var minDist = Infinity;
+ var dist, dx, dy, point, closestPoint, closestSeries, closestRow;
+ for ( var setIdx = this.layout_.points.length - 1 ; setIdx >= 0 ; --setIdx ) {
+ var points = this.layout_.points[setIdx];
+ for (var i = 0; i < points.length; ++i) {
+ point = points[i];
+ if (!Dygraph.isValidPoint(point)) continue;
+ dx = point.canvasx - domX;
+ dy = point.canvasy - domY;
+ dist = dx * dx + dy * dy;
+ if (dist < minDist) {
+ minDist = dist;
+ closestPoint = point;
+ closestSeries = setIdx;
+ closestRow = point.idx;
+ }
}
- idx -= this.layout_.datasets[i].length;
}
- return -1;
+ var name = this.layout_.setNames[closestSeries];
+ return {
+ row: closestRow,
+ seriesName: name,
+ point: closestPoint
+ };
};
/**
+ * Given canvas X,Y coordinates, find the touched area in a stacked graph.
+ *
+ * This first finds the X data point closest to the supplied DOM X coordinate,
+ * then finds the series which puts the Y coordinate on top of its filled area,
+ * using linear interpolation between adjacent point pairs.
+ *
+ * @param {Number} domX graph-relative DOM X coordinate
+ * @param {Number} domY graph-relative DOM Y coordinate
+ * Returns: {row, seriesName, point}
* @private
- * Generates HTML for the legend which is displayed when hovering over the
- * chart. If no selected points are specified, a default legend is returned
- * (this may just be the empty string).
- * @param { Number } [x] The x-value of the selected points.
- * @param { [Object] } [sel_points] List of selected points for the given
- * x-value. Should have properties like 'name', 'yval' and 'canvasy'.
- */
-Dygraph.prototype.generateLegendHTML_ = function(x, sel_points) {
- // If no points are selected, we display a default legend. Traditionally,
- // this has been blank. But a better default would be a conventional legend,
- // which provides essential information for a non-interactive chart.
- if (typeof(x) === 'undefined') {
- if (this.attr_('legend') != 'always') return '';
-
- var sepLines = this.attr_('labelsSeparateLines');
- var labels = this.attr_('labels');
- var html = '';
- for (var i = 1; i < labels.length; i++) {
- if (!this.visibility()[i - 1]) continue;
- var c = this.plotter_.colors[labels[i]];
- if (html != '') html += (sepLines ? '
' : ' ');
- html += "—" + labels[i] +
- "";
+ */
+Dygraph.prototype.findStackedPoint = function(domX, domY) {
+ var row = this.findClosestRow(domX);
+ var closestPoint, closestSeries;
+ for (var setIdx = 0; setIdx < this.layout_.points.length; ++setIdx) {
+ var boundary = this.getLeftBoundary_(setIdx);
+ var rowIdx = row - boundary;
+ var points = this.layout_.points[setIdx];
+ if (rowIdx >= points.length) continue;
+ var p1 = points[rowIdx];
+ if (!Dygraph.isValidPoint(p1)) continue;
+ var py = p1.canvasy;
+ if (domX > p1.canvasx && rowIdx + 1 < points.length) {
+ // interpolate series Y value using next point
+ var p2 = points[rowIdx + 1];
+ if (Dygraph.isValidPoint(p2)) {
+ var dx = p2.canvasx - p1.canvasx;
+ if (dx > 0) {
+ var r = (domX - p1.canvasx) / dx;
+ py += r * (p2.canvasy - p1.canvasy);
+ }
+ }
+ } else if (domX < p1.canvasx && rowIdx > 0) {
+ // interpolate series Y value using previous point
+ var p0 = points[rowIdx - 1];
+ if (Dygraph.isValidPoint(p0)) {
+ var dx = p1.canvasx - p0.canvasx;
+ if (dx > 0) {
+ var r = (p1.canvasx - domX) / dx;
+ py += r * (p0.canvasy - p1.canvasy);
+ }
+ }
+ }
+ // Stop if the point (domX, py) is above this series' upper edge
+ if (setIdx === 0 || py < domY) {
+ closestPoint = p1;
+ closestSeries = setIdx;
}
- return html;
}
+ var name = this.layout_.setNames[closestSeries];
+ return {
+ row: row,
+ seriesName: name,
+ point: closestPoint
+ };
+};
- var html = this.attr_('xValueFormatter')(x) + ":";
-
- var fmtFunc = this.attr_('yValueFormatter');
- var showZeros = this.attr_("labelsShowZeroValues");
- var sepLines = this.attr_("labelsSeparateLines");
- for (var i = 0; i < this.selPoints_.length; i++) {
- var pt = this.selPoints_[i];
- if (pt.yval == 0 && !showZeros) continue;
- if (!Dygraph.isOK(pt.canvasy)) continue;
- if (sepLines) html += "
";
+/**
+ * When the mouse moves in the canvas, display information about a nearby data
+ * point and draw dots over those points in the data series. This function
+ * takes care of cleanup of previously-drawn dots.
+ * @param {Object} event The mousemove event from the browser.
+ * @private
+ */
+Dygraph.prototype.mouseMove_ = function(event) {
+ // This prevents JS errors when mousing over the canvas before data loads.
+ var points = this.layout_.points;
+ if (points === undefined || points === null) return;
+
+ var canvasCoords = this.eventToDomCoords(event);
+ var canvasx = canvasCoords[0];
+ var canvasy = canvasCoords[1];
+
+ var highlightSeriesOpts = this.attr_("highlightSeriesOpts");
+ var selectionChanged = false;
+ if (highlightSeriesOpts && !this.isSeriesLocked()) {
+ var closest;
+ if (this.attr_("stackedGraph")) {
+ closest = this.findStackedPoint(canvasx, canvasy);
+ } else {
+ closest = this.findClosestPoint(canvasx, canvasy);
+ }
+ selectionChanged = this.setSelection(closest.row, closest.seriesName);
+ } else {
+ var idx = this.findClosestRow(canvasx);
+ selectionChanged = this.setSelection(idx);
+ }
- var c = this.plotter_.colors[pt.name];
- var yval = fmtFunc(pt.yval, this);
- // TODO(danvk): use a template string here and make it an attribute.
- html += " "
- + pt.name + ":"
- + yval;
+ var callback = this.attr_("highlightCallback");
+ if (callback && selectionChanged) {
+ callback(event,
+ this.lastx_,
+ this.selPoints_,
+ this.lastRow_,
+ this.highlightSet_);
}
- return html;
};
/**
+ * Fetch left offset from the specified set index or if not passed, the
+ * first defined boundaryIds record (see bug #236).
* @private
- * Displays information about the selected points in the legend. If there is no
- * selection, the legend will be cleared.
- * @param { Number } [x] The x-value of the selected points.
- * @param { [Object] } [sel_points] List of selected points for the given
- * x-value. Should have properties like 'name', 'yval' and 'canvasy'.
- */
-Dygraph.prototype.setLegendHTML_ = function(x, sel_points) {
- var html = this.generateLegendHTML_(x, sel_points);
- var labelsDiv = this.attr_("labelsDiv");
- if (labelsDiv !== null) {
- labelsDiv.innerHTML = html;
+ */
+Dygraph.prototype.getLeftBoundary_ = function(setIdx) {
+ if (this.boundaryIds_[setIdx]) {
+ return this.boundaryIds_[setIdx][0];
} else {
- if (typeof(this.shown_legend_error_) == 'undefined') {
- this.error('labelsDiv is set to something nonexistent; legend will not be shown.');
- this.shown_legend_error_ = true;
+ for (var i = 0; i < this.boundaryIds_.length; i++) {
+ if (this.boundaryIds_[i] !== undefined) {
+ return this.boundaryIds_[i][0];
+ }
}
+ return 0;
}
};
+Dygraph.prototype.animateSelection_ = function(direction) {
+ var totalSteps = 10;
+ var millis = 30;
+ if (this.fadeLevel === undefined) this.fadeLevel = 0;
+ if (this.animateId === undefined) this.animateId = 0;
+ var start = this.fadeLevel;
+ var steps = direction < 0 ? start : totalSteps - start;
+ if (steps <= 0) {
+ if (this.fadeLevel) {
+ this.updateSelection_(1.0);
+ }
+ return;
+ }
+
+ var thisId = ++this.animateId;
+ var that = this;
+ Dygraph.repeatAndCleanup(
+ function(n) {
+ // ignore simultaneous animations
+ if (that.animateId != thisId) return;
+
+ that.fadeLevel += direction;
+ if (that.fadeLevel === 0) {
+ that.clearSelection();
+ } else {
+ that.updateSelection_(that.fadeLevel / totalSteps);
+ }
+ },
+ steps, millis, function() {});
+};
+
/**
* Draw dots over the selectied points in the data series. This function
* takes care of cleanup of previously-drawn dots.
* @private
*/
-Dygraph.prototype.updateSelection_ = function() {
+Dygraph.prototype.updateSelection_ = function(opt_animFraction) {
+ /*var defaultPrevented = */
+ this.cascadeEvents_('select', {
+ selectedX: this.lastx_,
+ selectedPoints: this.selPoints_
+ });
+ // TODO(danvk): use defaultPrevented here?
+
// Clear the previously drawn vertical, if there is one
+ var i;
var ctx = this.canvas_ctx_;
- if (this.previousVerticalX_ >= 0) {
+ if (this.attr_('highlightSeriesOpts')) {
+ ctx.clearRect(0, 0, this.width_, this.height_);
+ var alpha = 1.0 - this.attr_('highlightSeriesBackgroundAlpha');
+ if (alpha) {
+ // Activating background fade includes an animation effect for a gradual
+ // fade. TODO(klausw): make this independently configurable if it causes
+ // issues? Use a shared preference to control animations?
+ var animateBackgroundFade = true;
+ if (animateBackgroundFade) {
+ if (opt_animFraction === undefined) {
+ // start a new animation
+ this.animateSelection_(1);
+ return;
+ }
+ alpha *= opt_animFraction;
+ }
+ ctx.fillStyle = 'rgba(255,255,255,' + alpha + ')';
+ ctx.fillRect(0, 0, this.width_, this.height_);
+ }
+
+ // Redraw only the highlighted series in the interactive canvas (not the
+ // static plot canvas, which is where series are usually drawn).
+ this.plotter_._renderLineChart(this.highlightSet_, ctx);
+ } else if (this.previousVerticalX_ >= 0) {
// Determine the maximum highlight circle size.
var maxCircleSize = 0;
var labels = this.attr_('labels');
- for (var i = 1; i < labels.length; i++) {
+ for (i = 1; i < labels.length; i++) {
var r = this.attr_('highlightCircleSize', labels[i]);
if (r > maxCircleSize) maxCircleSize = r;
}
@@ -1289,24 +1960,29 @@ Dygraph.prototype.updateSelection_ = function() {
2 * maxCircleSize + 2, this.height_);
}
- if (this.selPoints_.length > 0) {
- // Set the status message to indicate the selected point(s)
- if (this.attr_('showLabelsOnHighlight')) {
- this.setLegendHTML_(this.lastx_, this.selPoints_);
- }
+ if (this.isUsingExcanvas_ && this.currentZoomRectArgs_) {
+ Dygraph.prototype.drawZoomRect_.apply(this, this.currentZoomRectArgs_);
+ }
+ if (this.selPoints_.length > 0) {
// Draw colored circles over the center of each selected point
var canvasx = this.selPoints_[0].canvasx;
ctx.save();
- for (var i = 0; i < this.selPoints_.length; i++) {
+ for (i = 0; i < this.selPoints_.length; i++) {
var pt = this.selPoints_[i];
if (!Dygraph.isOK(pt.canvasy)) continue;
var circleSize = this.attr_('highlightCircleSize', pt.name);
- ctx.beginPath();
- ctx.fillStyle = this.plotter_.colors[pt.name];
- ctx.arc(canvasx, pt.canvasy, circleSize, 0, 2 * Math.PI, false);
- ctx.fill();
+ var callback = this.attr_("drawHighlightPointCallback", pt.name);
+ var color = this.plotter_.colors[pt.name];
+ if (!callback) {
+ callback = Dygraph.Circles.DEFAULT;
+ }
+ ctx.lineWidth = this.attr_('strokeWidth', pt.name);
+ ctx.strokeStyle = color;
+ ctx.fillStyle = color;
+ callback(this.g, pt.name, ctx, canvasx, pt.canvasy,
+ color, circleSize, pt.idx);
}
ctx.restore();
@@ -1320,38 +1996,52 @@ Dygraph.prototype.updateSelection_ = function() {
* using getSelection().
* @param { Integer } row number that should be highlighted (i.e. appear with
* hover dots on the chart). Set to false to clear any selection.
+ * @param { seriesName } optional series name to highlight that series with the
+ * the highlightSeriesOpts setting.
+ * @param { locked } optional If true, keep seriesName selected when mousing
+ * over the graph, disabling closest-series highlighting. Call clearSelection()
+ * to unlock it.
*/
-Dygraph.prototype.setSelection = function(row) {
+Dygraph.prototype.setSelection = function(row, opt_seriesName, opt_locked) {
// Extract the points we've selected
this.selPoints_ = [];
- var pos = 0;
-
- if (row !== false) {
- row = row-this.boundaryIds_[0][0];
- }
+ var changed = false;
if (row !== false && row >= 0) {
- for (var i in this.layout_.datasets) {
- if (row < this.layout_.datasets[i].length) {
- var point = this.layout_.points[pos+row];
-
- if (this.attr_("stackedGraph")) {
- point = this.layout_.unstackPointAtIndex(pos+row);
- }
-
- this.selPoints_.push(point);
+ if (row != this.lastRow_) changed = true;
+ this.lastRow_ = row;
+ for (var setIdx = 0; setIdx < this.layout_.points.length; ++setIdx) {
+ var points = this.layout_.points[setIdx];
+ var setRow = row - this.getLeftBoundary_(setIdx);
+ if (setRow < points.length) {
+ var point = points[setRow];
+ if (point.yval !== null) this.selPoints_.push(point);
}
- pos += this.layout_.datasets[i].length;
}
+ } else {
+ if (this.lastRow_ >= 0) changed = true;
+ this.lastRow_ = -1;
}
if (this.selPoints_.length) {
this.lastx_ = this.selPoints_[0].xval;
- this.updateSelection_();
} else {
- this.clearSelection();
+ this.lastx_ = -1;
}
+ if (opt_seriesName !== undefined) {
+ if (this.highlightSet_ !== opt_seriesName) changed = true;
+ this.highlightSet_ = opt_seriesName;
+ }
+
+ if (opt_locked !== undefined) {
+ this.lockedSet_ = opt_locked;
+ }
+
+ if (changed) {
+ this.updateSelection_(undefined);
+ }
+ return changed;
};
/**
@@ -1364,7 +2054,7 @@ Dygraph.prototype.mouseOut_ = function(event) {
this.attr_("unhighlightCallback")(event);
}
- if (this.attr_("hideOverlayOnMouseOut")) {
+ if (this.attr_("hideOverlayOnMouseOut") && !this.lockedSet_) {
this.clearSelection();
}
};
@@ -1374,12 +2064,21 @@ Dygraph.prototype.mouseOut_ = function(event) {
* the mouse over the chart).
*/
Dygraph.prototype.clearSelection = function() {
+ this.cascadeEvents_('deselect', {});
+
+ this.lockedSet_ = false;
// Get rid of the overlay data
+ if (this.fadeLevel) {
+ this.animateSelection_(-1);
+ return;
+ }
this.canvas_ctx_.clearRect(0, 0, this.width_, this.height_);
- this.setLegendHTML_();
+ this.fadeLevel = 0;
this.selPoints_ = [];
this.lastx_ = -1;
-}
+ this.lastRow_ = -1;
+ this.highlightSet_ = null;
+};
/**
* Returns the number of the currently selected row. To get data for this row,
@@ -1391,63 +2090,31 @@ Dygraph.prototype.getSelection = function() {
return -1;
}
- for (var row=0; row= Math.pow(10, maxNumberWidth) ||
- Math.abs(x) < Math.pow(10, -digits))) {
- return x.toExponential(digits);
- } else {
- return '' + Dygraph.round_(x, digits);
- }
+Dygraph.prototype.getHighlightSeries = function() {
+ return this.highlightSet_;
};
/**
- * Convert a JS date to a string appropriate to display on an axis that
- * is displaying values at the stated granularity.
- * @param {Date} date The date to format
- * @param {Number} granularity One of the Dygraph granularity constants
- * @return {String} The formatted date
- * @private
+ * Returns true if the currently-highlighted series was locked
+ * via setSelection(..., seriesName, true).
*/
-Dygraph.dateAxisFormatter = function(date, granularity) {
- if (granularity >= Dygraph.DECADAL) {
- return date.strftime('%Y');
- } else if (granularity >= Dygraph.MONTHLY) {
- return date.strftime('%b %y');
- } else {
- var frac = date.getHours() * 3600 + date.getMinutes() * 60 + date.getSeconds() + date.getMilliseconds();
- if (frac == 0 || granularity >= Dygraph.DAILY) {
- return new Date(date.getTime() + 3600*1000).strftime('%d%b');
- } else {
- return Dygraph.hmsString_(date.getTime());
- }
- }
+Dygraph.prototype.isSeriesLocked = function() {
+ return this.lockedSet_;
};
/**
@@ -1460,10 +2127,6 @@ Dygraph.prototype.loadedEvent_ = function(data) {
this.predraw_();
};
-Dygraph.prototype.months = ["Jan", "Feb", "Mar", "Apr", "May", "Jun",
- "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
-Dygraph.prototype.quarters = ["Jan", "Apr", "Jul", "Oct"];
-
/**
* Add ticks on the x-axis representing years, months, quarters, weeks, or days
* @private
@@ -1474,360 +2137,21 @@ Dygraph.prototype.addXTicks_ = function() {
if (this.dateWindow_) {
range = [this.dateWindow_[0], this.dateWindow_[1]];
} else {
- range = [this.rawData_[0][0], this.rawData_[this.rawData_.length - 1][0]];
- }
-
- var xTicks = this.attr_('xTicker')(range[0], range[1], this);
+ range = this.xAxisExtremes();
+ }
+
+ var xAxisOptionsView = this.optionsViewForAxis_('x');
+ var xTicks = xAxisOptionsView('ticker')(
+ range[0],
+ range[1],
+ this.width_, // TODO(danvk): should be area.width
+ xAxisOptionsView,
+ this);
+ // var msg = 'ticker(' + range[0] + ', ' + range[1] + ', ' + this.width_ + ', ' + this.attr_('pixelsPerXLabel') + ') -> ' + JSON.stringify(xTicks);
+ // console.log(msg);
this.layout_.setXTicks(xTicks);
};
-// Time granularity enumeration
-Dygraph.SECONDLY = 0;
-Dygraph.TWO_SECONDLY = 1;
-Dygraph.FIVE_SECONDLY = 2;
-Dygraph.TEN_SECONDLY = 3;
-Dygraph.THIRTY_SECONDLY = 4;
-Dygraph.MINUTELY = 5;
-Dygraph.TWO_MINUTELY = 6;
-Dygraph.FIVE_MINUTELY = 7;
-Dygraph.TEN_MINUTELY = 8;
-Dygraph.THIRTY_MINUTELY = 9;
-Dygraph.HOURLY = 10;
-Dygraph.TWO_HOURLY = 11;
-Dygraph.SIX_HOURLY = 12;
-Dygraph.DAILY = 13;
-Dygraph.WEEKLY = 14;
-Dygraph.MONTHLY = 15;
-Dygraph.QUARTERLY = 16;
-Dygraph.BIANNUAL = 17;
-Dygraph.ANNUAL = 18;
-Dygraph.DECADAL = 19;
-Dygraph.CENTENNIAL = 20;
-Dygraph.NUM_GRANULARITIES = 21;
-
-Dygraph.SHORT_SPACINGS = [];
-Dygraph.SHORT_SPACINGS[Dygraph.SECONDLY] = 1000 * 1;
-Dygraph.SHORT_SPACINGS[Dygraph.TWO_SECONDLY] = 1000 * 2;
-Dygraph.SHORT_SPACINGS[Dygraph.FIVE_SECONDLY] = 1000 * 5;
-Dygraph.SHORT_SPACINGS[Dygraph.TEN_SECONDLY] = 1000 * 10;
-Dygraph.SHORT_SPACINGS[Dygraph.THIRTY_SECONDLY] = 1000 * 30;
-Dygraph.SHORT_SPACINGS[Dygraph.MINUTELY] = 1000 * 60;
-Dygraph.SHORT_SPACINGS[Dygraph.TWO_MINUTELY] = 1000 * 60 * 2;
-Dygraph.SHORT_SPACINGS[Dygraph.FIVE_MINUTELY] = 1000 * 60 * 5;
-Dygraph.SHORT_SPACINGS[Dygraph.TEN_MINUTELY] = 1000 * 60 * 10;
-Dygraph.SHORT_SPACINGS[Dygraph.THIRTY_MINUTELY] = 1000 * 60 * 30;
-Dygraph.SHORT_SPACINGS[Dygraph.HOURLY] = 1000 * 3600;
-Dygraph.SHORT_SPACINGS[Dygraph.TWO_HOURLY] = 1000 * 3600 * 2;
-Dygraph.SHORT_SPACINGS[Dygraph.SIX_HOURLY] = 1000 * 3600 * 6;
-Dygraph.SHORT_SPACINGS[Dygraph.DAILY] = 1000 * 86400;
-Dygraph.SHORT_SPACINGS[Dygraph.WEEKLY] = 1000 * 604800;
-
-/**
- * @private
- * If we used this time granularity, how many ticks would there be?
- * This is only an approximation, but it's generally good enough.
- */
-Dygraph.prototype.NumXTicks = function(start_time, end_time, granularity) {
- if (granularity < Dygraph.MONTHLY) {
- // Generate one tick mark for every fixed interval of time.
- var spacing = Dygraph.SHORT_SPACINGS[granularity];
- return Math.floor(0.5 + 1.0 * (end_time - start_time) / spacing);
- } else {
- var year_mod = 1; // e.g. to only print one point every 10 years.
- var num_months = 12;
- if (granularity == Dygraph.QUARTERLY) num_months = 3;
- if (granularity == Dygraph.BIANNUAL) num_months = 2;
- if (granularity == Dygraph.ANNUAL) num_months = 1;
- if (granularity == Dygraph.DECADAL) { num_months = 1; year_mod = 10; }
- if (granularity == Dygraph.CENTENNIAL) { num_months = 1; year_mod = 100; }
-
- var msInYear = 365.2524 * 24 * 3600 * 1000;
- var num_years = 1.0 * (end_time - start_time) / msInYear;
- return Math.floor(0.5 + 1.0 * num_years * num_months / year_mod);
- }
-};
-
-/**
- * @private
- *
- * Construct an x-axis of nicely-formatted times on meaningful boundaries
- * (e.g. 'Jan 09' rather than 'Jan 22, 2009').
- *
- * Returns an array containing {v: millis, label: label} dictionaries.
- */
-Dygraph.prototype.GetXAxis = function(start_time, end_time, granularity) {
- var formatter = this.attr_("xAxisLabelFormatter");
- var ticks = [];
- if (granularity < Dygraph.MONTHLY) {
- // Generate one tick mark for every fixed interval of time.
- var spacing = Dygraph.SHORT_SPACINGS[granularity];
- var format = '%d%b'; // e.g. "1Jan"
-
- // Find a time less than start_time which occurs on a "nice" time boundary
- // for this granularity.
- var g = spacing / 1000;
- var d = new Date(start_time);
- if (g <= 60) { // seconds
- var x = d.getSeconds(); d.setSeconds(x - x % g);
- } else {
- d.setSeconds(0);
- g /= 60;
- if (g <= 60) { // minutes
- var x = d.getMinutes(); d.setMinutes(x - x % g);
- } else {
- d.setMinutes(0);
- g /= 60;
-
- if (g <= 24) { // days
- var x = d.getHours(); d.setHours(x - x % g);
- } else {
- d.setHours(0);
- g /= 24;
-
- if (g == 7) { // one week
- d.setDate(d.getDate() - d.getDay());
- }
- }
- }
- }
- start_time = d.getTime();
-
- for (var t = start_time; t <= end_time; t += spacing) {
- ticks.push({ v:t, label: formatter(new Date(t), granularity) });
- }
- } else {
- // Display a tick mark on the first of a set of months of each year.
- // Years get a tick mark iff y % year_mod == 0. This is useful for
- // displaying a tick mark once every 10 years, say, on long time scales.
- var months;
- var year_mod = 1; // e.g. to only print one point every 10 years.
-
- if (granularity == Dygraph.MONTHLY) {
- months = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 ];
- } else if (granularity == Dygraph.QUARTERLY) {
- months = [ 0, 3, 6, 9 ];
- } else if (granularity == Dygraph.BIANNUAL) {
- months = [ 0, 6 ];
- } else if (granularity == Dygraph.ANNUAL) {
- months = [ 0 ];
- } else if (granularity == Dygraph.DECADAL) {
- months = [ 0 ];
- year_mod = 10;
- } else if (granularity == Dygraph.CENTENNIAL) {
- months = [ 0 ];
- year_mod = 100;
- } else {
- this.warn("Span of dates is too long");
- }
-
- var start_year = new Date(start_time).getFullYear();
- var end_year = new Date(end_time).getFullYear();
- var zeropad = Dygraph.zeropad;
- for (var i = start_year; i <= end_year; i++) {
- if (i % year_mod != 0) continue;
- for (var j = 0; j < months.length; j++) {
- var date_str = i + "/" + zeropad(1 + months[j]) + "/01";
- var t = Dygraph.dateStrToMillis(date_str);
- if (t < start_time || t > end_time) continue;
- ticks.push({ v:t, label: formatter(new Date(t), granularity) });
- }
- }
- }
-
- return ticks;
-};
-
-
-/**
- * Add ticks to the x-axis based on a date range.
- * @param {Number} startDate Start of the date window (millis since epoch)
- * @param {Number} endDate End of the date window (millis since epoch)
- * @param {Dygraph} self The dygraph object
- * @return { [Object] } Array of {label, value} tuples.
- * @public
- */
-Dygraph.dateTicker = function(startDate, endDate, self) {
- // TODO(danvk): why does this take 'self' as a param?
- var chosen = -1;
- for (var i = 0; i < Dygraph.NUM_GRANULARITIES; i++) {
- var num_ticks = self.NumXTicks(startDate, endDate, i);
- if (self.width_ / num_ticks >= self.attr_('pixelsPerXLabel')) {
- chosen = i;
- break;
- }
- }
-
- if (chosen >= 0) {
- return self.GetXAxis(startDate, endDate, chosen);
- } else {
- // TODO(danvk): signal error.
- }
-};
-
-/**
- * @private
- * This is a list of human-friendly values at which to show tick marks on a log
- * scale. It is k * 10^n, where k=1..9 and n=-39..+39, so:
- * ..., 1, 2, 3, 4, 5, ..., 9, 10, 20, 30, ..., 90, 100, 200, 300, ...
- * NOTE: this assumes that Dygraph.LOG_SCALE = 10.
- */
-Dygraph.PREFERRED_LOG_TICK_VALUES = function() {
- var vals = [];
- for (var power = -39; power <= 39; power++) {
- var range = Math.pow(10, power);
- for (var mult = 1; mult <= 9; mult++) {
- var val = range * mult;
- vals.push(val);
- }
- }
- return vals;
-}();
-
-// TODO(konigsberg): Update comment.
-/**
- * Add ticks when the x axis has numbers on it (instead of dates)
- *
- * @param {Number} minV minimum value
- * @param {Number} maxV maximum value
- * @param self
- * @param {function} attribute accessor function.
- * @return {[Object]} Array of {label, value} tuples.
- */
-Dygraph.numericTicks = function(minV, maxV, self, axis_props, vals) {
- var attr = function(k) {
- if (axis_props && axis_props.hasOwnProperty(k)) return axis_props[k];
- return self.attr_(k);
- };
-
- var ticks = [];
- if (vals) {
- for (var i = 0; i < vals.length; i++) {
- ticks.push({v: vals[i]});
- }
- } else {
- if (axis_props && attr("logscale")) {
- var pixelsPerTick = attr('pixelsPerYLabel');
- // NOTE(konigsberg): Dan, should self.height_ be self.plotter_.area.h?
- var nTicks = Math.floor(self.height_ / pixelsPerTick);
- var minIdx = Dygraph.binarySearch(minV, Dygraph.PREFERRED_LOG_TICK_VALUES, 1);
- var maxIdx = Dygraph.binarySearch(maxV, Dygraph.PREFERRED_LOG_TICK_VALUES, -1);
- if (minIdx == -1) {
- minIdx = 0;
- }
- if (maxIdx == -1) {
- maxIdx = Dygraph.PREFERRED_LOG_TICK_VALUES.length - 1;
- }
- // Count the number of tick values would appear, if we can get at least
- // nTicks / 4 accept them.
- var lastDisplayed = null;
- if (maxIdx - minIdx >= nTicks / 4) {
- var axisId = axis_props.yAxisId;
- for (var idx = maxIdx; idx >= minIdx; idx--) {
- var tickValue = Dygraph.PREFERRED_LOG_TICK_VALUES[idx];
- var domCoord = axis_props.g.toDomYCoord(tickValue, axisId);
- var tick = { v: tickValue };
- if (lastDisplayed == null) {
- lastDisplayed = {
- tickValue : tickValue,
- domCoord : domCoord
- };
- } else {
- if (domCoord - lastDisplayed.domCoord >= pixelsPerTick) {
- lastDisplayed = {
- tickValue : tickValue,
- domCoord : domCoord
- };
- } else {
- tick.label = "";
- }
- }
- ticks.push(tick);
- }
- // Since we went in backwards order.
- ticks.reverse();
- }
- }
-
- // ticks.length won't be 0 if the log scale function finds values to insert.
- if (ticks.length == 0) {
- // Basic idea:
- // Try labels every 1, 2, 5, 10, 20, 50, 100, etc.
- // Calculate the resulting tick spacing (i.e. this.height_ / nTicks).
- // The first spacing greater than pixelsPerYLabel is what we use.
- // TODO(danvk): version that works on a log scale.
- if (attr("labelsKMG2")) {
- var mults = [1, 2, 4, 8];
- } else {
- var mults = [1, 2, 5];
- }
- var scale, low_val, high_val, nTicks;
- // TODO(danvk): make it possible to set this for x- and y-axes independently.
- var pixelsPerTick = attr('pixelsPerYLabel');
- for (var i = -10; i < 50; i++) {
- if (attr("labelsKMG2")) {
- var base_scale = Math.pow(16, i);
- } else {
- var base_scale = Math.pow(10, i);
- }
- for (var j = 0; j < mults.length; j++) {
- scale = base_scale * mults[j];
- low_val = Math.floor(minV / scale) * scale;
- high_val = Math.ceil(maxV / scale) * scale;
- nTicks = Math.abs(high_val - low_val) / scale;
- var spacing = self.height_ / nTicks;
- // wish I could break out of both loops at once...
- if (spacing > pixelsPerTick) break;
- }
- if (spacing > pixelsPerTick) break;
- }
-
- // Construct the set of ticks.
- // Allow reverse y-axis if it's explicitly requested.
- if (low_val > high_val) scale *= -1;
- for (var i = 0; i < nTicks; i++) {
- var tickV = low_val + i * scale;
- ticks.push( {v: tickV} );
- }
- }
- }
-
- // Add formatted labels to the ticks.
- var k;
- var k_labels = [];
- if (attr("labelsKMB")) {
- k = 1000;
- k_labels = [ "K", "M", "B", "T" ];
- }
- if (attr("labelsKMG2")) {
- if (k) self.warn("Setting both labelsKMB and labelsKMG2. Pick one!");
- k = 1024;
- k_labels = [ "k", "M", "G", "T" ];
- }
- var formatter = attr('yAxisLabelFormatter') ?
- attr('yAxisLabelFormatter') : attr('yValueFormatter');
-
- // Add labels to the ticks.
- for (var i = 0; i < ticks.length; i++) {
- if (ticks[i].label !== undefined) continue; // Use current label.
- var tickV = ticks[i].v;
- var absTickV = Math.abs(tickV);
- var label = formatter(tickV, self);
- if (k_labels.length > 0) {
- // Round up to an appropriate unit.
- var n = k*k*k*k;
- for (var j = 3; j >= 0; j--, n /= k) {
- if (absTickV >= n) {
- label = Dygraph.round_(tickV / n, attr('digitsAfterDecimal')) + k_labels[j];
- break;
- }
- }
- }
- ticks[i].label = label;
- }
-
- return ticks;
-};
-
/**
* @private
* Computes the range of the data series (including confidence intervals).
@@ -1836,33 +2160,33 @@ Dygraph.numericTicks = function(minV, maxV, self, axis_props, vals) {
* @return [low, high]
*/
Dygraph.prototype.extremeValues_ = function(series) {
- var minY = null, maxY = null;
+ var minY = null, maxY = null, j, y;
var bars = this.attr_("errorBars") || this.attr_("customBars");
if (bars) {
// With custom bars, maxY is the max of the high values.
- for (var j = 0; j < series.length; j++) {
- var y = series[j][1][0];
- if (!y) continue;
+ for (j = 0; j < series.length; j++) {
+ y = series[j][1][0];
+ if (y === null || isNaN(y)) continue;
var low = y - series[j][1][1];
var high = y + series[j][1][2];
if (low > y) low = y; // this can happen with custom bars,
if (high < y) high = y; // e.g. in tests/custom-bars.html
- if (maxY == null || high > maxY) {
+ if (maxY === null || high > maxY) {
maxY = high;
}
- if (minY == null || low < minY) {
+ if (minY === null || low < minY) {
minY = low;
}
}
} else {
- for (var j = 0; j < series.length; j++) {
- var y = series[j][1];
+ for (j = 0; j < series.length; j++) {
+ y = series[j][1];
if (y === null || isNaN(y)) continue;
- if (maxY == null || y > maxY) {
+ if (maxY === null || y > maxY) {
maxY = y;
}
- if (minY == null || y < minY) {
+ if (minY === null || y < minY) {
minY = y;
}
}
@@ -1880,11 +2204,27 @@ Dygraph.prototype.extremeValues_ = function(series) {
* number of axes, rolling averages, etc.
*/
Dygraph.prototype.predraw_ = function() {
+ var start = new Date();
+
+ this.layout_.computePlotArea();
+
// TODO(danvk): move more computations out of drawGraph_ and into here.
this.computeYAxes_();
// Create a new plotter.
- if (this.plotter_) this.plotter_.clear();
+ if (this.plotter_) {
+ this.cascadeEvents_('clearChart');
+ this.plotter_.clear();
+ }
+
+ if (!this.is_initial_draw_) {
+ this.canvas_ctx_.restore();
+ this.hidden_ctx_.restore();
+ }
+
+ this.canvas_ctx_.save();
+ this.hidden_ctx_.save();
+
this.plotter_ = new DygraphCanvasRenderer(this,
this.hidden_,
this.hidden_ctx_,
@@ -1894,93 +2234,242 @@ Dygraph.prototype.predraw_ = function() {
// this will be until the options are available, so it's positioned here.
this.createRollInterface_();
- // Same thing applies for the labelsDiv. It's right edge should be flush with
- // the right edge of the charting area (which may not be the same as the right
- // edge of the div, if we have two y-axes.
- this.positionLabelsDiv_();
+ this.cascadeEvents_('predraw');
+
+ // Convert the raw data (a 2D array) into the internal format and compute
+ // rolling averages.
+ this.rolledSeries_ = [null]; // x-axis is the first series and it's special
+ for (var i = 1; i < this.numColumns(); i++) {
+ // var logScale = this.attr_('logscale', i); // TODO(klausw): this looks wrong // konigsberg thinks so too.
+ var logScale = this.attr_('logscale');
+ var series = this.extractSeries_(this.rawData_, i, logScale);
+ series = this.rollingAverage(series, this.rollPeriod_);
+ this.rolledSeries_.push(series);
+ }
// If the data or options have changed, then we'd better redraw.
this.drawGraph_();
+
+ // This is used to determine whether to do various animations.
+ var end = new Date();
+ this.drawingTimeMs_ = (end - start);
};
/**
- * Update the graph with new data. This method is called when the viewing area
- * has changed. If the underlying data or options have changed, predraw_ will
- * be called before drawGraph_ is called.
+ * Point structure.
+ *
+ * xval_* and yval_* are the original unscaled data values,
+ * while x_* and y_* are scaled to the range (0.0-1.0) for plotting.
+ * yval_stacked is the cumulative Y value used for stacking graphs,
+ * and bottom/top/minus/plus are used for error bar graphs.
*
- * clearSelection, when undefined or true, causes this.clearSelection to be
- * called at the end of the draw operation. This should rarely be defined,
- * and never true (that is it should be undefined most of the time, and
- * rarely false.)
+ * @typedef {{
+ * idx: number,
+ * name: string,
+ * x: ?number,
+ * xval: ?number,
+ * y_bottom: ?number,
+ * y: ?number,
+ * y_stacked: ?number,
+ * y_top: ?number,
+ * yval_minus: ?number,
+ * yval: ?number,
+ * yval_plus: ?number,
+ * yval_stacked
+ * }}
+ */
+Dygraph.PointType = undefined;
+
+// TODO(bhs): these loops are a hot-spot for high-point-count charts. In fact,
+// on chrome+linux, they are 6 times more expensive than iterating through the
+// points and drawing the lines. The brunt of the cost comes from allocating
+// the |point| structures.
+/**
+ * Converts a series to a Point array.
*
* @private
- */
-Dygraph.prototype.drawGraph_ = function(clearSelection) {
- if (typeof(clearSelection) === 'undefined') {
- clearSelection = true;
+ * @param {Array.)>} series Array where
+ * series[row] = [x,y] or [x, [y, err]] or [x, [y, yplus, yminus]].
+ * @param {boolean} bars True if error bars or custom bars are being drawn.
+ * @param {string} setName Name of the series.
+ * @param {number} boundaryIdStart Index offset of the first point, equal to
+ * the number of skipped points left of the date window minimum (if any).
+ * @return {Array.} List of points for this series.
+ */
+Dygraph.seriesToPoints_ = function(series, bars, setName, boundaryIdStart) {
+ var points = [];
+ for (var i = 0; i < series.length; ++i) {
+ var item = series[i];
+ var yraw = bars ? item[1][0] : item[1];
+ var yval = yraw === null ? null : DygraphLayout.parseFloat_(yraw);
+ var point = {
+ x: NaN,
+ y: NaN,
+ xval: DygraphLayout.parseFloat_(item[0]),
+ yval: yval,
+ name: setName, // TODO(danvk): is this really necessary?
+ idx: i + boundaryIdStart
+ };
+
+ if (bars) {
+ point.y_top = NaN;
+ point.y_bottom = NaN;
+ point.yval_minus = DygraphLayout.parseFloat_(item[1][1]);
+ point.yval_plus = DygraphLayout.parseFloat_(item[1][2]);
+ }
+ points.push(point);
}
+ return points;
+};
- var data = this.rawData_;
- // This is used to set the second parameter to drawCallback, below.
- var is_initial_draw = this.is_initial_draw_;
- this.is_initial_draw_ = false;
+/**
+ * Calculates point stacking for stackedGraph=true.
+ *
+ * For stacking purposes, interpolate or extend neighboring data across
+ * NaN values based on stackedGraphNaNFill settings. This is for display
+ * only, the underlying data value as shown in the legend remains NaN.
+ *
+ * @param {Array.} points Point array for a single series.
+ * Updates each Point's yval_stacked property.
+ * @param {Array.} cumulativeYval Accumulated top-of-graph stacked Y
+ * values for the series seen so far. Index is the row number. Updated
+ * based on the current series's values.
+ * @param {Array.} seriesExtremes Min and max values, updated
+ * to reflect the stacked values.
+ * @param {string} fillMethod Interpolation method, one of 'all', 'inside', or
+ * 'none'.
+ * @private
+ */
+Dygraph.stackPoints_ = function(
+ points, cumulativeYval, seriesExtremes, fillMethod) {
+ var lastXval = null;
+ var prevPoint = null;
+ var nextPoint = null;
+ var nextPointIdx = -1;
+
+ // Find the next stackable point starting from the given index.
+ var updateNextPoint = function(idx) {
+ // If we've previously found a non-NaN point and haven't gone past it yet,
+ // just use that.
+ if (nextPointIdx >= idx) return;
+
+ // We haven't found a non-NaN point yet or have moved past it,
+ // look towards the right to find a non-NaN point.
+ for (var j = idx; j < points.length; ++j) {
+ // Clear out a previously-found point (if any) since it's no longer
+ // valid, we shouldn't use it for interpolation anymore.
+ nextPoint = null;
+ if (!isNaN(points[j].yval) && points[j].yval !== null) {
+ nextPointIdx = j;
+ nextPoint = points[j];
+ break;
+ }
+ }
+ };
- var minY = null, maxY = null;
- this.layout_.removeAllDatasets();
- this.setColors_();
- this.attrs_['pointSize'] = 0.5 * this.attr_('highlightCircleSize');
+ for (var i = 0; i < points.length; ++i) {
+ var point = points[i];
+ var xval = point.xval;
+ if (cumulativeYval[xval] === undefined) {
+ cumulativeYval[xval] = 0;
+ }
+
+ var actualYval = point.yval;
+ if (isNaN(actualYval) || actualYval === null) {
+ // Interpolate/extend for stacking purposes if possible.
+ updateNextPoint(i);
+ if (prevPoint && nextPoint && fillMethod != 'none') {
+ // Use linear interpolation between prevPoint and nextPoint.
+ actualYval = prevPoint.yval + (nextPoint.yval - prevPoint.yval) *
+ ((xval - prevPoint.xval) / (nextPoint.xval - prevPoint.xval));
+ } else if (prevPoint && fillMethod == 'all') {
+ actualYval = prevPoint.yval;
+ } else if (nextPoint && fillMethod == 'all') {
+ actualYval = nextPoint.yval;
+ } else {
+ actualYval = 0;
+ }
+ } else {
+ prevPoint = point;
+ }
- // Loop over the fields (series). Go from the last to the first,
- // because if they're stacked that's how we accumulate the values.
+ var stackedYval = cumulativeYval[xval];
+ if (lastXval != xval) {
+ // If an x-value is repeated, we ignore the duplicates.
+ stackedYval += actualYval;
+ cumulativeYval[xval] = stackedYval;
+ }
+ lastXval = xval;
- var cumulative_y = []; // For stacked series.
- var datasets = [];
+ point.yval_stacked = stackedYval;
- var extremes = {}; // series name -> [low, high]
+ if (stackedYval > seriesExtremes[1]) {
+ seriesExtremes[1] = stackedYval;
+ }
+ if (stackedYval < seriesExtremes[0]) {
+ seriesExtremes[0] = stackedYval;
+ }
+ }
+};
- // Loop over all fields and create datasets
- for (var i = data[0].length - 1; i >= 1; i--) {
- if (!this.visibility()[i - 1]) continue;
- var seriesName = this.attr_("labels")[i];
- var connectSeparatedPoints = this.attr_('connectSeparatedPoints', i);
- var logScale = this.attr_('logscale', i);
-
- var series = [];
- for (var j = 0; j < data.length; j++) {
- var date = data[j][0];
- var point = data[j][i];
- if (logScale) {
- // On the log scale, points less than zero do not exist.
- // This will create a gap in the chart. Note that this ignores
- // connectSeparatedPoints.
- if (point <= 0) {
- point = null;
- }
- series.push([date, point]);
- } else {
- if (point != null || !connectSeparatedPoints) {
- series.push([date, point]);
- }
- }
+/**
+ * Loop over all fields and create datasets, calculating extreme y-values for
+ * each series and extreme x-indices as we go.
+ *
+ * dateWindow is passed in as an explicit parameter so that we can compute
+ * extreme values "speculatively", i.e. without actually setting state on the
+ * dygraph.
+ *
+ * @param {Array.)>>} rolledSeries, where
+ * rolledSeries[seriesIndex][row] = raw point, where
+ * seriesIndex is the column number starting with 1, and
+ * rawPoint is [x,y] or [x, [y, err]] or [x, [y, yminus, yplus]].
+ * @param {?Array.} dateWindow [xmin, xmax] pair, or null.
+ * @return {{
+ * points: Array.>,
+ * seriesExtremes: Array.>,
+ * boundaryIds: Array.}}
+ * @private
+ */
+Dygraph.prototype.gatherDatasets_ = function(rolledSeries, dateWindow) {
+ var boundaryIds = [];
+ var points = [];
+ var cumulativeYval = []; // For stacked series.
+ var extremes = {}; // series name -> [low, high]
+ var i, k;
+ var errorBars = this.attr_("errorBars");
+ var customBars = this.attr_("customBars");
+ var bars = errorBars || customBars;
+ var isValueNull = function(sample) {
+ if (!bars) {
+ return sample[1] === null;
+ } else {
+ return customBars ? sample[1][1] === null :
+ errorBars ? sample[1][0] === null : false;
}
+ };
- // TODO(danvk): move this into predraw_. It's insane to do it here.
- series = this.rollingAverage(series, this.rollPeriod_);
+ // Loop over the fields (series). Go from the last to the first,
+ // because if they're stacked that's how we accumulate the values.
+ var num_series = rolledSeries.length - 1;
+ var series;
+ for (i = num_series; i >= 1; i--) {
+ if (!this.visibility()[i - 1]) continue;
// Prune down to the desired range, if necessary (for zooming)
// Because there can be lines going to points outside of the visible area,
// we actually prune to visible points, plus one on either side.
- var bars = this.attr_("errorBars") || this.attr_("customBars");
- if (this.dateWindow_) {
- var low = this.dateWindow_[0];
- var high= this.dateWindow_[1];
- var pruned = [];
+ if (dateWindow) {
+ series = rolledSeries[i];
+ var low = dateWindow[0];
+ var high = dateWindow[1];
+
// TODO(danvk): do binary search instead of linear search.
// TODO(danvk): pass firstIdx and lastIdx directly to the renderer.
var firstIdx = null, lastIdx = null;
- for (var k = 0; k < series.length; k++) {
+ for (k = 0; k < series.length; k++) {
if (series[k][0] >= low && firstIdx === null) {
firstIdx = k;
}
@@ -1988,58 +2477,92 @@ Dygraph.prototype.drawGraph_ = function(clearSelection) {
lastIdx = k;
}
}
+
if (firstIdx === null) firstIdx = 0;
- if (firstIdx > 0) firstIdx--;
+ var correctedFirstIdx = firstIdx;
+ var isInvalidValue = true;
+ while (isInvalidValue && correctedFirstIdx > 0) {
+ correctedFirstIdx--;
+ isInvalidValue = isValueNull(series[correctedFirstIdx]);
+ }
+
if (lastIdx === null) lastIdx = series.length - 1;
- if (lastIdx < series.length - 1) lastIdx++;
- this.boundaryIds_[i-1] = [firstIdx, lastIdx];
- for (var k = firstIdx; k <= lastIdx; k++) {
- pruned.push(series[k]);
+ var correctedLastIdx = lastIdx;
+ isInvalidValue = true;
+ while (isInvalidValue && correctedLastIdx < series.length - 1) {
+ correctedLastIdx++;
+ isInvalidValue = isValueNull(series[correctedLastIdx]);
+ }
+
+
+ if (correctedFirstIdx!==firstIdx) {
+ firstIdx = correctedFirstIdx;
}
- series = pruned;
+ if (correctedLastIdx !== lastIdx) {
+ lastIdx = correctedLastIdx;
+ }
+
+ boundaryIds[i-1] = [firstIdx, lastIdx];
+
+ // .slice's end is exclusive, we want to include lastIdx.
+ series = series.slice(firstIdx, lastIdx + 1);
} else {
- this.boundaryIds_[i-1] = [0, series.length-1];
+ series = rolledSeries[i];
+ boundaryIds[i-1] = [0, series.length-1];
}
+ var seriesName = this.attr_("labels")[i];
var seriesExtremes = this.extremeValues_(series);
- if (bars) {
- for (var j=0; j seriesExtremes[1]) {
- seriesExtremes[1] = cumulative_y[x];
- }
- if (cumulative_y[x] < seriesExtremes[0]) {
- seriesExtremes[0] = cumulative_y[x];
- }
- }
+ if (this.attr_("stackedGraph")) {
+ Dygraph.stackPoints_(seriesPoints, cumulativeYval, seriesExtremes,
+ this.attr_("stackedGraphNaNFill"));
}
- extremes[seriesName] = seriesExtremes;
- datasets[i] = series;
+ extremes[seriesName] = seriesExtremes;
+ points[i] = seriesPoints;
}
- for (var i = 1; i < datasets.length; i++) {
+ return { points: points, extremes: extremes, boundaryIds: boundaryIds };
+};
+
+/**
+ * Update the graph with new data. This method is called when the viewing area
+ * has changed. If the underlying data or options have changed, predraw_ will
+ * be called before drawGraph_ is called.
+ *
+ * @private
+ */
+Dygraph.prototype.drawGraph_ = function() {
+ var start = new Date();
+
+ // This is used to set the second parameter to drawCallback, below.
+ var is_initial_draw = this.is_initial_draw_;
+ this.is_initial_draw_ = false;
+
+ this.layout_.removeAllDatasets();
+ this.setColors_();
+ this.attrs_.pointSize = 0.5 * this.attr_('highlightCircleSize');
+
+ var packed = this.gatherDatasets_(this.rolledSeries_, this.dateWindow_);
+ var points = packed.points;
+ var extremes = packed.extremes;
+ this.boundaryIds_ = packed.boundaryIds;
+
+ this.setIndexByName_ = {};
+ var labels = this.attr_("labels");
+ if (labels.length > 0) {
+ this.setIndexByName_[labels[0]] = 0;
+ }
+ var dataIdx = 0;
+ for (var i = 1; i < points.length; i++) {
+ this.setIndexByName_[labels[i]] = i;
if (!this.visibility()[i - 1]) continue;
- this.layout_.addDataset(this.attr_("labels")[i], datasets[i]);
+ this.layout_.addDataset(labels[i], points[i]);
+ this.datasetIndex_[i] = dataIdx++;
}
this.computeYAxisRanges_(extremes);
@@ -2050,33 +2573,57 @@ Dygraph.prototype.drawGraph_ = function(clearSelection) {
// Save the X axis zoomed status as the updateOptions call will tend to set it erroneously
var tmp_zoomed_x = this.zoomed_x_;
// Tell PlotKit to use this new data and render itself
- this.layout_.setDateWindow(this.dateWindow_);
this.zoomed_x_ = tmp_zoomed_x;
- this.layout_.evaluateWithError();
+ this.layout_.evaluate();
+ this.renderGraph_(is_initial_draw);
+
+ if (this.attr_("timingName")) {
+ var end = new Date();
+ Dygraph.info(this.attr_("timingName") + " - drawGraph: " + (end - start) + "ms");
+ }
+};
+
+/**
+ * This does the work of drawing the chart. It assumes that the layout and axis
+ * scales have already been set (e.g. by predraw_).
+ *
+ * @private
+ */
+Dygraph.prototype.renderGraph_ = function(is_initial_draw) {
+ this.cascadeEvents_('clearChart');
this.plotter_.clear();
+
+ if (this.attr_('underlayCallback')) {
+ // NOTE: we pass the dygraph object to this callback twice to avoid breaking
+ // users who expect a deprecated form of this callback.
+ this.attr_('underlayCallback')(
+ this.hidden_ctx_, this.layout_.getPlotArea(), this, this);
+ }
+
+ var e = {
+ canvas: this.hidden_,
+ drawingContext: this.hidden_ctx_
+ };
+ this.cascadeEvents_('willDrawChart', e);
this.plotter_.render();
+ this.cascadeEvents_('didDrawChart', e);
+ this.lastRow_ = -1; // because plugins/legend.js clears the legend
+
+ // TODO(danvk): is this a performance bottleneck when panning?
+ // The interaction canvas should already be empty in that situation.
this.canvas_.getContext('2d').clearRect(0, 0, this.canvas_.width,
this.canvas_.height);
- if (is_initial_draw) {
- // Generate a static legend before any particular point is selected.
- this.setLegendHTML_();
- } else {
- if (clearSelection) {
- if (typeof(this.selPoints_) !== 'undefined' && this.selPoints_.length) {
- // We should select the point nearest the page x/y here, but it's easier
- // to just clear the selection. This prevents erroneous hover dots from
- // being displayed.
- this.clearSelection();
- } else {
- this.clearSelection();
- }
- }
- }
-
if (this.attr_("drawCallback") !== null) {
this.attr_("drawCallback")(this, is_initial_draw);
}
+ if (is_initial_draw) {
+ this.readyFired_ = true;
+ while (this.readyFns_.length > 0) {
+ var fn = this.readyFns_.pop();
+ fn(this);
+ }
+ }
};
/**
@@ -2085,106 +2632,66 @@ Dygraph.prototype.drawGraph_ = function(clearSelection) {
* currently being displayed. This includes things like the number of axes and
* the style of the axes. It does not include the range of each axis and its
* tick marks.
- * This fills in this.axes_ and this.seriesToAxisMap_.
+ * This fills in this.axes_.
* axes_ = [ { options } ]
- * seriesToAxisMap_ = { seriesName: 0, seriesName2: 1, ... }
* indices are into the axes_ array.
*/
Dygraph.prototype.computeYAxes_ = function() {
// Preserve valueWindow settings if they exist, and if the user hasn't
// specified a new valueRange.
- var valueWindows;
- if (this.axes_ != undefined && this.user_attrs_.hasOwnProperty("valueRange") == false) {
+ var valueWindows, axis, index, opts, v;
+ if (this.axes_ !== undefined && this.user_attrs_.hasOwnProperty("valueRange") === false) {
valueWindows = [];
- for (var index = 0; index < this.axes_.length; index++) {
+ for (index = 0; index < this.axes_.length; index++) {
valueWindows.push(this.axes_[index].valueWindow);
}
}
+ // this.axes_ doesn't match this.attributes_.axes_.options. It's used for
+ // data computation as well as options storage.
+ // Go through once and add all the axes.
+ this.axes_ = [];
- this.axes_ = [{ yAxisId : 0, g : this }]; // always have at least one y-axis.
- this.seriesToAxisMap_ = {};
-
- // Get a list of series names.
- var labels = this.attr_("labels");
- var series = {};
- for (var i = 1; i < labels.length; i++) series[labels[i]] = (i - 1);
-
- // all options which could be applied per-axis:
- var axisOptions = [
- 'includeZero',
- 'valueRange',
- 'labelsKMB',
- 'labelsKMG2',
- 'pixelsPerYLabel',
- 'yAxisLabelWidth',
- 'axisLabelFontSize',
- 'axisTickSize',
- 'logscale'
- ];
-
- // Copy global axis options over to the first axis.
- for (var i = 0; i < axisOptions.length; i++) {
- var k = axisOptions[i];
- var v = this.attr_(k);
- if (v) this.axes_[0][k] = v;
+ for (axis = 0; axis < this.attributes_.numAxes(); axis++) {
+ // Add a new axis, making a copy of its per-axis options.
+ opts = { g : this };
+ Dygraph.update(opts, this.attributes_.axisOptions(axis));
+ this.axes_[axis] = opts;
}
- // Go through once and add all the axes.
- for (var seriesName in series) {
- if (!series.hasOwnProperty(seriesName)) continue;
- var axis = this.attr_("axis", seriesName);
- if (axis == null) {
- this.seriesToAxisMap_[seriesName] = 0;
- continue;
- }
- if (typeof(axis) == 'object') {
- // Add a new axis, making a copy of its per-axis options.
- var opts = {};
- Dygraph.update(opts, this.axes_[0]);
- Dygraph.update(opts, { valueRange: null }); // shouldn't inherit this.
- var yAxisId = this.axes_.length;
- opts.yAxisId = yAxisId;
- opts.g = this;
- Dygraph.update(opts, axis);
- this.axes_.push(opts);
- this.seriesToAxisMap_[seriesName] = yAxisId;
- }
- }
-
- // Go through one more time and assign series to an axis defined by another
- // series, e.g. { 'Y1: { axis: {} }, 'Y2': { axis: 'Y1' } }
- for (var seriesName in series) {
- if (!series.hasOwnProperty(seriesName)) continue;
- var axis = this.attr_("axis", seriesName);
- if (typeof(axis) == 'string') {
- if (!this.seriesToAxisMap_.hasOwnProperty(axis)) {
- this.error("Series " + seriesName + " wants to share a y-axis with " +
- "series " + axis + ", which does not define its own axis.");
- return null;
- }
- var idx = this.seriesToAxisMap_[axis];
- this.seriesToAxisMap_[seriesName] = idx;
- }
- }
- // Now we remove series from seriesToAxisMap_ which are not visible. We do
- // this last so that hiding the first series doesn't destroy the axis
- // properties of the primary axis.
- var seriesToAxisFiltered = {};
- var vis = this.visibility();
- for (var i = 1; i < labels.length; i++) {
- var s = labels[i];
- if (vis[i - 1]) seriesToAxisFiltered[s] = this.seriesToAxisMap_[s];
- }
- this.seriesToAxisMap_ = seriesToAxisFiltered;
+ // Copy global valueRange option over to the first axis.
+ // NOTE(konigsberg): Are these two statements necessary?
+ // I tried removing it. The automated tests pass, and manually
+ // messing with tests/zoom.html showed no trouble.
+ v = this.attr_('valueRange');
+ if (v) this.axes_[0].valueRange = v;
- if (valueWindows != undefined) {
+ if (valueWindows !== undefined) {
// Restore valueWindow settings.
- for (var index = 0; index < valueWindows.length; index++) {
+
+ // When going from two axes back to one, we only restore
+ // one axis.
+ var idxCount = Math.min(valueWindows.length, this.axes_.length);
+
+ for (index = 0; index < idxCount; index++) {
this.axes_[index].valueWindow = valueWindows[index];
}
}
+
+ for (axis = 0; axis < this.axes_.length; axis++) {
+ if (axis === 0) {
+ opts = this.optionsViewForAxis_('y' + (axis ? '2' : ''));
+ v = opts("valueRange");
+ if (v) this.axes_[axis].valueRange = v;
+ } else { // To keep old behavior
+ var axes = this.user_attrs_.axes;
+ if (axes && axes.y2) {
+ v = axes.y2.valueRange;
+ if (v) this.axes_[axis].valueRange = v;
+ }
+ }
+ }
};
/**
@@ -2192,13 +2699,7 @@ Dygraph.prototype.computeYAxes_ = function() {
* @return {Number} the number of axes.
*/
Dygraph.prototype.numAxes = function() {
- var last_axis = 0;
- for (var series in this.seriesToAxisMap_) {
- if (!this.seriesToAxisMap_.hasOwnProperty(series)) continue;
- var idx = this.seriesToAxisMap_[series];
- if (idx > last_axis) last_axis = idx;
- }
- return 1 + last_axis;
+ return this.attributes_.numAxes();
};
/**
@@ -2210,7 +2711,7 @@ Dygraph.prototype.numAxes = function() {
*/
Dygraph.prototype.axisPropertiesForSeries = function(series) {
// TODO(danvk): handle errors.
- return this.axes_[this.seriesToAxisMap_[series]];
+ return this.axes_[this.attributes_.axisForSeries(series)];
};
/**
@@ -2220,69 +2721,110 @@ Dygraph.prototype.axisPropertiesForSeries = function(series) {
* This fills in the valueRange and ticks fields in each entry of this.axes_.
*/
Dygraph.prototype.computeYAxisRanges_ = function(extremes) {
- // Build a map from axis number -> [list of series names]
- var seriesForAxis = [];
- for (var series in this.seriesToAxisMap_) {
- if (!this.seriesToAxisMap_.hasOwnProperty(series)) continue;
- var idx = this.seriesToAxisMap_[series];
- while (seriesForAxis.length <= idx) seriesForAxis.push([]);
- seriesForAxis[idx].push(series);
- }
+ var isNullUndefinedOrNaN = function(num) {
+ return isNaN(parseFloat(num));
+ };
+ var numAxes = this.attributes_.numAxes();
+ var ypadCompat, span, series, ypad;
+
+ var p_axis;
// Compute extreme values, a span and tick marks for each axis.
- for (var i = 0; i < this.axes_.length; i++) {
+ for (var i = 0; i < numAxes; i++) {
var axis = this.axes_[i];
+ var logscale = this.attributes_.getForAxis("logscale", i);
+ var includeZero = this.attributes_.getForAxis("includeZero", i);
+ var independentTicks = this.attributes_.getForAxis("independentTicks", i);
+ series = this.attributes_.seriesForAxis(i);
- if (!seriesForAxis[i]) {
+ // Add some padding. This supports two Y padding operation modes:
+ //
+ // - backwards compatible (yRangePad not set):
+ // 10% padding for automatic Y ranges, but not for user-supplied
+ // ranges, and move a close-to-zero edge to zero except if
+ // avoidMinZero is set, since drawing at the edge results in
+ // invisible lines. Unfortunately lines drawn at the edge of a
+ // user-supplied range will still be invisible. If logscale is
+ // set, add a variable amount of padding at the top but
+ // none at the bottom.
+ //
+ // - new-style (yRangePad set by the user):
+ // always add the specified Y padding.
+ //
+ ypadCompat = true;
+ ypad = 0.1; // add 10%
+ if (this.attr_('yRangePad') !== null) {
+ ypadCompat = false;
+ // Convert pixel padding to ratio
+ ypad = this.attr_('yRangePad') / this.plotter_.area.h;
+ }
+
+ if (series.length === 0) {
// If no series are defined or visible then use a reasonable default
axis.extremeRange = [0, 1];
} else {
// Calculate the extremes of extremes.
- var series = seriesForAxis[i];
var minY = Infinity; // extremes[series[0]][0];
var maxY = -Infinity; // extremes[series[0]][1];
var extremeMinY, extremeMaxY;
+
for (var j = 0; j < series.length; j++) {
+ // this skips invisible series
+ if (!extremes.hasOwnProperty(series[j])) continue;
+
// Only use valid extremes to stop null data series' from corrupting the scale.
extremeMinY = extremes[series[j]][0];
- if (extremeMinY != null) {
+ if (extremeMinY !== null) {
minY = Math.min(extremeMinY, minY);
}
extremeMaxY = extremes[series[j]][1];
- if (extremeMaxY != null) {
+ if (extremeMaxY !== null) {
maxY = Math.max(extremeMaxY, maxY);
}
}
- if (axis.includeZero && minY > 0) minY = 0;
- // Ensure we have a valid scale, otherwise defualt to zero for safety.
+ // Include zero if requested by the user.
+ if (includeZero && !logscale) {
+ if (minY > 0) minY = 0;
+ if (maxY < 0) maxY = 0;
+ }
+
+ // Ensure we have a valid scale, otherwise default to [0, 1] for safety.
if (minY == Infinity) minY = 0;
- if (maxY == -Infinity) maxY = 0;
-
- // Add some padding and round up to an integer to be human-friendly.
- var span = maxY - minY;
- // special case: if we have no sense of scale, use +/-10% of the sole value.
- if (span == 0) { span = maxY; }
-
- var maxAxisY;
- var minAxisY;
- if (axis.logscale) {
- var maxAxisY = maxY + 0.1 * span;
- var minAxisY = minY;
+ if (maxY == -Infinity) maxY = 1;
+
+ span = maxY - minY;
+ // special case: if we have no sense of scale, center on the sole value.
+ if (span === 0) {
+ if (maxY !== 0) {
+ span = Math.abs(maxY);
+ } else {
+ // ... and if the sole value is zero, use range 0-1.
+ maxY = 1;
+ span = 1;
+ }
+ }
+
+ var maxAxisY, minAxisY;
+ if (logscale) {
+ if (ypadCompat) {
+ maxAxisY = maxY + ypad * span;
+ minAxisY = minY;
+ } else {
+ var logpad = Math.exp(Math.log(span) * ypad);
+ maxAxisY = maxY * logpad;
+ minAxisY = minY / logpad;
+ }
} else {
- var maxAxisY = maxY + 0.1 * span;
- var minAxisY = minY - 0.1 * span;
+ maxAxisY = maxY + ypad * span;
+ minAxisY = minY - ypad * span;
- // Try to include zero and make it minAxisY (or maxAxisY) if it makes sense.
- if (!this.attr_("avoidMinZero")) {
+ // Backwards-compatible behavior: Move the span to start or end at zero if it's
+ // close to zero, but not if avoidMinZero is set.
+ if (ypadCompat && !this.attr_("avoidMinZero")) {
if (minAxisY < 0 && minY >= 0) minAxisY = 0;
if (maxAxisY > 0 && maxY <= 0) maxAxisY = 0;
}
-
- if (this.attr_("includeZero")) {
- if (maxY < 0) maxAxisY = 0;
- if (minY > 0) minAxisY = 0;
- }
}
axis.extremeRange = [minAxisY, maxAxisY];
}
@@ -2293,22 +2835,50 @@ Dygraph.prototype.computeYAxisRanges_ = function(extremes) {
axis.computedValueRange = [axis.valueWindow[0], axis.valueWindow[1]];
} else if (axis.valueRange) {
// This is a user-set value range for this axis.
- axis.computedValueRange = [axis.valueRange[0], axis.valueRange[1]];
+ var y0 = isNullUndefinedOrNaN(axis.valueRange[0]) ? axis.extremeRange[0] : axis.valueRange[0];
+ var y1 = isNullUndefinedOrNaN(axis.valueRange[1]) ? axis.extremeRange[1] : axis.valueRange[1];
+ if (!ypadCompat) {
+ if (axis.logscale) {
+ var logpad = Math.exp(Math.log(span) * ypad);
+ y0 *= logpad;
+ y1 /= logpad;
+ } else {
+ span = y1 - y0;
+ y0 -= span * ypad;
+ y1 += span * ypad;
+ }
+ }
+ axis.computedValueRange = [y0, y1];
} else {
axis.computedValueRange = axis.extremeRange;
}
-
- // Add ticks. By default, all axes inherit the tick positions of the
- // primary axis. However, if an axis is specifically marked as having
- // independent ticks, then that is permissible as well.
- if (i == 0 || axis.independentTicks) {
- axis.ticks =
- Dygraph.numericTicks(axis.computedValueRange[0],
- axis.computedValueRange[1],
- this,
- axis);
- } else {
- var p_axis = this.axes_[0];
+
+
+ if (independentTicks) {
+ axis.independentTicks = independentTicks;
+ var opts = this.optionsViewForAxis_('y' + (i ? '2' : ''));
+ var ticker = opts('ticker');
+ axis.ticks = ticker(axis.computedValueRange[0],
+ axis.computedValueRange[1],
+ this.height_, // TODO(danvk): should be area.height
+ opts,
+ this);
+ // Define the first independent axis as primary axis.
+ if (!p_axis) p_axis = axis;
+ }
+ }
+ if (p_axis === undefined) {
+ throw ("Configuration Error: At least one axis has to have the \"independentTicks\" option activated.");
+ }
+ // Add ticks. By default, all axes inherit the tick positions of the
+ // primary axis. However, if an axis is specifically marked as having
+ // independent ticks, then that is permissible as well.
+ for (var i = 0; i < numAxes; i++) {
+ var axis = this.axes_[i];
+
+ if (!axis.independentTicks) {
+ var opts = this.optionsViewForAxis_('y' + (i ? '2' : ''));
+ var ticker = opts('ticker');
var p_ticks = p_axis.ticks;
var p_scale = p_axis.computedValueRange[1] - p_axis.computedValueRange[0];
var scale = axis.computedValueRange[1] - axis.computedValueRange[0];
@@ -2319,12 +2889,64 @@ Dygraph.prototype.computeYAxisRanges_ = function(extremes) {
tick_values.push(y_val);
}
- axis.ticks =
- Dygraph.numericTicks(axis.computedValueRange[0],
- axis.computedValueRange[1],
- this, axis, tick_values);
+ axis.ticks = ticker(axis.computedValueRange[0],
+ axis.computedValueRange[1],
+ this.height_, // TODO(danvk): should be area.height
+ opts,
+ this,
+ tick_values);
+ }
+ }
+};
+
+/**
+ * Extracts one series from the raw data (a 2D array) into an array of (date,
+ * value) tuples.
+ *
+ * This is where undesirable points (i.e. negative values on log scales and
+ * missing values through which we wish to connect lines) are dropped.
+ * TODO(danvk): the "missing values" bit above doesn't seem right.
+ *
+ * @private
+ * @param {Array.)>>} rawData Input data. Rectangular
+ * grid of points, where rawData[row][0] is the X value for the row,
+ * and rawData[row][i] is the Y data for series #i.
+ * @param {number} i Series index, starting from 1.
+ * @param {boolean} logScale True if using logarithmic Y scale.
+ * @return {Array.)>} Series array, where
+ * series[row] = [x,y] or [x, [y, err]] or [x, [y, yplus, yminus]].
+ */
+Dygraph.prototype.extractSeries_ = function(rawData, i, logScale) {
+ // TODO(danvk): pre-allocate series here.
+ var series = [];
+ var errorBars = this.attr_("errorBars");
+ var customBars = this.attr_("customBars");
+ for (var j = 0; j < rawData.length; j++) {
+ var x = rawData[j][0];
+ var point = rawData[j][i];
+ if (logScale) {
+ // On the log scale, points less than zero do not exist.
+ // This will create a gap in the chart.
+ if (errorBars || customBars) {
+ // point.length is either 2 (errorBars) or 3 (customBars)
+ for (var k = 0; k < point.length; k++) {
+ if (point[k] <= 0) {
+ point = null;
+ break;
+ }
+ }
+ } else if (point <= 0) {
+ point = null;
+ }
+ }
+ // Fix null points to fit the display type standard.
+ if (point !== null) {
+ series.push([x, point]);
+ } else {
+ series.push([x, errorBars ? [null, null] : customBars ? [null, null, null] : point]);
}
}
+ return series;
};
/**
@@ -2341,17 +2963,16 @@ Dygraph.prototype.computeYAxisRanges_ = function(extremes) {
* data
*/
Dygraph.prototype.rollingAverage = function(originalData, rollPeriod) {
- if (originalData.length < 2)
- return originalData;
- var rollPeriod = Math.min(rollPeriod, originalData.length - 1);
+ rollPeriod = Math.min(rollPeriod, originalData.length);
var rollingData = [];
var sigma = this.attr_("sigma");
+ var low, high, i, j, y, sum, num_ok, stddev;
if (this.fractions_) {
var num = 0;
var den = 0; // numerator/denominator
var mult = 100.0;
- for (var i = 0; i < originalData.length; i++) {
+ for (i = 0; i < originalData.length; i++) {
num += originalData[i][1][0];
den += originalData[i][1][1];
if (i - rollPeriod >= 0) {
@@ -2362,22 +2983,22 @@ Dygraph.prototype.rollingAverage = function(originalData, rollPeriod) {
var date = originalData[i][0];
var value = den ? num / den : 0.0;
if (this.attr_("errorBars")) {
- if (this.wilsonInterval_) {
+ if (this.attr_("wilsonInterval")) {
// For more details on this confidence interval, see:
// http://en.wikipedia.org/wiki/Binomial_confidence_interval
if (den) {
var p = value < 0 ? 0 : value, n = den;
var pm = sigma * Math.sqrt(p*(1-p)/n + sigma*sigma/(4*n*n));
var denom = 1 + sigma * sigma / den;
- var low = (p + sigma * sigma / (2 * den) - pm) / denom;
- var high = (p + sigma * sigma / (2 * den) + pm) / denom;
+ low = (p + sigma * sigma / (2 * den) - pm) / denom;
+ high = (p + sigma * sigma / (2 * den) + pm) / denom;
rollingData[i] = [date,
[p * mult, (p - low) * mult, (high - p) * mult]];
} else {
rollingData[i] = [date, [0, 0, 0]];
}
} else {
- var stddev = den ? sigma * Math.sqrt(value * (1 - value) / den) : 1.0;
+ stddev = den ? sigma * Math.sqrt(value * (1 - value) / den) : 1.0;
rollingData[i] = [date, [mult * value, mult * stddev, mult * stddev]];
}
} else {
@@ -2385,16 +3006,16 @@ Dygraph.prototype.rollingAverage = function(originalData, rollPeriod) {
}
}
} else if (this.attr_("customBars")) {
- var low = 0;
+ low = 0;
var mid = 0;
- var high = 0;
+ high = 0;
var count = 0;
- for (var i = 0; i < originalData.length; i++) {
+ for (i = 0; i < originalData.length; i++) {
var data = originalData[i][1];
- var y = data[1];
+ y = data[1];
rollingData[i] = [originalData[i][0], [y, y - data[0], data[2] - y]];
- if (y != null && !isNaN(y)) {
+ if (y !== null && !isNaN(y)) {
low += data[0];
mid += y;
high += data[2];
@@ -2402,32 +3023,35 @@ Dygraph.prototype.rollingAverage = function(originalData, rollPeriod) {
}
if (i - rollPeriod >= 0) {
var prev = originalData[i - rollPeriod];
- if (prev[1][1] != null && !isNaN(prev[1][1])) {
+ if (prev[1][1] !== null && !isNaN(prev[1][1])) {
low -= prev[1][0];
mid -= prev[1][1];
high -= prev[1][2];
count -= 1;
}
}
- rollingData[i] = [originalData[i][0], [ 1.0 * mid / count,
- 1.0 * (mid - low) / count,
- 1.0 * (high - mid) / count ]];
+ if (count) {
+ rollingData[i] = [originalData[i][0], [ 1.0 * mid / count,
+ 1.0 * (mid - low) / count,
+ 1.0 * (high - mid) / count ]];
+ } else {
+ rollingData[i] = [originalData[i][0], [null, null, null]];
+ }
}
} else {
// Calculate the rolling average for the first rollPeriod - 1 points where
// there is not enough data to roll over the full number of points
- var num_init_points = Math.min(rollPeriod - 1, originalData.length - 2);
- if (!this.attr_("errorBars")){
+ if (!this.attr_("errorBars")) {
if (rollPeriod == 1) {
return originalData;
}
- for (var i = 0; i < originalData.length; i++) {
- var sum = 0;
- var num_ok = 0;
- for (var j = Math.max(0, i - rollPeriod + 1); j < i + 1; j++) {
- var y = originalData[j][1];
- if (y == null || isNaN(y)) continue;
+ for (i = 0; i < originalData.length; i++) {
+ sum = 0;
+ num_ok = 0;
+ for (j = Math.max(0, i - rollPeriod + 1); j < i + 1; j++) {
+ y = originalData[j][1];
+ if (y === null || isNaN(y)) continue;
num_ok++;
sum += originalData[j][1];
}
@@ -2439,23 +3063,26 @@ Dygraph.prototype.rollingAverage = function(originalData, rollPeriod) {
}
} else {
- for (var i = 0; i < originalData.length; i++) {
- var sum = 0;
+ for (i = 0; i < originalData.length; i++) {
+ sum = 0;
var variance = 0;
- var num_ok = 0;
- for (var j = Math.max(0, i - rollPeriod + 1); j < i + 1; j++) {
- var y = originalData[j][1][0];
- if (y == null || isNaN(y)) continue;
+ num_ok = 0;
+ for (j = Math.max(0, i - rollPeriod + 1); j < i + 1; j++) {
+ y = originalData[j][1][0];
+ if (y === null || isNaN(y)) continue;
num_ok++;
sum += originalData[j][1][0];
variance += Math.pow(originalData[j][1][1], 2);
}
if (num_ok) {
- var stddev = Math.sqrt(variance) / num_ok;
+ stddev = Math.sqrt(variance) / num_ok;
rollingData[i] = [originalData[i][0],
[sum / num_ok, sigma * stddev, sigma * stddev]];
} else {
- rollingData[i] = [originalData[i][0], [null, null, null]];
+ // This explicitly preserves NaNs to aid with "independent series".
+ // See testRollingAveragePreservesNaNs.
+ var v = (rollPeriod == 1) ? originalData[i][1][0] : null;
+ rollingData[i] = [originalData[i][0], [v, v, v]];
}
}
}
@@ -2472,7 +3099,8 @@ Dygraph.prototype.rollingAverage = function(originalData, rollPeriod) {
*/
Dygraph.prototype.detectTypeFromString_ = function(str) {
var isDate = false;
- if (str.indexOf('-') > 0 ||
+ var dashPos = str.indexOf('-'); // could be 2006-01-01 _or_ 1.0e-2
+ if ((dashPos > 0 && (str[dashPos-1] != 'e' && str[dashPos-1] != 'E')) ||
str.indexOf('/') >= 0 ||
isNaN(parseFloat(str))) {
isDate = true;
@@ -2481,19 +3109,23 @@ Dygraph.prototype.detectTypeFromString_ = function(str) {
isDate = true;
}
+ this.setXAxisOptions_(isDate);
+};
+
+Dygraph.prototype.setXAxisOptions_ = function(isDate) {
if (isDate) {
- this.attrs_.xValueFormatter = Dygraph.dateString_;
this.attrs_.xValueParser = Dygraph.dateParser;
- this.attrs_.xTicker = Dygraph.dateTicker;
- this.attrs_.xAxisLabelFormatter = Dygraph.dateAxisFormatter;
+ this.attrs_.axes.x.valueFormatter = Dygraph.dateString_;
+ this.attrs_.axes.x.ticker = Dygraph.dateTicker;
+ this.attrs_.axes.x.axisLabelFormatter = Dygraph.dateAxisFormatter;
} else {
- // TODO(danvk): use Dygraph.numberFormatter here?
- /** @private (shut up, jsdoc!) */
- this.attrs_.xValueFormatter = function(x) { return x; };
/** @private (shut up, jsdoc!) */
this.attrs_.xValueParser = function(x) { return parseFloat(x); };
- this.attrs_.xTicker = Dygraph.numericTicks;
- this.attrs_.xAxisLabelFormatter = this.attrs_.xValueFormatter;
+ // TODO(danvk): use Dygraph.numberValueFormatter here?
+ /** @private (shut up, jsdoc!) */
+ this.attrs_.axes.x.valueFormatter = function(x) { return x; };
+ this.attrs_.axes.x.ticker = Dygraph.numericLinearTicks;
+ this.attrs_.axes.x.axisLabelFormatter = this.attrs_.axes.x.valueFormatter;
}
};
@@ -2550,7 +3182,9 @@ Dygraph.prototype.parseFloat_ = function(x, opt_line_no, opt_line) {
*/
Dygraph.prototype.parseCSV_ = function(data) {
var ret = [];
- var lines = data.split("\n");
+ var line_delimiter = Dygraph.detectLineDelimiter(data);
+ var lines = data.split(line_delimiter || "\n");
+ var vals, j;
// Use the default delimiter or fall back to a tab if that makes sense.
var delim = this.attr_('delimiter');
@@ -2563,6 +3197,7 @@ Dygraph.prototype.parseCSV_ = function(data) {
// User hasn't explicitly set labels, so they're (presumably) in the CSV.
start = 1;
this.attrs_.labels = lines[0].split(delim); // NOTE: _not_ user_attrs_.
+ this.attributes_.reparseSeries();
}
var line_no = 0;
@@ -2573,7 +3208,7 @@ Dygraph.prototype.parseCSV_ = function(data) {
for (var i = start; i < lines.length; i++) {
var line = lines[i];
line_no = i;
- if (line.length == 0) continue; // skip blank lines
+ if (line.length === 0) continue; // skip blank lines
if (line[0] == '#') continue; // skip comment lines
var inFields = line.split(delim);
if (inFields.length < 2) continue;
@@ -2588,9 +3223,9 @@ Dygraph.prototype.parseCSV_ = function(data) {
// If fractions are expected, parse the numbers as "A/B"
if (this.fractions_) {
- for (var j = 1; j < inFields.length; j++) {
+ for (j = 1; j < inFields.length; j++) {
// TODO(danvk): figure out an appropriate way to flag parse errors.
- var vals = inFields[j].split("/");
+ vals = inFields[j].split("/");
if (vals.length != 2) {
this.error('Expected fractional "num/den" values in CSV data ' +
"but found a value '" + inFields[j] + "' on line " +
@@ -2608,32 +3243,32 @@ Dygraph.prototype.parseCSV_ = function(data) {
'but line ' + (1 + i) + ' has an odd number of values (' +
(inFields.length - 1) + "): '" + line + "'");
}
- for (var j = 1; j < inFields.length; j += 2) {
+ for (j = 1; j < inFields.length; j += 2) {
fields[(j + 1) / 2] = [this.parseFloat_(inFields[j], i, line),
this.parseFloat_(inFields[j + 1], i, line)];
}
} else if (this.attr_("customBars")) {
// Bars are a low;center;high tuple
- for (var j = 1; j < inFields.length; j++) {
+ for (j = 1; j < inFields.length; j++) {
var val = inFields[j];
if (/^ *$/.test(val)) {
fields[j] = [null, null, null];
} else {
- var vals = val.split(";");
+ vals = val.split(";");
if (vals.length == 3) {
fields[j] = [ this.parseFloat_(vals[0], i, line),
this.parseFloat_(vals[1], i, line),
this.parseFloat_(vals[2], i, line) ];
} else {
- this.warning('When using customBars, values must be either blank ' +
- 'or "low;center;high" tuples (got "' + val +
- '" on line ' + (1+i));
+ this.warn('When using customBars, values must be either blank ' +
+ 'or "low;center;high" tuples (got "' + val +
+ '" on line ' + (1+i));
}
}
}
} else {
// Values are just numbers
- for (var j = 1; j < inFields.length; j++) {
+ for (j = 1; j < inFields.length; j++) {
fields[j] = this.parseFloat_(inFields[j], i, line);
}
}
@@ -2651,9 +3286,9 @@ Dygraph.prototype.parseCSV_ = function(data) {
// first row parsed correctly, then they probably double-specified the
// labels. We go with the values set in the option, discard this row and
// log a warning to the JS console.
- if (i == 0 && this.attr_('labels')) {
+ if (i === 0 && this.attr_('labels')) {
var all_null = true;
- for (var j = 0; all_null && j < fields.length; j++) {
+ for (j = 0; all_null && j < fields.length; j++) {
if (fields[j]) all_null = false;
}
if (all_null) {
@@ -2668,7 +3303,7 @@ Dygraph.prototype.parseCSV_ = function(data) {
if (outOfOrder) {
this.warn("CSV is out of order; order it correctly to speed loading.");
- ret.sort(function(a,b) { return a[0] - b[0] });
+ ret.sort(function(a,b) { return a[0] - b[0]; });
}
return ret;
@@ -2684,40 +3319,49 @@ Dygraph.prototype.parseCSV_ = function(data) {
*/
Dygraph.prototype.parseArray_ = function(data) {
// Peek at the first x value to see if it's numeric.
- if (data.length == 0) {
+ if (data.length === 0) {
this.error("Can't plot empty data set");
return null;
}
- if (data[0].length == 0) {
+ if (data[0].length === 0) {
this.error("Data set cannot contain an empty row");
return null;
}
- if (this.attr_("labels") == null) {
+ var i;
+ if (this.attr_("labels") === null) {
this.warn("Using default labels. Set labels explicitly via 'labels' " +
"in the options parameter");
this.attrs_.labels = [ "X" ];
- for (var i = 1; i < data[0].length; i++) {
- this.attrs_.labels.push("Y" + i);
+ for (i = 1; i < data[0].length; i++) {
+ this.attrs_.labels.push("Y" + i); // Not user_attrs_.
+ }
+ this.attributes_.reparseSeries();
+ } else {
+ var num_labels = this.attr_("labels");
+ if (num_labels.length != data[0].length) {
+ this.error("Mismatch between number of labels (" + num_labels +
+ ") and number of columns in array (" + data[0].length + ")");
+ return null;
}
}
if (Dygraph.isDateLike(data[0][0])) {
// Some intelligent defaults for a date x-axis.
- this.attrs_.xValueFormatter = Dygraph.dateString_;
- this.attrs_.xAxisLabelFormatter = Dygraph.dateAxisFormatter;
- this.attrs_.xTicker = Dygraph.dateTicker;
+ this.attrs_.axes.x.valueFormatter = Dygraph.dateString_;
+ this.attrs_.axes.x.ticker = Dygraph.dateTicker;
+ this.attrs_.axes.x.axisLabelFormatter = Dygraph.dateAxisFormatter;
// Assume they're all dates.
var parsedData = Dygraph.clone(data);
- for (var i = 0; i < data.length; i++) {
- if (parsedData[i].length == 0) {
+ for (i = 0; i < data.length; i++) {
+ if (parsedData[i].length === 0) {
this.error("Row " + (1 + i) + " of data is empty");
return null;
}
- if (parsedData[i][0] == null
- || typeof(parsedData[i][0].getTime) != 'function'
- || isNaN(parsedData[i][0].getTime())) {
+ if (parsedData[i][0] === null ||
+ typeof(parsedData[i][0].getTime) != 'function' ||
+ isNaN(parsedData[i][0].getTime())) {
this.error("x value in row " + (1 + i) + " is not a Date");
return null;
}
@@ -2727,8 +3371,9 @@ Dygraph.prototype.parseArray_ = function(data) {
} else {
// Some intelligent defaults for a numeric x-axis.
/** @private (shut up, jsdoc!) */
- this.attrs_.xValueFormatter = function(x) { return x; };
- this.attrs_.xTicker = Dygraph.numericTicks;
+ this.attrs_.axes.x.valueFormatter = function(x) { return x; };
+ this.attrs_.axes.x.ticker = Dygraph.numericLinearTicks;
+ this.attrs_.axes.x.axisLabelFormatter = Dygraph.numberAxisLabelFormatter;
return data;
}
};
@@ -2743,20 +3388,33 @@ Dygraph.prototype.parseArray_ = function(data) {
* @private
*/
Dygraph.prototype.parseDataTable_ = function(data) {
+ var shortTextForAnnotationNum = function(num) {
+ // converts [0-9]+ [A-Z][a-z]*
+ // example: 0=A, 1=B, 25=Z, 26=Aa, 27=Ab
+ // and continues like.. Ba Bb .. Za .. Zz..Aaa...Zzz Aaaa Zzzz
+ var shortText = String.fromCharCode(65 /* A */ + num % 26);
+ num = Math.floor(num / 26);
+ while ( num > 0 ) {
+ shortText = String.fromCharCode(65 /* A */ + (num - 1) % 26 ) + shortText.toLowerCase();
+ num = Math.floor((num - 1) / 26);
+ }
+ return shortText;
+ };
+
var cols = data.getNumberOfColumns();
var rows = data.getNumberOfRows();
var indepType = data.getColumnType(0);
if (indepType == 'date' || indepType == 'datetime') {
- this.attrs_.xValueFormatter = Dygraph.dateString_;
this.attrs_.xValueParser = Dygraph.dateParser;
- this.attrs_.xTicker = Dygraph.dateTicker;
- this.attrs_.xAxisLabelFormatter = Dygraph.dateAxisFormatter;
+ this.attrs_.axes.x.valueFormatter = Dygraph.dateString_;
+ this.attrs_.axes.x.ticker = Dygraph.dateTicker;
+ this.attrs_.axes.x.axisLabelFormatter = Dygraph.dateAxisFormatter;
} else if (indepType == 'number') {
- this.attrs_.xValueFormatter = function(x) { return x; };
this.attrs_.xValueParser = function(x) { return parseFloat(x); };
- this.attrs_.xTicker = Dygraph.numericTicks;
- this.attrs_.xAxisLabelFormatter = this.attrs_.xValueFormatter;
+ this.attrs_.axes.x.valueFormatter = function(x) { return x; };
+ this.attrs_.axes.x.ticker = Dygraph.numericLinearTicks;
+ this.attrs_.axes.x.axisLabelFormatter = this.attrs_.axes.x.valueFormatter;
} else {
this.error("only 'date', 'datetime' and 'number' types are supported for " +
"column 1 of DataTable input (Got '" + indepType + "')");
@@ -2767,7 +3425,8 @@ Dygraph.prototype.parseDataTable_ = function(data) {
var colIdx = [];
var annotationCols = {}; // data index -> [annotation cols]
var hasAnnotations = false;
- for (var i = 1; i < cols; i++) {
+ var i, j;
+ for (i = 1; i < cols; i++) {
var type = data.getColumnType(i);
if (type == 'number') {
colIdx.push(i);
@@ -2789,7 +3448,7 @@ Dygraph.prototype.parseDataTable_ = function(data) {
// Read column labels
// TODO(danvk): add support back for errorBars
var labels = [data.getColumnLabel(0)];
- for (var i = 0; i < colIdx.length; i++) {
+ for (i = 0; i < colIdx.length; i++) {
labels.push(data.getColumnLabel(colIdx[i]));
if (this.attr_("errorBars")) i += 1;
}
@@ -2799,7 +3458,7 @@ Dygraph.prototype.parseDataTable_ = function(data) {
var ret = [];
var outOfOrder = false;
var annotations = [];
- for (var i = 0; i < rows; i++) {
+ for (i = 0; i < rows; i++) {
var row = [];
if (typeof(data.getValue(i, 0)) === 'undefined' ||
data.getValue(i, 0) === null) {
@@ -2814,16 +3473,16 @@ Dygraph.prototype.parseDataTable_ = function(data) {
row.push(data.getValue(i, 0));
}
if (!this.attr_("errorBars")) {
- for (var j = 0; j < colIdx.length; j++) {
+ for (j = 0; j < colIdx.length; j++) {
var col = colIdx[j];
row.push(data.getValue(i, col));
if (hasAnnotations &&
annotationCols.hasOwnProperty(col) &&
- data.getValue(i, annotationCols[col][0]) != null) {
+ data.getValue(i, annotationCols[col][0]) !== null) {
var ann = {};
ann.series = data.getColumnLabel(col);
ann.xval = row[0];
- ann.shortText = String.fromCharCode(65 /* A */ + annotations.length)
+ ann.shortText = shortTextForAnnotationNum(annotations.length);
ann.text = '';
for (var k = 0; k < annotationCols[col].length; k++) {
if (k) ann.text += "\n";
@@ -2834,11 +3493,11 @@ Dygraph.prototype.parseDataTable_ = function(data) {
}
// Strip out infinities, which give dygraphs problems later on.
- for (var j = 0; j < row.length; j++) {
+ for (j = 0; j < row.length; j++) {
if (!isFinite(row[j])) row[j] = null;
}
} else {
- for (var j = 0; j < cols - 1; j++) {
+ for (j = 0; j < cols - 1; j++) {
row.push([ data.getValue(i, 1 + 2 * j), data.getValue(i, 2 + 2 * j) ]);
}
}
@@ -2850,14 +3509,15 @@ Dygraph.prototype.parseDataTable_ = function(data) {
if (outOfOrder) {
this.warn("DataTable is out of order; order it correctly to speed loading.");
- ret.sort(function(a,b) { return a[0] - b[0] });
+ ret.sort(function(a,b) { return a[0] - b[0]; });
}
this.rawData_ = ret;
if (annotations.length > 0) {
this.setAnnotations(annotations, true);
}
-}
+ this.attributes_.reparseSeries();
+};
/**
* Get the CSV data. If it's in a function, call that function. If it's in a
@@ -2865,38 +3525,52 @@ Dygraph.prototype.parseDataTable_ = function(data) {
* @private
*/
Dygraph.prototype.start_ = function() {
- if (typeof this.file_ == 'function') {
- // CSV string. Pretend we got it via XHR.
- this.loadedEvent_(this.file_());
- } else if (Dygraph.isArrayLike(this.file_)) {
- this.rawData_ = this.parseArray_(this.file_);
+ var data = this.file_;
+
+ // Functions can return references of all other types.
+ if (typeof data == 'function') {
+ data = data();
+ }
+
+ if (Dygraph.isArrayLike(data)) {
+ this.rawData_ = this.parseArray_(data);
this.predraw_();
- } else if (typeof this.file_ == 'object' &&
- typeof this.file_.getColumnRange == 'function') {
+ } else if (typeof data == 'object' &&
+ typeof data.getColumnRange == 'function') {
// must be a DataTable from gviz.
- this.parseDataTable_(this.file_);
+ this.parseDataTable_(data);
this.predraw_();
- } else if (typeof this.file_ == 'string') {
+ } else if (typeof data == 'string') {
// Heuristic: a newline means it's CSV data. Otherwise it's an URL.
- if (this.file_.indexOf('\n') >= 0) {
- this.loadedEvent_(this.file_);
+ var line_delimiter = Dygraph.detectLineDelimiter(data);
+ if (line_delimiter) {
+ this.loadedEvent_(data);
} else {
- var req = new XMLHttpRequest();
+ // REMOVE_FOR_IE
+ var req;
+ if (window.XMLHttpRequest) {
+ // Firefox, Opera, IE7, and other browsers will use the native object
+ req = new XMLHttpRequest();
+ } else {
+ // IE 5 and 6 will use the ActiveX control
+ req = new ActiveXObject("Microsoft.XMLHTTP");
+ }
+
var caller = this;
req.onreadystatechange = function () {
if (req.readyState == 4) {
- if (req.status == 200 || // Normal http
- req.status == 0) { // Chrome w/ --allow-file-access-from-files
+ if (req.status === 200 || // Normal http
+ req.status === 0) { // Chrome w/ --allow-file-access-from-files
caller.loadedEvent_(req.responseText);
}
}
};
- req.open("GET", this.file_, true);
+ req.open("GET", data, true);
req.send(null);
}
} else {
- this.error("Unknown data format: " + (typeof this.file_));
+ this.error("Unknown data format: " + (typeof data));
}
};
@@ -2917,9 +3591,13 @@ Dygraph.prototype.start_ = function() {
* avoiding the occasional infinite loop and preventing redraws when it's not
* necessary (e.g. when updating a callback).
*/
-Dygraph.prototype.updateOptions = function(attrs, block_redraw) {
+Dygraph.prototype.updateOptions = function(input_attrs, block_redraw) {
if (typeof(block_redraw) == 'undefined') block_redraw = false;
+ // mapLegacyOptions_ drops the "file" parameter as a convenience to us.
+ var file = input_attrs.file;
+ var attrs = Dygraph.mapLegacyOptions_(input_attrs);
+
// TODO(danvk): this is a mess. Move these options into attr_.
if ('rollPeriod' in attrs) {
this.rollPeriod_ = attrs.rollPeriod;
@@ -2927,11 +3605,11 @@ Dygraph.prototype.updateOptions = function(attrs, block_redraw) {
if ('dateWindow' in attrs) {
this.dateWindow_ = attrs.dateWindow;
if (!('isZoomedIgnoreProgrammaticZoom' in attrs)) {
- this.zoomed_x_ = attrs.dateWindow != null;
+ this.zoomed_x_ = (attrs.dateWindow !== null);
}
}
if ('valueRange' in attrs && !('isZoomedIgnoreProgrammaticZoom' in attrs)) {
- this.zoomed_y_ = attrs.valueRange != null;
+ this.zoomed_y_ = (attrs.valueRange !== null);
}
// TODO(danvk): validate per-series options.
@@ -2941,17 +3619,69 @@ Dygraph.prototype.updateOptions = function(attrs, block_redraw) {
// drawPoints
// highlightCircleSize
- Dygraph.update(this.user_attrs_, attrs);
+ // Check if this set options will require new points.
+ var requiresNewPoints = Dygraph.isPixelChangingOptionList(this.attr_("labels"), attrs);
+
+ Dygraph.updateDeep(this.user_attrs_, attrs);
- if (attrs['file']) {
- this.file_ = attrs['file'];
+ this.attributes_.reparseSeries();
+
+ if (file) {
+ this.file_ = file;
if (!block_redraw) this.start_();
} else {
- if (!block_redraw) this.predraw_();
+ if (!block_redraw) {
+ if (requiresNewPoints) {
+ this.predraw_();
+ } else {
+ this.renderGraph_(false);
+ }
+ }
}
};
/**
+ * Returns a copy of the options with deprecated names converted into current
+ * names. Also drops the (potentially-large) 'file' attribute. If the caller is
+ * interested in that, they should save a copy before calling this.
+ * @private
+ */
+Dygraph.mapLegacyOptions_ = function(attrs) {
+ var my_attrs = {};
+ for (var k in attrs) {
+ if (k == 'file') continue;
+ if (attrs.hasOwnProperty(k)) my_attrs[k] = attrs[k];
+ }
+
+ var set = function(axis, opt, value) {
+ if (!my_attrs.axes) my_attrs.axes = {};
+ if (!my_attrs.axes[axis]) my_attrs.axes[axis] = {};
+ my_attrs.axes[axis][opt] = value;
+ };
+ var map = function(opt, axis, new_opt) {
+ if (typeof(attrs[opt]) != 'undefined') {
+ Dygraph.warn("Option " + opt + " is deprecated. Use the " +
+ new_opt + " option for the " + axis + " axis instead. " +
+ "(e.g. { axes : { " + axis + " : { " + new_opt + " : ... } } } " +
+ "(see http://dygraphs.com/per-axis.html for more information.");
+ set(axis, new_opt, attrs[opt]);
+ delete my_attrs[opt];
+ }
+ };
+
+ // This maps, e.g., xValueFormater -> axes: { x: { valueFormatter: ... } }
+ map('xValueFormatter', 'x', 'valueFormatter');
+ map('pixelsPerXLabel', 'x', 'pixelsPerLabel');
+ map('xAxisLabelFormatter', 'x', 'axisLabelFormatter');
+ map('xTicker', 'x', 'ticker');
+ map('yValueFormatter', 'y', 'valueFormatter');
+ map('pixelsPerYLabel', 'y', 'pixelsPerLabel');
+ map('yAxisLabelFormatter', 'y', 'axisLabelFormatter');
+ map('yTicker', 'y', 'ticker');
+ return my_attrs;
+};
+
+/**
* Resizes the dygraph. If no parameters are specified, resizes to fill the
* containing div (which has presumably changed size since the dygraph was
* instantiated. If the width/height are specified, the div will be resized.
@@ -2974,9 +3704,8 @@ Dygraph.prototype.resize = function(width, height) {
width = height = null;
}
- // TODO(danvk): there should be a clear() method.
- this.maindiv_.innerHTML = "";
- this.attrs_.labelsDiv = null;
+ var old_width = this.width_;
+ var old_height = this.height_;
if (width) {
this.maindiv_.style.width = width + "px";
@@ -2984,12 +3713,16 @@ Dygraph.prototype.resize = function(width, height) {
this.width_ = width;
this.height_ = height;
} else {
- this.width_ = this.maindiv_.offsetWidth;
- this.height_ = this.maindiv_.offsetHeight;
+ this.width_ = this.maindiv_.clientWidth;
+ this.height_ = this.maindiv_.clientHeight;
}
- this.createInterface_();
- this.predraw_();
+ if (old_width != this.width_ || old_height != this.height_) {
+ // Resizing a canvas erases it, even when the size doesn't change, so
+ // any resize needs to be followed by a redraw.
+ this.resizeElements_();
+ this.predraw_();
+ }
this.resize_lock = false;
};
@@ -3011,10 +3744,11 @@ Dygraph.prototype.visibility = function() {
// Do lazy-initialization, so that this happens after we know the number of
// data series.
if (!this.attr_("visibility")) {
- this.attrs_["visibility"] = [];
+ this.attrs_.visibility = [];
}
- while (this.attr_("visibility").length < this.rawData_[0].length - 1) {
- this.attr_("visibility").push(true);
+ // TODO(danvk): it looks like this could go into an infinite loop w/ user_attrs.
+ while (this.attr_("visibility").length < this.numColumns() - 1) {
+ this.attrs_.visibility.push(true);
}
return this.attr_("visibility");
};
@@ -3033,12 +3767,32 @@ Dygraph.prototype.setVisibility = function(num, value) {
};
/**
+ * How large of an area will the dygraph render itself in?
+ * This is used for testing.
+ * @return A {width: w, height: h} object.
+ * @private
+ */
+Dygraph.prototype.size = function() {
+ return { width: this.width_, height: this.height_ };
+};
+
+/**
* Update the list of annotations and redraw the chart.
+ * See dygraphs.com/annotations.html for more info on how to use annotations.
+ * @param ann {Array} An array of annotation objects.
+ * @param suppressDraw {Boolean} Set to "true" to block chart redraw (optional).
*/
Dygraph.prototype.setAnnotations = function(ann, suppressDraw) {
// Only add the annotation CSS rule once we know it will be used.
Dygraph.addAnnotationRule();
this.annotations_ = ann;
+ if (!this.layout_) {
+ this.warn("Tried to setAnnotations before dygraph was ready. " +
+ "Try setting them in a ready() block. See " +
+ "dygraphs.com/tests/annotation.html");
+ return;
+ }
+
this.layout_.setAnnotations(this.annotations_);
if (!suppressDraw) {
this.predraw_();
@@ -3053,15 +3807,42 @@ Dygraph.prototype.annotations = function() {
};
/**
+ * Get the list of label names for this graph. The first column is the
+ * x-axis, so the data series names start at index 1.
+ *
+ * Returns null when labels have not yet been defined.
+ */
+Dygraph.prototype.getLabels = function() {
+ var labels = this.attr_("labels");
+ return labels ? labels.slice() : null;
+};
+
+/**
* Get the index of a series (column) given its name. The first column is the
* x-axis, so the data series start with index 1.
*/
Dygraph.prototype.indexFromSetName = function(name) {
- var labels = this.attr_("labels");
- for (var i = 0; i < labels.length; i++) {
- if (labels[i] == name) return i;
+ return this.setIndexByName_[name];
+};
+
+/**
+ * Trigger a callback when the dygraph has drawn itself and is ready to be
+ * manipulated. This is primarily useful when dygraphs has to do an XHR for the
+ * data (i.e. a URL is passed as the data source) and the chart is drawn
+ * asynchronously. If the chart has already drawn, the callback will fire
+ * immediately.
+ *
+ * This is a good place to call setAnnotation().
+ *
+ * @param {function(!Dygraph)} callback The callback to trigger when the chart
+ * is ready.
+ */
+Dygraph.prototype.ready = function(callback) {
+ if (this.is_initial_draw_) {
+ this.readyFns_.push(callback);
+ } else {
+ callback(this);
}
- return null;
};
/**
@@ -3071,6 +3852,7 @@ Dygraph.prototype.indexFromSetName = function(name) {
* called once -- all calls after the first will return immediately.
*/
Dygraph.addAnnotationRule = function() {
+ // TODO(danvk): move this function into plugins/annotations.js?
if (Dygraph.addedAnnotationCSS) return;
var rule = "border: 1px solid black; " +
@@ -3103,7 +3885,7 @@ Dygraph.addAnnotationRule = function() {
}
this.warn("Unable to add default annotation CSS rule; display may be off.");
-}
+};
// Older pages may still use this name.
-DateGraph = Dygraph;
+var DateGraph = Dygraph;