return this.__repr__();
};
-/**
- * Formatting to use for an integer number.
- *
- * @param {Number} x The number to format
- * @param {Number} unused_precision The precision to use, ignored.
- * @return {String} A string formatted like %g in printf. The max generated
- * string length should be precision + 6 (e.g 1.123e+300).
- */
-Dygraph.intFormat = function(x, unused_precision) {
- return x.toString();
-}
-
-/**
- * Number formatting function which mimicks the behavior of %g in printf, i.e.
- * either exponential or fixed format (without trailing 0s) is used depending on
- * the length of the generated string. The advantage of this format is that
- * there is a predictable upper bound on the resulting string length,
- * significant figures are not dropped, and normal numbers are not displayed in
- * exponential notation.
- *
- * NOTE: JavaScript's native toPrecision() is NOT a drop-in replacement for %g.
- * It creates strings which are too long for absolute values between 10^-4 and
- * 10^-6. See tests/number-format.html for output examples.
- *
- * @param {Number} x The number to format
- * @param {Number} opt_precision The precision to use, default 2.
- * @return {String} A string formatted like %g in printf. The max generated
- * string length should be precision + 6 (e.g 1.123e+300).
- */
-Dygraph.floatFormat = function(x, opt_precision) {
- // Avoid invalid precision values; [1, 21] is the valid range.
- var p = Math.min(Math.max(1, opt_precision || 2), 21);
-
- // This is deceptively simple. The actual algorithm comes from:
- //
- // Max allowed length = p + 4
- // where 4 comes from 'e+n' and '.'.
- //
- // Length of fixed format = 2 + y + p
- // where 2 comes from '0.' and y = # of leading zeroes.
- //
- // Equating the two and solving for y yields y = 2, or 0.00xxxx which is
- // 1.0e-3.
- //
- // Since the behavior of toPrecision() is identical for larger numbers, we
- // don't have to worry about the other bound.
- //
- // Finally, the argument for toExponential() is the number of trailing digits,
- // so we take off 1 for the value before the '.'.
- return (Math.abs(x) < 1.0e-3 && x != 0.0) ?
- x.toExponential(p - 1) : x.toPrecision(p);
-};
-
// Various default values
Dygraph.DEFAULT_ROLL_PERIOD = 1;
Dygraph.DEFAULT_WIDTH = 480;
labelsKMG2: false,
showLabelsOnHighlight: true,
- yValueFormatter: function(x, opt_precision) {
- var s = Dygraph.floatFormat(x, opt_precision);
- var s2 = Dygraph.intFormat(x);
- return s.length < s2.length ? s : s2;
- },
+ yValueFormatter: function(a,b) { return Dygraph.numberFormatter(a,b); },
+ digitsAfterDecimal: 2,
+ maxNumberWidth: 6,
+ sigFigs: null,
strokeWidth: 1.0,
stepPlot: false,
avoidMinZero: false,
+ // Sizes of the various chart labels.
+ titleHeight: 28,
+ xLabelHeight: 18,
+ yLabelWidth: 18,
+
interactionModel: null // will be set to Dygraph.defaultInteractionModel.
};
// Used for initializing annotation CSS rules only once.
Dygraph.addedAnnotationCSS = false;
+/**
+ * Return the 2d context for a dygraph canvas.
+ *
+ * This method is only exposed for the sake of replacing the function in
+ * automated tests, e.g.
+ *
+ * var oldFunc = Dygraph.getContext();
+ * Dygraph.getContext = function(canvas) {
+ * var realContext = oldFunc(canvas);
+ * return new Proxy(realContext);
+ * };
+ */
+Dygraph.getContext = function(canvas) {
+ return canvas.getContext("2d");
+};
+
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,
this.is_initial_draw_ = true;
this.annotations_ = [];
- // Number of digits to use when labeling the x (if numeric) and y axis
- // ticks.
- this.numXDigits_ = 2;
- this.numYDigits_ = 2;
-
- // When labeling x (if numeric) or y values in the legend, there are
- // numDigits + numExtraDigits of precision used. For axes labels with N
- // digits of precision, the data should be displayed with at least N+1 digits
- // of precision. The reason for this is to divide each interval between
- // successive ticks into tenths (for 1) or hundredths (for 2), etc. For
- // example, if the labels are [0, 1, 2], we want data to be displayed as
- // 0.1, 1.3, etc.
- this.numExtraDigits_ = 1;
+ // Zoomed indicators - These indicate when the graph has been zoomed and on what axis.
+ this.zoomed_x_ = false;
+ this.zoomed_y_ = false;
// Clear the div. This ensure that, if multiple dygraphs are passed the same
// div, then only one will be drawn.
this.start_();
};
+/**
+ * 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).
+ */
+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'.";
+};
+
Dygraph.prototype.toString = function() {
var maindiv = this.maindiv_;
var id = (maindiv && maindiv.id) ? maindiv.id : maindiv
* If the Dygraph has dates on the x-axis, these will be millis since epoch.
*/
Dygraph.prototype.xAxisRange = function() {
- if (this.dateWindow_) return this.dateWindow_;
+ return this.dateWindow_ ? this.dateWindow_ : this.xAxisExtremes();
+};
- // The entire chart is visible.
+/**
+ * Returns the lower- and upper-bound x-axis values of the
+ * data set.
+ */
+Dygraph.prototype.xAxisExtremes = function() {
var left = this.rawData_[0][0];
var right = this.rawData_[this.rawData_.length - 1][0];
return [left, right];
/**
* Converts a y for an axis to a percentage from the top to the
- * bottom of the div.
+ * bottom of the drawing area.
*
* If the coordinate represents a value visible on the canvas, then
* the value will be between 0 and 1, where 0 is the top of the canvas.
var pct;
if (!this.axes_[axis].logscale) {
- // yrange[1] - y is unit distance from the bottom.
- // yrange[1] - yrange[0] is the scale of the range.
+ // 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.
pct = (yRange[1] - y) / (yRange[1] - yRange[0]);
} else {
}
/**
+ * Converts an x value to a percentage from the left to the right of
+ * the drawing area.
+ *
+ * If the coordinate represents a value visible on the canvas, then
+ * the value will be between 0 and 1, where 0 is the left of the canvas.
+ * However, this method will return values outside the range, as
+ * values can fall outside the canvas.
+ *
+ * If x is null, this returns null.
+ */
+Dygraph.prototype.toPercentXCoord = function(x) {
+ if (x == null) {
+ return null;
+ }
+
+ var xRange = this.xAxisRange();
+ return (x - xRange[0]) / (xRange[1] - xRange[0]);
+}
+
+/**
* Returns the number of columns (including the independent variable).
*/
Dygraph.prototype.numColumns = function() {
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.hidden_ctx_ = Dygraph.getContext(this.hidden_);
// The interactive parts of the graph are drawn on top of the chart.
this.graphDiv.appendChild(this.hidden_);
};
/**
- * Position the labels div so that its right edge is flush with the right edge
- * of the charting area.
+ * 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
*/
Dygraph.prototype.positionLabelsDiv_ = function() {
// Don't touch a user-specified labelsDiv.
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";
};
/**
var display = this.attr_('showRoller') ? 'block' : 'none';
+ var area = this.plotter_.area;
var textAttr = { "position": "absolute",
"zIndex": 10,
- "top": (this.plotter_.area.h - 25) + "px",
- "left": (this.plotter_.area.x + 1) + "px",
+ "top": (area.y + area.h - 25) + "px",
+ "left": (area.x + 1) + "px",
"display": display
};
this.roller_.size = "2";
context.initialLeftmostDate = xRange[0];
context.xUnitsPerPixel = context.dateRange / (g.plotter_.area.w - 1);
+ if (g.attr_("panEdgeFraction")) {
+ var maxXPixelsToDraw = g.width_ * g.attr_("panEdgeFraction");
+ var xExtremes = g.xAxisExtremes(); // I REALLY WANT TO CALL THIS xTremes!
+
+ var boundedLeftX = g.toDomXCoord(xExtremes[0]) - maxXPixelsToDraw;
+ var boundedRightX = g.toDomXCoord(xExtremes[1]) + maxXPixelsToDraw;
+
+ var boundedLeftDate = g.toDataXCoord(boundedLeftX);
+ var boundedRightDate = g.toDataXCoord(boundedRightX);
+ context.boundedDates = [boundedLeftDate, boundedRightDate];
+
+ var boundedValues = [];
+ var maxYPixelsToDraw = g.height_ * g.attr_("panEdgeFraction");
+
+ for (var i = 0; i < g.axes_.length; i++) {
+ var axis = g.axes_[i];
+ var yExtremes = axis.extremeRange;
+
+ var boundedTopY = g.toDomYCoord(yExtremes[0], i) + maxYPixelsToDraw;
+ var boundedBottomY = g.toDomYCoord(yExtremes[1], i) - maxYPixelsToDraw;
+
+ var boundedTopValue = g.toDataYCoord(boundedTopY);
+ var boundedBottomValue = g.toDataYCoord(boundedBottomY);
+
+ boundedValues[i] = [boundedTopValue, boundedBottomValue];
+ }
+ context.boundedValues = boundedValues;
+ }
+
// Record the range of each y-axis at the start of the drag.
// If any axis has a valueRange or valueWindow, then we want a 2D pan.
context.is2DPan = false;
var minDate = context.initialLeftmostDate -
(context.dragEndX - context.dragStartX) * context.xUnitsPerPixel;
+ if (context.boundedDates) {
+ minDate = Math.max(minDate, context.boundedDates[0]);
+ }
var maxDate = minDate + context.dateRange;
+ if (context.boundedDates) {
+ if (maxDate > context.boundedDates[1]) {
+ // Adjust minDate, and recompute maxDate.
+ minDate = minDate - (maxDate - context.boundedDates[1]);
+ maxDate = minDate + context.dateRange;
+ }
+ }
+
g.dateWindow_ = [minDate, maxDate];
// y-axis scaling is automatic unless this is a full 2D pan.
var pixelsDragged = context.dragEndY - context.dragStartY;
var unitsDragged = pixelsDragged * axis.unitsPerPixel;
+
+ var boundedValue = context.boundedValues ? context.boundedValues[i] : null;
// In log scale, maxValue and minValue are the logs of those values.
var maxValue = axis.initialTopValue + unitsDragged;
+ if (boundedValue) {
+ maxValue = Math.min(maxValue, boundedValue[1]);
+ }
var minValue = maxValue - axis.dragValueRange;
+ if (boundedValue) {
+ if (minValue < boundedValue[0]) {
+ // Adjust maxValue, and recompute minValue.
+ maxValue = maxValue - (minValue - boundedValue[0]);
+ minValue = maxValue - axis.dragValueRange;
+ }
+ }
if (axis.logscale) {
axis.valueWindow = [ Math.pow(Dygraph.LOG_SCALE, minValue),
Math.pow(Dygraph.LOG_SCALE, maxValue) ];
context.initialLeftmostDate = null;
context.dateRange = null;
context.valueRange = null;
+ context.boundedDates = null;
+ context.boundedValues = null;
}
// Called in response to an interaction model operation that
g.doZoomY_(Math.min(context.dragStartY, context.dragEndY),
Math.max(context.dragStartY, context.dragEndY));
} else {
- g.canvas_.getContext("2d").clearRect(0, 0,
- g.canvas_.width,
- g.canvas_.height);
+ g.canvas_ctx_.clearRect(0, 0, g.canvas_.width, g.canvas_.height);
}
context.dragStartX = null;
context.dragStartY = null;
px: 0,
py: 0,
+ // Values for use with panEdgeFraction, which limit how far outside the
+ // graph's data boundaries it can be panned.
+ boundedDates: null, // [minDate, maxDate]
+ boundedValues: null, // [[minValue, maxValue] ...]
+
initializeMouseDown: function(event, g, context) {
// prevents mouse drags from selecting page text.
if (event.preventDefault) {
Dygraph.prototype.drawZoomRect_ = function(direction, startX, endX, startY,
endY, prevDirection, prevEndX,
prevEndY) {
- var ctx = this.canvas_.getContext("2d");
+ var ctx = this.canvas_ctx_;
// Clean up from the previous rect if necessary
if (prevDirection == Dygraph.HORIZONTAL) {
*/
Dygraph.prototype.doZoomXDates_ = function(minDate, maxDate) {
this.dateWindow_ = [minDate, maxDate];
+ this.zoomed_x_ = true;
this.drawGraph_();
if (this.attr_("zoomCallback")) {
this.attr_("zoomCallback")(minDate, maxDate, this.yAxisRanges());
valueRanges.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());
}
};
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];
* @private
*/
Dygraph.prototype.mouseMove_ = function(event) {
- var canvasx = Dygraph.pageX(event) - Dygraph.findPosX(this.mouseEventElement_);
- var points = this.layout_.points;
-
// 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_);
+
var lastx = -1;
var lasty = -1;
var labels = this.attr_('labels');
var html = '';
for (var i = 1; i < labels.length; i++) {
- var c = new RGBColor(this.plotter_.colors[labels[i]]);
- if (i > 1) html += (sepLines ? '<br/>' : ' ');
- html += "<b><font color='" + c.toHex() + "'>—" + labels[i] +
- "</font></b>";
+ if (!this.visibility()[i - 1]) continue;
+ var c = this.plotter_.colors[labels[i]];
+ if (html != '') html += (sepLines ? '<br/>' : ' ');
+ html += "<b><span style='color: " + c + ";'>—" + labels[i] +
+ "</span></b>";
}
return html;
}
- var displayDigits = this.numXDigits_ + this.numExtraDigits_;
- var html = this.attr_('xValueFormatter')(x, displayDigits) + ":";
+ var html = this.attr_('xValueFormatter')(x) + ":";
var fmtFunc = this.attr_('yValueFormatter');
var showZeros = this.attr_("labelsShowZeroValues");
if (!Dygraph.isOK(pt.canvasy)) continue;
if (sepLines) html += "<br/>";
- var c = new RGBColor(this.plotter_.colors[pt.name]);
- var yval = fmtFunc(pt.yval, displayDigits);
+ 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 += " <b><font color='" + c.toHex() + "'>"
- + pt.name + "</font></b>:"
+ html += " <b><span style='color: " + c + ";'>"
+ + pt.name + "</span></b>:"
+ yval;
}
return html;
};
+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;
+ } 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;
+ }
+ }
+};
+
/**
* Draw dots over the selectied points in the data series. This function
* takes care of cleanup of previously-drawn dots.
*/
Dygraph.prototype.updateSelection_ = function() {
// Clear the previously drawn vertical, if there is one
- var ctx = this.canvas_.getContext("2d");
+ var ctx = this.canvas_ctx_;
if (this.previousVerticalX_ >= 0) {
// Determine the maximum highlight circle size.
var maxCircleSize = 0;
if (this.selPoints_.length > 0) {
// Set the status message to indicate the selected point(s)
if (this.attr_('showLabelsOnHighlight')) {
- var html = this.generateLegendHTML_(this.lastx_, this.selPoints_);
- this.attr_("labelsDiv").innerHTML = html;
+ this.setLegendHTML_(this.lastx_, this.selPoints_);
}
// Draw colored circles over the center of each selected point
this.lastx_ = this.selPoints_[0].xval;
this.updateSelection_();
} else {
- this.lastx_ = -1;
this.clearSelection();
}
*/
Dygraph.prototype.clearSelection = function() {
// Get rid of the overlay data
- var ctx = this.canvas_.getContext("2d");
- ctx.clearRect(0, 0, this.width_, this.height_);
- this.attr_('labelsDiv').innerHTML = this.generateLegendHTML_();
+ this.canvas_ctx_.clearRect(0, 0, this.width_, this.height_);
+ this.setLegendHTML_();
this.selPoints_ = [];
this.lastx_ = -1;
}
}
}
return -1;
-}
+};
+
+/**
+ * Number formatting function which mimicks the behavior of %g in printf, i.e.
+ * either exponential or fixed format (without trailing 0s) is used depending on
+ * the length of the generated string. The advantage of this format is that
+ * there is a predictable upper bound on the resulting string length,
+ * significant figures are not dropped, and normal numbers are not displayed in
+ * exponential notation.
+ *
+ * NOTE: JavaScript's native toPrecision() is NOT a drop-in replacement for %g.
+ * It creates strings which are too long for absolute values between 10^-4 and
+ * 10^-6, e.g. '0.00001' instead of '1e-5'. See tests/number-format.html for
+ * output examples.
+ *
+ * @param {Number} x The number to format
+ * @param {Number} opt_precision The precision to use, default 2.
+ * @return {String} A string formatted like %g in printf. The max generated
+ * string length should be precision + 6 (e.g 1.123e+300).
+ */
+Dygraph.floatFormat = function(x, opt_precision) {
+ // Avoid invalid precision values; [1, 21] is the valid range.
+ var p = Math.min(Math.max(1, opt_precision || 2), 21);
+
+ // This is deceptively simple. The actual algorithm comes from:
+ //
+ // Max allowed length = p + 4
+ // where 4 comes from 'e+n' and '.'.
+ //
+ // Length of fixed format = 2 + y + p
+ // where 2 comes from '0.' and y = # of leading zeroes.
+ //
+ // Equating the two and solving for y yields y = 2, or 0.00xxxx which is
+ // 1.0e-3.
+ //
+ // Since the behavior of toPrecision() is identical for larger numbers, we
+ // don't have to worry about the other bound.
+ //
+ // Finally, the argument for toExponential() is the number of trailing digits,
+ // so we take off 1 for the value before the '.'.
+ return (Math.abs(x) < 1.0e-3 && x != 0.0) ?
+ x.toExponential(p - 1) : x.toPrecision(p);
+};
+
+/**
+ * Return a string version of a number. This respects the digitsAfterDecimal
+ * and maxNumberWidth options.
+ * @param {Number} x The number to be formatted
+ * @param {Dygraph} g The dygraph object
+ */
+Dygraph.numberFormatter = function(x, g) {
+ var sigFigs = g.attr_('sigFigs');
+
+ if (sigFigs !== null) {
+ // User has opted for a fixed number of significant figures.
+ return Dygraph.floatFormat(x, sigFigs);
+ }
+
+ var digits = g.attr_('digitsAfterDecimal');
+ var maxNumberWidth = g.attr_('maxNumberWidth');
+
+ // 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))) {
+ return x.toExponential(digits);
+ } else {
+ return '' + Dygraph.round_(x, digits);
+ }
+};
Dygraph.zeropad = function(x) {
if (x < 10) return "0" + x; else return "" + x;
-}
+};
/**
* Return a string version of the hours, minutes and seconds portion of a date.
} else {
return zeropad(d.getHours()) + ":" + zeropad(d.getMinutes());
}
-}
+};
/**
* Convert a JS date to a string appropriate to display on an axis that
return Dygraph.hmsString_(date.getTime());
}
}
-}
+};
/**
* Convert a JS date (millis since epoch) to YYYY/MM/DD
};
/**
+ * Round a number to the specified number of digits past the decimal point.
+ * @param {Number} num The number to round
+ * @param {Number} places The number of decimals to which to round
+ * @return {Number} The rounded number
+ * @private
+ */
+Dygraph.round_ = function(num, places) {
+ var shift = Math.pow(10, places);
+ return Math.round(num * shift)/shift;
+};
+
+/**
* Fires when there's data available to be graphed.
* @param {String} data Raw CSV data to be plotted
* @private
range = [this.rawData_[0][0], this.rawData_[this.rawData_.length - 1][0]];
}
- var formatter = this.attr_('xTicker');
- var ret = formatter(range[0], range[1], this);
- var xTicks = [];
-
- // Note: numericTicks() returns a {ticks: [...], numDigits: yy} dictionary,
- // whereas dateTicker and user-defined tickers typically just return a ticks
- // array.
- if (ret.ticks !== undefined) {
- xTicks = ret.ticks;
- this.numXDigits_ = ret.numDigits;
- } else {
- xTicks = ret;
- }
-
+ var xTicks = this.attr_('xTicker')(range[0], range[1], this);
this.layout_.updateOptions({xTicks: xTicks});
};
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 = Date.parse(date_str);
+ var t = Dygraph.dateStrToMillis(date_str);
if (t < start_time || t > end_time) continue;
ticks.push({ v:t, label: formatter(new Date(t), granularity) });
}
};
/**
- * Determine the number of significant figures in a Number up to the specified
- * precision. Note that there is no way to determine if a trailing '0' is
- * significant or not, so by convention we return 1 for all of the following
- * inputs: 1, 1.0, 1.00, 1.000 etc.
- * @param {Number} x The input value.
- * @param {Number} opt_maxPrecision Optional maximum precision to consider.
- * Default and maximum allowed value is 13.
- * @return {Number} The number of significant figures which is >= 1.
- */
-Dygraph.significantFigures = function(x, opt_maxPrecision) {
- var precision = Math.max(opt_maxPrecision || 13, 13);
-
- // Convert the number to its exponential notation form and work backwards,
- // ignoring the 'e+xx' bit. This may seem like a hack, but doing a loop and
- // dividing by 10 leads to roundoff errors. By using toExponential(), we let
- // the JavaScript interpreter handle the low level bits of the Number for us.
- var s = x.toExponential(precision);
- var ePos = s.lastIndexOf('e'); // -1 case handled by return below.
-
- for (var i = ePos - 1; i >= 0; i--) {
- if (s[i] == '.') {
- // Got to the decimal place. We'll call this 1 digit of precision because
- // we can't know for sure how many trailing 0s are significant.
- return 1;
- } else if (s[i] != '0') {
- // Found the first non-zero digit. Return the number of characters
- // except for the '.'.
- return i; // This is i - 1 + 1 (-1 is for '.', +1 is for 0 based index).
- }
- }
-
- // Occurs if toExponential() doesn't return a string containing 'e', which
- // should never happen.
- return 1;
-};
-
-/**
* Add ticks when the x axis has numbers on it (instead of dates)
* TODO(konigsberg): Update comment.
*
var formatter = attr('yAxisLabelFormatter') ?
attr('yAxisLabelFormatter') : attr('yValueFormatter');
- // Determine the number of decimal places needed for the labels below by
- // taking the maximum number of significant figures for any label. We must
- // take the max because we can't tell if trailing 0s are significant.
- var numDigits = 0;
- for (var i = 0; i < ticks.length; i++) {
- numDigits = Math.max(Dygraph.significantFigures(ticks[i].v), numDigits);
- }
-
// 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 !== undefined) ?
- formatter(tickV, numDigits) : tickV.toPrecision(numDigits);
+ 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 = formatter(tickV / n, numDigits) + k_labels[j];
+ label = Dygraph.round_(tickV / n, attr('digitsAfterDecimal')) + k_labels[j];
break;
}
}
ticks[i].label = label;
}
- return {ticks: ticks, numDigits: numDigits};
+ return ticks;
};
// Computes the range of the data series (including confidence intervals).
// Create a new plotter.
if (this.plotter_) this.plotter_.clear();
this.plotter_ = new DygraphCanvasRenderer(this,
- this.hidden_, this.layout_,
+ this.hidden_,
+ this.hidden_ctx_,
+ this.layout_,
this.renderOptions_);
// The roller sits in the bottom left corner of the chart. We don't know where
this.layout_.updateOptions( { yAxes: this.axes_,
seriesToAxisMap: this.seriesToAxisMap_
} );
-
this.addXTicks_();
+ // Save the X axis zoomed status as the updateOptions call will tend to set it errorneously
+ var tmp_zoomed_x = this.zoomed_x_;
// Tell PlotKit to use this new data and render itself
this.layout_.updateOptions({dateWindow: this.dateWindow_});
+ this.zoomed_x_ = tmp_zoomed_x;
this.layout_.evaluateWithError();
this.plotter_.clear();
this.plotter_.render();
if (is_initial_draw) {
// Generate a static legend before any particular point is selected.
- this.attr_('labelsDiv').innerHTML = this.generateLegendHTML_();
+ this.setLegendHTML_();
+ } else {
+ if (typeof(this.selPoints_) !== 'undefined' && this.selPoints_.length) {
+ this.lastx_ = this.selPoints_[0].xval;
+ this.updateSelection_();
+ } else {
+ this.clearSelection();
+ }
}
if (this.attr_("drawCallback") !== null) {
* indices are into the axes_ array.
*/
Dygraph.prototype.computeYAxes_ = function() {
+ var valueWindows;
+ if (this.axes_ != undefined) {
+ // Preserve valueWindow settings.
+ valueWindows = [];
+ for (var index = 0; index < this.axes_.length; index++) {
+ valueWindows.push(this.axes_[index].valueWindow);
+ }
+ }
+
this.axes_ = [{ yAxisId : 0, g : this }]; // always have at least one y-axis.
this.seriesToAxisMap_ = {};
if (vis[i - 1]) seriesToAxisFiltered[s] = this.seriesToAxisMap_[s];
}
this.seriesToAxisMap_ = seriesToAxisFiltered;
+
+ if (valueWindows != undefined) {
+ // Restore valueWindow settings.
+ for (var index = 0; index < valueWindows.length; index++) {
+ this.axes_[index].valueWindow = valueWindows[index];
+ }
+ }
};
/**
// Compute extreme values, a span and tick marks for each axis.
for (var i = 0; i < this.axes_.length; i++) {
var axis = this.axes_[i];
- if (axis.valueWindow) {
- // This is only set if the user has zoomed on the y-axis. It is never set
- // by a user. It takes precedence over axis.valueRange because, if you set
- // valueRange, you'd still expect to be able to pan.
- 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]];
+
+ if (!seriesForAxis[i]) {
+ // 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++) {
- minY = Math.min(extremes[series[j]][0], minY);
- maxY = Math.max(extremes[series[j]][1], maxY);
+ // Only use valid extremes to stop null data series' from corrupting the scale.
+ extremeMinY = extremes[series[j]][0];
+ if (extremeMinY != null) {
+ minY = Math.min(extremeMinY, minY);
+ }
+ extremeMaxY = extremes[series[j]][1];
+ 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.
+ 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 (minY > 0) minAxisY = 0;
}
}
-
- axis.computedValueRange = [minAxisY, maxAxisY];
+ axis.extremeRange = [minAxisY, maxAxisY];
+ }
+ if (axis.valueWindow) {
+ // This is only set if the user has zoomed on the y-axis. It is never set
+ // by a user. It takes precedence over axis.valueRange because, if you set
+ // valueRange, you'd still expect to be able to pan.
+ 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]];
+ } 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) {
- var ret =
+ axis.ticks =
Dygraph.numericTicks(axis.computedValueRange[0],
axis.computedValueRange[1],
this,
axis);
- axis.ticks = ret.ticks;
- this.numYDigits_ = ret.numDigits;
} else {
var p_axis = this.axes_[0];
var p_ticks = p_axis.ticks;
tick_values.push(y_val);
}
- var ret =
+ axis.ticks =
Dygraph.numericTicks(axis.computedValueRange[0],
axis.computedValueRange[1],
this, axis, tick_values);
- axis.ticks = ret.ticks;
- this.numYDigits_ = ret.numDigits;
}
}
};
while (dateStrSlashed.search("-") != -1) {
dateStrSlashed = dateStrSlashed.replace("-", "/");
}
- d = Date.parse(dateStrSlashed);
+ d = Dygraph.dateStrToMillis(dateStrSlashed);
} else if (dateStr.length == 8) { // e.g. '20090712'
// TODO(danvk): remove support for this format. It's confusing.
dateStrSlashed = dateStr.substr(0,4) + "/" + dateStr.substr(4,2)
+ "/" + dateStr.substr(6,2);
- d = Date.parse(dateStrSlashed);
+ d = Dygraph.dateStrToMillis(dateStrSlashed);
} else {
// Any format that Date.parse will accept, e.g. "2009/07/12" or
// "2009/07/12 12:34:56"
- d = Date.parse(dateStr);
+ d = Dygraph.dateStrToMillis(dateStr);
}
if (!d || isNaN(d)) {
this.attrs_.xTicker = Dygraph.dateTicker;
this.attrs_.xAxisLabelFormatter = Dygraph.dateAxisFormatter;
} else {
- this.attrs_.xValueFormatter = this.attrs_.yValueFormatter;
+ // TODO(danvk): use Dygraph.numberFormatter here?
+ 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;
} else if (this.attr_("customBars")) {
// Bars are a low;center;high tuple
for (var j = 1; j < inFields.length; j++) {
- var vals = inFields[j].split(";");
- fields[j] = [ this.parseFloat_(vals[0], i, line),
- this.parseFloat_(vals[1], i, line),
- this.parseFloat_(vals[2], i, line) ];
+ var val = inFields[j];
+ if (/^ *$/.test(val)) {
+ fields[j] = [null, null, null];
+ } else {
+ var 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));
+ }
+ }
}
} else {
// Values are just numbers
return parsedData;
} else {
// Some intelligent defaults for a numeric x-axis.
- this.attrs_.xValueFormatter = this.attrs_.yValueFormatter;
+ this.attrs_.xValueFormatter = function(x) { return x; };
this.attrs_.xTicker = Dygraph.numericTicks;
return data;
}
this.attrs_.xTicker = Dygraph.dateTicker;
this.attrs_.xAxisLabelFormatter = Dygraph.dateAxisFormatter;
} else if (indepType == 'number') {
- this.attrs_.xValueFormatter = this.attrs_.yValueFormatter;
+ 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;
annotations.push(ann);
}
}
+
+ // Strip out infinities, which give dygraphs problems later on.
+ for (var j = 0; j < row.length; j++) {
+ if (!isFinite(row[j])) row[j] = null;
+ }
} else {
for (var j = 0; j < cols - 1; j++) {
row.push([ data.getValue(i, 1 + 2 * j), data.getValue(i, 2 + 2 * j) ]);
if (ret.length > 0 && row[0] < ret[ret.length - 1][0]) {
outOfOrder = true;
}
-
- // Strip out infinities, which give dygraphs problems later on.
- for (var j = 0; j < row.length; j++) {
- if (!isFinite(row[j])) row[j] = null;
- }
ret.push(row);
}
}
}
+// This is identical to JavaScript's built-in Date.parse() method, except that
+// it doesn't get replaced with an incompatible method by aggressive JS
+// libraries like MooTools or Joomla.
+Dygraph.dateStrToMillis = function(str) {
+ return new Date(str).getTime();
+};
+
// These functions are all based on MochiKit.
Dygraph.update = function (self, o) {
if (typeof(o) != 'undefined' && o !== null) {
* <li>file: changes the source data for the graph</li>
* <li>errorBars: changes whether the data contains stddev</li>
* </ul>
+ *
* @param {Object} attrs The new properties and values
*/
Dygraph.prototype.updateOptions = function(attrs) {
}
if ('dateWindow' in attrs) {
this.dateWindow_ = attrs.dateWindow;
+ if (!('isZoomedIgnoreProgrammaticZoom' in attrs)) {
+ this.zoomed_x_ = attrs.dateWindow != null;
+ }
+ }
+ if ('valueRange' in attrs && !('isZoomedIgnoreProgrammaticZoom' in attrs)) {
+ this.zoomed_y_ = attrs.valueRange != null;
}
// TODO(danvk): validate per-series options.
// <REMOVE_FOR_COMBINED>
Dygraph.OPTIONS_REFERENCE = // <JSON>
{
- "includeZero": {
- "type": "boolean",
+ "xValueParser": {
+ "default": "parseFloat() or Date.parse()*",
+ "labels": ["CSV parsing"],
+ "type": "function(str) -> number",
+ "description": "A function which parses x-values (i.e. the dependent series). Must return a number, even when the values are dates. In this case, millis since epoch are used. This is used primarily for parsing CSV data. *=Dygraphs is slightly more accepting in the dates which it will parse. See code for details."
+ },
+ "stackedGraph": {
"default": "false",
- "description": "Usually, dygraphs will use the range of the data plus some padding to set the range of the y-axis. If this option is set, the y-axis will always include zero, typically as the lowest value. This can be used to avoid exaggerating the variance in the data"
+ "labels": ["Data Line display"],
+ "type": "boolean",
+ "description": "If set, stack series on top of one another rather than drawing them independently."
},
- "rollPeriod": {
- "type": "integer >= 1",
+ "pointSize": {
"default": "1",
- "description": "Number of days over which to average data. Discussed extensively above."
+ "labels": ["Data Line display"],
+ "type": "integer",
+ "description": "The size of the dot to draw on each point in pixels (see drawPoints). A dot is always drawn when a point is \"isolated\", i.e. there is a missing point on either side of it. This also controls the size of those dots."
},
- "showRoller": {
- "type": "boolean",
+ "labelsDivStyles": {
+ "default": "null",
+ "labels": ["Legend"],
+ "type": "{}",
+ "description": "Additional styles to apply to the currently-highlighted points div. For example, { 'font-weight': 'bold' } will make the labels bold."
+ },
+ "drawPoints": {
"default": "false",
- "description": "If the rolling average period text box should be shown."
+ "labels": ["Data Line display"],
+ "type": "boolean",
+ "description": "Draw a small dot at each point, in addition to a line going through the point. This makes the individual data points easier to see, but can increase visual clutter in the chart."
+ },
+ "height": {
+ "default": "320",
+ "labels": ["Overall display"],
+ "type": "integer",
+ "description": "Height, in pixels, of the chart. If the container div has been explicitly sized, this will be ignored."
+ },
+ "zoomCallback": {
+ "default": "null",
+ "labels": ["Callbacks"],
+ "type": "function(minDate, maxDate, yRanges)",
+ "description": "A function to call when the zoom window is changed (either by zooming in or out). minDate and maxDate are milliseconds since epoch. yRanges is an array of [bottom, top] pairs, one for each y-axis."
+ },
+ "pointClickCallback": {
+ "default": "",
+ "labels": ["Callbacks", "Interactive Elements"],
+ "type": "",
+ "description": ""
},
"colors": {
- "example": "['red', '#00FF00']",
- "type": "array<string>",
"default": "(see description)",
+ "labels": ["Data Series Colors"],
+ "type": "array<string>",
+ "example": "['red', '#00FF00']",
"description": "List of colors for the data series. These can be of the form \"#AABBCC\" or \"rgb(255,100,200)\" or \"yellow\", etc. If not specified, equally-spaced points around a color wheel are used."
},
- "fillGraph": {
- "type": "boolean",
+ "connectSeparatedPoints": {
"default": "false",
- "description": "Should the area underneath the graph be filled? This option is not compatible with error bars."
- },
- "visibility": {
- "type": "Array of booleans",
- "default": "[true, true, ...]",
- "description": "Which series should initially be visible? Once the Dygraph has been constructed, you can access and modify the visibility of each series using the <code>visibility</code> and <code>setVisibility</code> methods."
- },
- "colorSaturation": {
- "type": "0.0 - 1.0",
- "default": "1.0",
- "description": "If <strong>colors</strong> is not specified, saturation of the automatically-generated data series colors."
- },
- "colorValue": {
- "type": "float (0.0 - 1.0)",
- "default": "1.0",
- "description": "If colors is not specified, value of the data series colors, as in hue/saturation/value. (0.0-1.0, default 0.5)"
+ "labels": ["Data Line display"],
+ "type": "boolean",
+ "description": "Usually, when Dygraphs encounters a missing value in a data series, it interprets this as a gap and draws it as such. If, instead, the missing values represents an x-value for which only a different series has data, then you'll want to connect the dots by setting this to true. To explicitly include a gap with this option set, use a value of NaN."
},
- "clickCallback": {
- "type": "function(e, date)",
- "snippet": "function(e, date){<br> alert(date);<br>}",
+ "highlightCallback": {
"default": "null",
- "description": "A function to call when a data point is clicked. The function should take two arguments, the event object for the click and the date that was clicked."
+ "labels": ["Callbacks"],
+ "type": "function(event, x, points,row)",
+ "description": "When set, this callback gets called every time a new point is highlighted. The parameters are the JavaScript mousemove event, the x-coordinate of the highlighted points and an array of highlighted points: <code>[ {name: 'series', yval: y-value}, … ]</code>"
},
- "zoomCallback": {
- "type": "function(minDate, maxDate, yRanges)",
- "default": "null",
- "description": "A function to call when the zoom window is changed (either by zooming in or out). minDate and maxDate are milliseconds since epoch. yRanges is an array of [bottom, top] pairs, one for each y-axis."
+ "includeZero": {
+ "default": "false",
+ "labels": ["Axis display"],
+ "type": "boolean",
+ "description": "Usually, dygraphs will use the range of the data plus some padding to set the range of the y-axis. If this option is set, the y-axis will always include zero, typically as the lowest value. This can be used to avoid exaggerating the variance in the data"
},
- "strokeWidth": {
- "type": "integer",
- "example": "0.5, 2.0",
- "default": "1.0",
- "description": "The width of the lines connecting data points. This can be used to increase the contrast or some graphs."
+ "rollPeriod": {
+ "default": "1",
+ "labels": ["Error Bars", "Rolling Averages"],
+ "type": "integer >= 1",
+ "description": "Number of days over which to average data. Discussed extensively above."
},
- "dateWindow": {
- "type": "Array of two Dates or numbers",
- "example": "[<br> Date.parse('2006-01-01'),<br> (new Date()).valueOf()<br>]",
- "default": "Full range of the input is shown",
- "description": "Initially zoom in on a section of the graph. Is of the form [earliest, latest], where earliest/latest are milliseconds since epoch. If the data for the x-axis is numeric, the values in dateWindow must also be numbers."
+ "unhighlightCallback": {
+ "default": "null",
+ "labels": ["Callbacks"],
+ "type": "function(event)",
+ "description": "When set, this callback gets called every time the user stops highlighting any point by mousing out of the graph. The parameter is the mouseout event."
},
- "valueRange": {
- "type": "Array of two numbers",
- "example": "[10, 110]",
- "default": "Full range of the input is shown",
- "description": "Explicitly set the vertical range of the graph to [low, high]."
+ "axisTickSize": {
+ "default": "3.0",
+ "labels": ["Axis display"],
+ "type": "number",
+ "description": "The size of the line to display next to each tick mark on x- or y-axes."
},
"labelsSeparateLines": {
- "type": "boolean",
"default": "false",
+ "labels": ["Legend"],
+ "type": "boolean",
"description": "Put <code><br/></code> between lines in the label string. Often used in conjunction with <strong>labelsDiv</strong>."
},
- "labelsDiv": {
- "type": "DOM element or string",
- "example": "<code style='font-size: small'>document.getElementById('foo')</code>or<code>'foo'",
+ "xValueFormatter": {
+ "default": "(Round to 2 decimal places)",
+ "labels": ["Axis display"],
+ "type": "function(x)",
+ "description": "Function to provide a custom display format for the X value for mouseover."
+ },
+ "pixelsPerYLabel": {
+ "default": "30",
+ "labels": ["Axis display", "Grid"],
+ "type": "integer",
+ "description": "Number of pixels to require between each x- and y-label. Larger values will yield a sparser axis with fewer ticks."
+ },
+ "annotationMouseOverHandler": {
"default": "null",
- "description": "Show data labels in an external div, rather than on the graph. This value can either be a div element or a div id."
+ "labels": ["Annotations"],
+ "type": "function(annotation, point, dygraph, event)",
+ "description": "If provided, this function is called whenever the user mouses over an annotation."
},
- "labelsShowZeroValues": {
- "type": "boolean",
- "default": "true",
- "description": "Show zero value labels in the labelsDiv."
+ "annotationMouseOutHandler": {
+ "default": "null",
+ "labels": ["Annotations"],
+ "type": "function(annotation, point, dygraph, event)",
+ "description": "If provided, this function is called whenever the user mouses out of an annotation."
},
- "labelsKMB": {
- "type": "boolean",
- "default": "false",
- "description": "Show K/M/B for thousands/millions/billions on y-axis."
+ "annotationClickHandler": {
+ "default": "null",
+ "labels": ["Annotations"],
+ "type": "function(annotation, point, dygraph, event)",
+ "description": "If provided, this function is called whenever the user clicks on an annotation."
+ },
+ "annotationDblClickHandler": {
+ "default": "null",
+ "labels": ["Annotations"],
+ "type": "function(annotation, point, dygraph, event)",
+ "description": "If provided, this function is called whenever the user double-clicks on an annotation."
+ },
+ "drawCallback": {
+ "default": "null",
+ "labels": ["Callbacks"],
+ "type": "function(dygraph, is_initial)",
+ "description": "When set, this callback gets called every time the dygraph is drawn. This includes the initial draw, after zooming and repeatedly while panning. The first parameter is the dygraph being drawn. The second is a boolean value indicating whether this is the initial draw."
},
"labelsKMG2": {
- "type": "boolean",
"default": "false",
+ "labels": ["Value display/formatting"],
+ "type": "boolean",
"description": "Show k/M/G for kilo/Mega/Giga on y-axis. This is different than <code>labelsKMB</code> in that it uses base 2, not 10."
},
- "labelsDivWidth": {
- "type": "integer",
- "default": "250",
- "description": "Width (in pixels) of the div which shows information on the currently-highlighted points."
- },
- "labelsDivStyles": {
- "type": "{}",
- "default": "null",
- "description": "Additional styles to apply to the currently-highlighted points div. For example, { 'font-weight': 'bold' } will make the labels bold."
+ "delimiter": {
+ "default": ",",
+ "labels": ["CSV parsing"],
+ "type": "string",
+ "description": "The delimiter to look for when separating fields of a CSV file. Setting this to a tab is not usually necessary, since tab-delimited data is auto-detected."
},
- "highlightCircleSize": {
+ "axisLabelFontSize": {
+ "default": "14",
+ "labels": ["Axis display"],
"type": "integer",
- "default": "3",
- "description": "The size in pixels of the dot drawn over highlighted points."
+ "description": "Size of the font (in pixels) to use in the axis labels, both x- and y-axis."
},
- "drawPoints": {
- "type": "boolean",
- "default": "false",
- "description": "Draw a small dot at each point, in addition to a line going through the point. This makes the individual data points easier to see, but can increase visual clutter in the chart."
+ "underlayCallback": {
+ "default": "null",
+ "labels": ["Callbacks"],
+ "type": "function(canvas, area, dygraph)",
+ "description": "When set, this callback gets called before the chart is drawn. It details on how to use this."
},
- "pointSize": {
+ "width": {
+ "default": "480",
+ "labels": ["Overall display"],
"type": "integer",
- "default": "1",
- "description": "The size of the dot to draw on each point in pixels (see drawPoints). A dot is always drawn when a point is \"isolated\", i.e. there is a missing point on either side of it. This also controls the size of those dots."
+ "description": "Width, in pixels, of the chart. If the container div has been explicitly sized, this will be ignored."
},
- "pixelsPerXLabel": {
- "type": "integer",
- "default": "60",
- "description": "Number of pixels to require between each x- and y-label. Larger values will yield a sparser axis with fewer ticks."
+ "interactionModel": {
+ "default": "...",
+ "labels": ["Interactive Elements"],
+ "type": "Object",
+ "description": "TODO(konigsberg): document this"
},
- "pixelsPerYLabel": {
- "type": "integer",
- "default": "30",
- "description": "Number of pixels to require between each x- and y-label. Larger values will yield a sparser axis with fewer ticks."
+ "xTicker": {
+ "default": "Dygraph.dateTicker or Dygraph.numericTicks",
+ "labels": ["Axis display"],
+ "type": "function(min, max, dygraph) -> [{v: ..., label: ...}, ...]",
+ "description": "This lets you specify an arbitrary function to generate tick marks on an axis. The tick marks are an array of (value, label) pairs. The built-in functions go to great lengths to choose good tick marks so, if you set this option, you'll most likely want to call one of them and modify the result."
},
"xAxisLabelWidth": {
- "type": "integer",
"default": "50",
- "description": "Width, in pixels, of the x-axis labels."
- },
- "yAxisLabelWidth": {
+ "labels": ["Axis display"],
"type": "integer",
- "default": "50",
- "description": "Width, in pixels, of the y-axis labels."
- },
- "axisLabelFontSize": {
- "type": "integer",
- "default": "14",
- "description": "Size of the font (in pixels) to use in the axis labels, both x- and y-axis."
+ "description": "Width, in pixels, of the x-axis labels."
},
- "xAxisLabelFormatter": {
- "type": "function(date, granularity)",
- "default": "Dygraph.dateAxisFormatter",
- "description": "Function to call to format values along the x axis."
+ "showLabelsOnHighlight": {
+ "default": "true",
+ "labels": ["Interactive Elements", "Legend"],
+ "type": "boolean",
+ "description": "Whether to show the legend upon mouseover."
},
- "yAxisLabelFormatter": {
- "type": "function(x)",
- "default": "yValueFormatter",
- "description": "Function used to format values along the Y axis. By default it uses the same as the <code>yValueFormatter</code> unless specified."
+ "axis": {
+ "default": "(none)",
+ "labels": ["Axis display"],
+ "type": "string or object",
+ "description": "Set to either an object ({}) filled with options for this axis or to the name of an existing data series with its own axis to re-use that axis. See tests for usage."
},
- "rightGap": {
+ "pixelsPerXLabel": {
+ "default": "60",
+ "labels": ["Axis display", "Grid"],
"type": "integer",
- "default": "5",
- "description": "Number of pixels to leave blank at the right edge of the Dygraph. This makes it easier to highlight the right-most data point."
- },
- "errorBars": {
- "type": "boolean",
- "default": "false",
- "description": "Does the data contain standard deviations? Setting this to true alters the input format (see above)."
+ "description": "Number of pixels to require between each x- and y-label. Larger values will yield a sparser axis with fewer ticks."
},
- "sigma": {
- "type": "integer",
- "default": "2.0",
- "description": "When errorBars is set, shade this many standard deviations above/below each point."
+ "labelsDiv": {
+ "default": "null",
+ "labels": ["Legend"],
+ "type": "DOM element or string",
+ "example": "<code style='font-size: small'>document.getElementById('foo')</code>or<code>'foo'",
+ "description": "Show data labels in an external div, rather than on the graph. This value can either be a div element or a div id."
},
"fractions": {
- "type": "boolean",
"default": "false",
+ "labels": ["CSV parsing", "Error Bars"],
+ "type": "boolean",
"description": "When set, attempt to parse each cell in the CSV file as \"a/b\", where a and b are integers. The ratio will be plotted. This allows computation of Wilson confidence intervals (see below)."
},
- "wilsonInterval": {
+ "logscale": {
+ "default": "false",
+ "labels": ["Axis display"],
"type": "boolean",
+ "description": "When set for a y-axis, the graph shows that axis in log scale. Any values less than or equal to zero are not displayed.\n\nNot compatible with showZero, and ignores connectSeparatedPoints. Also, showing log scale with valueRanges that are less than zero will result in an unviewable graph."
+ },
+ "strokeWidth": {
+ "default": "1.0",
+ "labels": ["Data Line display"],
+ "type": "integer",
+ "example": "0.5, 2.0",
+ "description": "The width of the lines connecting data points. This can be used to increase the contrast or some graphs."
+ },
+ "wilsonInterval": {
"default": "true",
+ "labels": ["Error Bars"],
+ "type": "boolean",
"description": "Use in conjunction with the \"fractions\" option. Instead of plotting +/- N standard deviations, dygraphs will compute a Wilson confidence interval and plot that. This has more reasonable behavior for ratios close to 0 or 1."
},
- "customBars": {
- "type": "boolean",
+ "fillGraph": {
"default": "false",
- "description": "When set, parse each CSV cell as \"low;middle;high\". Error bars will be drawn for each point between low and high, with the series itself going through middle."
+ "labels": ["Data Line display"],
+ "type": "boolean",
+ "description": "Should the area underneath the graph be filled? This option is not compatible with error bars."
},
- "drawCallback": {
- "type": "function(dygraph, is_initial)",
- "default": "null",
- "description": "When set, this callback gets called every time the dygraph is drawn. This includes the initial draw, after zooming and repeatedly while panning. The first parameter is the dygraph being drawn. The second is a boolean value indicating whether this is the initial draw."
+ "highlightCircleSize": {
+ "default": "3",
+ "labels": ["Interactive Elements"],
+ "type": "integer",
+ "description": "The size in pixels of the dot drawn over highlighted points."
},
"gridLineColor": {
- "type": "red, blue",
"default": "rgb(128,128,128)",
+ "labels": ["Grid"],
+ "type": "red, blue",
"description": "The color of the gridlines."
},
- "highlightCallback": {
- "type": "function(event, x, points,row)",
- "default": "null",
- "description": "When set, this callback gets called every time a new point is highlighted. The parameters are the JavaScript mousemove event, the x-coordinate of the highlighted points and an array of highlighted points: <code>[ {name: 'series', yval: y-value}, … ]</code>"
- },
- "unhighlightCallback": {
- "type": "function(event)",
- "default": "null",
- "description": "When set, this callback gets called every time the user stops highlighting any point by mousing out of the graph. The parameter is the mouseout event."
+ "visibility": {
+ "default": "[true, true, ...]",
+ "labels": ["Data Line display"],
+ "type": "Array of booleans",
+ "description": "Which series should initially be visible? Once the Dygraph has been constructed, you can access and modify the visibility of each series using the <code>visibility</code> and <code>setVisibility</code> methods."
},
- "underlayCallback": {
- "type": "function(canvas, area, dygraph)",
- "default": "null",
- "description": "When set, this callback gets called before the chart is drawn. It details on how to use this."
+ "valueRange": {
+ "default": "Full range of the input is shown",
+ "labels": ["Axis display"],
+ "type": "Array of two numbers",
+ "example": "[10, 110]",
+ "description": "Explicitly set the vertical range of the graph to [low, high]."
},
- "width": {
+ "labelsDivWidth": {
+ "default": "250",
+ "labels": ["Legend"],
"type": "integer",
- "default": "480",
- "description": "Width, in pixels, of the chart. If the container div has been explicitly sized, this will be ignored."
+ "description": "Width (in pixels) of the div which shows information on the currently-highlighted points."
},
- "height": {
+ "colorSaturation": {
+ "default": "1.0",
+ "labels": ["Data Series Colors"],
+ "type": "0.0 - 1.0",
+ "description": "If <strong>colors</strong> is not specified, saturation of the automatically-generated data series colors."
+ },
+ "yAxisLabelWidth": {
+ "default": "50",
+ "labels": ["Axis display"],
"type": "integer",
- "default": "320",
- "description": "Height, in pixels, of the chart. If the container div has been explicitly sized, this will be ignored."
+ "description": "Width, in pixels, of the y-axis labels."
},
- "stepPlot": {
+ "hideOverlayOnMouseOut": {
+ "default": "true",
+ "labels": ["Interactive Elements", "Legend"],
"type": "boolean",
- "default": "false",
- "description": "When set, display the graph as a step plot instead of a line plot."
- },
- "xValueFormatter": {
- "type": "function(x)",
- "default": "(Round to 2 decimal places)",
- "description": "Function to provide a custom display format for the X value for mouseover."
+ "description": "Whether to hide the legend when the mouse leaves the chart area."
},
"yValueFormatter": {
- "type": "function(x)",
"default": "(Round to 2 decimal places)",
+ "labels": ["Axis display"],
+ "type": "function(x)",
"description": "Function to provide a custom display format for the Y value for mouseover."
},
- "avoidMinZero": {
+ "legend": {
+ "default": "onmouseover",
+ "labels": ["Legend"],
+ "type": "string",
+ "description": "When to display the legend. By default, it only appears when a user mouses over the chart. Set it to \"always\" to always display a legend of some sort."
+ },
+ "labelsShowZeroValues": {
+ "default": "true",
+ "labels": ["Legend"],
"type": "boolean",
+ "description": "Show zero value labels in the labelsDiv."
+ },
+ "stepPlot": {
"default": "false",
- "description": "When set, the heuristic that fixes the Y axis at zero for a data set with the minimum Y value of zero is disabled. \nThis is particularly useful for data sets that contain many zero values, especially for step plots which may otherwise have lines not visible running along the bottom axis."
+ "labels": ["Data Line display"],
+ "type": "boolean",
+ "description": "When set, display the graph as a step plot instead of a line plot."
},
- "logscale": {
+ "labelsKMB": {
+ "default": "false",
+ "labels": ["Value display/formatting"],
"type": "boolean",
+ "description": "Show K/M/B for thousands/millions/billions on y-axis."
+ },
+ "rightGap": {
+ "default": "5",
+ "labels": ["Overall display"],
+ "type": "integer",
+ "description": "Number of pixels to leave blank at the right edge of the Dygraph. This makes it easier to highlight the right-most data point."
+ },
+ "avoidMinZero": {
"default": "false",
- "description": "When set for a y-axis, the graph shows that axis in y-scale. Any values less than or equal to zero are not displayed.\n\nNot compatible with showZero, and ignores connectSeparatedPoints. Also, showing log scale with valueRanges that are less than zero will result in an unviewable graph."
+ "labels": ["Axis display"],
+ "type": "boolean",
+ "description": "When set, the heuristic that fixes the Y axis at zero for a data set with the minimum Y value of zero is disabled. \nThis is particularly useful for data sets that contain many zero values, especially for step plots which may otherwise have lines not visible running along the bottom axis."
+ },
+ "xAxisLabelFormatter": {
+ "default": "Dygraph.dateAxisFormatter",
+ "labels": ["Axis display", "Value display/formatting"],
+ "type": "function(date, granularity)",
+ "description": "Function to call to format values along the x axis."
+ },
+ "clickCallback": {
+ "snippet": "function(e, date){<br> alert(date);<br>}",
+ "default": "null",
+ "labels": ["Callbacks"],
+ "type": "function(e, date)",
+ "description": "A function to call when a data point is clicked. The function should take two arguments, the event object for the click and the date that was clicked."
+ },
+ "yAxisLabelFormatter": {
+ "default": "yValueFormatter",
+ "labels": ["Axis display", "Value display/formatting"],
+ "type": "function(x)",
+ "description": "Function used to format values along the Y axis. By default it uses the same as the <code>yValueFormatter</code> unless specified."
},
"labels": {
- "type": "array<string>",
"default": "[\"X\", \"Y1\", \"Y2\", ...]*",
+ "labels": ["Legend"],
+ "type": "array<string>",
"description": "A name for each data series, including the independent (X) series. For CSV files and DataTable objections, this is determined by context. For raw data, this must be specified. If it is not, default values are supplied and a warning is logged."
},
- "interactionModel": {
- "type": "Object",
- "default": "...",
- "description": "TODO(konigsberg): document this"
+ "dateWindow": {
+ "default": "Full range of the input is shown",
+ "labels": ["Axis display"],
+ "type": "Array of two Dates or numbers",
+ "example": "[<br> Date.parse('2006-01-01'),<br> (new Date()).valueOf()<br>]",
+ "description": "Initially zoom in on a section of the graph. Is of the form [earliest, latest], where earliest/latest are milliseconds since epoch. If the data for the x-axis is numeric, the values in dateWindow must also be numbers."
},
- "delimiter": {
- "type": "string",
- "default": ",",
- "description": "The delimiter to look for when separating fields of a CSV file. Setting this to a tab is not usually necessary, since tab-delimited data is auto-detected."
+ "showRoller": {
+ "default": "false",
+ "labels": ["Interactive Elements", "Rolling Averages"],
+ "type": "boolean",
+ "description": "If the rolling average period text box should be shown."
},
- "xValueParser": {
- "type": "function(str) -> number",
- "default": "parseFloat() or Date.parse()*",
- "description": "A function which parses x-values (i.e. the dependent series). Must return a number, even when the values are dates. In this case, millis since epoch are used. This is used primarily for parsing CSV data. *=Dygraphs is slightly more accepting in the dates which it will parse. See code for details."
+ "sigma": {
+ "default": "2.0",
+ "labels": ["Error Bars"],
+ "type": "float",
+ "description": "When errorBars is set, shade this many standard deviations above/below each point."
},
- "axisTickSize": {
- "type": "number",
- "default": "3.0",
- "description": "The size of the line to display next to each tick mark on x- or y-axes."
+ "customBars": {
+ "default": "false",
+ "labels": ["CSV parsing", "Error Bars"],
+ "type": "boolean",
+ "description": "When set, parse each CSV cell as \"low;middle;high\". Error bars will be drawn for each point between low and high, with the series itself going through middle."
},
- "axis": {
- "type": "string or object",
- "default": "(none)",
- "description": "Set to either an object ({}) filled with options for this axis or to the name of an existing data series with its own axis to re-use that axis. See tests for usage."
+ "colorValue": {
+ "default": "1.0",
+ "labels": ["Data Series Colors"],
+ "type": "float (0.0 - 1.0)",
+ "description": "If colors is not specified, value of the data series colors, as in hue/saturation/value. (0.0-1.0, default 0.5)"
},
- "connectSeparatedPoints": {
- "type": "boolean",
+ "errorBars": {
"default": "false",
- "description": "Usually, when Dygraphs encounters a missing value in a data series, it interprets this as a gap and draws it as such. If, instead, the missing values represents an x-value for which only a different series has data, then you'll want to connect the dots by setting this to true. To explicitly include a gap with this option set, use a value of NaN."
- },
- "stackedGraph": {
+ "labels": ["CSV parsing", "Error Bars"],
"type": "boolean",
+ "description": "Does the data contain standard deviations? Setting this to true alters the input format (see above)."
+ },
+ "displayAnnotations": {
"default": "false",
- "description": "If set, stack series on top of one another rather than drawing them independently."
+ "labels": ["Annotations"],
+ "type": "boolean",
+ "description": "Only applies when Dygraphs is used as a GViz chart. Causes string columns following a data series to be interpreted as annotations on points in that series. This is the same format used by Google's AnnotatedTimeLine chart."
},
- "xTicker": {
- "type": "function(min, max, dygraph) -> [{v: ..., label: ...}, ...]",
- "default": "Dygraph.dateTicker or Dygraph.numericTicks",
- "description": "This lets you specify an arbitrary function to generate tick marks on an axis. The tick marks are an array of (value, label) pairs. The built-in functions go to great lengths to choose good tick marks so, if you set this option, you'll most likely want to call one of them and modify the result."
+ "panEdgeFraction": {
+ "default": "null",
+ "labels": ["Axis Display", "Interactive Elements"],
+ "type": "float",
+ "default": "null",
+ "description": "A value representing the farthest a graph may be panned, in percent of the display. For example, a value of 0.1 means that the graph can only be panned 10% pased the edges of the displayed values. null means no bounds."
},
- "legend": {
+ "title": {
+ "labels": ["Chart labels"],
"type": "string",
- "default": "onmouseover",
- "description": "When to display the legend. By default, it only appears when a user mouses over the chart. Set it to \"always\" to always display a legend of some sort."
+ "default": "null",
+ "description": "Text to display above the chart. You can supply any HTML for this value, not just text. If you wish to style it using CSS, use the 'dygraph-label' or 'dygraph-title' classes."
},
- "showLabelsOnHighlight": {
- "type": "boolean",
- "default": "true",
- "description": "Whether to show the legend upon mouseover."
+ "titleHeight": {
+ "default": "18",
+ "labels": ["Chart labels"],
+ "type": "integer",
+ "description": "Height of the chart title, in pixels. This also controls the default font size of the title. If you style the title on your own, this controls how much space is set aside above the chart for the title's div."
},
- "hideOverlayOnMouseOut": {
+ "xlabel": {
+ "labels": ["Chart labels"],
+ "type": "string",
+ "default": "null",
+ "description": "Text to display below the chart's x-axis. You can supply any HTML for this value, not just text. If you wish to style it using CSS, use the 'dygraph-label' or 'dygraph-xlabel' classes."
+ },
+ "xLabelHeight": {
+ "labels": ["Chart labels"],
+ "type": "integer",
+ "default": "18",
+ "description": "Height of the x-axis label, in pixels. This also controls the default font size of the x-axis label. If you style the label on your own, this controls how much space is set aside below the chart for the x-axis label's div."
+ },
+ "ylabel": {
+ "labels": ["Chart labels"],
+ "type": "string",
+ "default": "null",
+ "description": "Text to display to the left of the chart's y-axis. You can supply any HTML for this value, not just text. If you wish to style it using CSS, use the 'dygraph-label' or 'dygraph-ylabel' classes. The text will be rotated 90 degrees by default, so CSS rules may behave in unintuitive ways. No additional space is set aside for a y-axis label. If you need more space, increase the width of the y-axis tick labels using the yAxisLabelWidth option. If you need a wider div for the y-axis label, either style it that way with CSS (but remember that it's rotated, so width is controlled by the 'height' property) or set the yLabelWidth option."
+ },
+ "yLabelWidth": {
+ "labels": ["Chart labels"],
+ "type": "integer",
+ "default": "18",
+ "description": "Width of the div which contains the y-axis label. Since the y-axis label appears rotated 90 degrees, this actually affects the height of its div."
+ },
+ "isZoomedIgnoreProgrammaticZoom" : {
+ "default": "false",
+ "labels": ["Zooming"],
"type": "boolean",
- "default": "true",
- "description": "Whether to hide the legend when the mouse leaves the chart area."
+ "description" : "When this option is passed to updateOptions() along with either the <code>dateWindow</code> or <code>valueRange</code> options, the zoom flags are not changed to reflect a zoomed state. This is primarily useful for when the display area of a chart is changed programmatically and also where manual zooming is allowed and use is made of the <code>isZoomed</code> method to determine this."
},
- "pointClickCallback": {
- "type": "",
- "default": "",
- "description": ""
+ "sigFigs" : {
+ "default": "null",
+ "labels": ["Value display/formatting"],
+ "type": "integer",
+ "description": "By default, dygraphs displays numbers with a fixed number of digits after the decimal point. If you'd prefer to have a fixed number of significant figures, set this option to that number of sig figs. A value of 2, for instance, would cause 1 to be display as 1.0 and 1234 to be displayed as 1.23e+3."
},
- "annotationMouseOverHandler": {
- "type": "",
- "default": "",
- "description": ""
+ "digitsAfterDecimal" : {
+ "default": "2",
+ "labels": ["Value display/formatting"],
+ "type": "integer",
+ "description": "Unless it's run in scientific mode (see the <code>sigFigs</code> option), dygraphs displays numbers with <code>digitsAfterDecimal</code> digits after the decimal point. Trailing zeros are not displayed, so with a value of 2 you'll get '0', '0.1', '0.12', '123.45' but not '123.456' (it will be rounded to '123.46'). Numbers with absolute value less than 0.1^digitsAfterDecimal (i.e. those which would show up as '0.00') will be displayed in scientific notation."
},
- "annotationMouseOutHandler": {
- "type": "",
- "default": "",
- "description": ""
+ "maxNumberWidth" : {
+ "default": "6",
+ "labels": ["Value display/formatting"],
+ "type": "integer",
+ "description": "When displaying numbers in normal (not scientific) mode, large numbers will be displayed with many trailing zeros (e.g. 100000000 instead of 1e9). This can lead to unwieldy y-axis labels. If there are more than <code>maxNumberWidth</code> digits to the left of the decimal in a number, dygraphs will switch to scientific notation, even when not operating in scientific mode. If you'd like to see all those digits, set this to something large, like 20 or 30."
}
}
; // </JSON>
// NOTE: in addition to parsing as JS, this snippet is expected to be valid
// JSON. This assumption cannot be checked in JS, but it will be checked when
-// documentation is generated by the generate-documentation.py script.
+// documentation is generated by the generate-documentation.py script. For the
+// most part, this just means that you should always use double quotes.
// Do a quick sanity check on the options reference.
(function() {
var warn = function(msg) { if (console) console.warn(msg); };
var flds = ['type', 'default', 'description'];
+ var valid_cats = [
+ 'Annotations',
+ 'Axis display',
+ 'Chart labels',
+ 'CSV parsing',
+ 'Callbacks',
+ 'Data Line display',
+ 'Data Series Colors',
+ 'Error Bars',
+ 'Grid',
+ 'Interactive Elements',
+ 'Legend',
+ 'Overall display',
+ 'Rolling Averages',
+ 'Value display/formatting',
+ 'Zooming'
+ ];
+ var cats = {};
+ for (var i = 0; i < valid_cats.length; i++) cats[valid_cats[i]] = true;
+
for (var k in Dygraph.OPTIONS_REFERENCE) {
if (!Dygraph.OPTIONS_REFERENCE.hasOwnProperty(k)) continue;
var op = Dygraph.OPTIONS_REFERENCE[k];
warn(k + '.' + flds[i] + ' must be of type string');
}
}
+ var labels = op['labels'];
+ if (typeof(labels) !== 'object') {
+ warn('Option "' + k + '" is missing a "labels": [...] option');
+ for (var i = 0; i < labels.length; i++) {
+ if (!cats.hasOwnProperty(labels[i])) {
+ warn('Option "' + k + '" has label "' + labels[i] +
+ '", which is invalid.');
+ }
+ }
+ }
}
})();
// </REMOVE_FOR_COMBINED>
projects / dygraphs.git / blobdiff