*/
/**
- * An interactive, zoomable graph
- * @param {String | Function} file A file containing CSV data or a function that
- * returns this data. The expected format for each line is
- * YYYYMMDD,val1,val2,... or, if attrs.errorBars is set,
- * YYYYMMDD,val1,stddev1,val2,stddev2,...
+ * Creates an interactive, zoomable chart.
+ *
+ * @constructor
+ * @param {div | String} div A div or the id of a div into which to construct
+ * the chart.
+ * @param {String | Function} file A file containing CSV data or a function
+ * that returns this data. The most basic expected format for each line is
+ * "YYYY/MM/DD,val1,val2,...". For more information, see
+ * http://dygraphs.com/data.html.
* @param {Object} attrs Various other attributes, e.g. errorBars determines
- * whether the input data contains error ranges.
+ * 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) {
Dygraph.__repr__ = function() {
return "[" + this.NAME + " " + this.VERSION + "]";
};
+
+/**
+ * Returns information about the Dygraph class.
+ */
Dygraph.toString = function() {
return this.__repr__();
};
Dygraph.DEFAULT_ROLL_PERIOD = 1;
Dygraph.DEFAULT_WIDTH = 480;
Dygraph.DEFAULT_HEIGHT = 320;
-Dygraph.AXIS_LINE_WIDTH = 0.3;
Dygraph.LOG_SCALE = 10;
Dygraph.LN_TEN = Math.log(Dygraph.LOG_SCALE);
+/** @private */
Dygraph.log10 = function(x) {
return Math.log(x) / Dygraph.LN_TEN;
}
xLabelHeight: 18,
yLabelWidth: 18,
- interactionModel: null // will be set to Dygraph.defaultInteractionModel.
+ drawXAxis: true,
+ drawYAxis: true,
+ axisLineColor: "black",
+ axisLineWidth: 0.3,
+ gridLineWidth: 0.3,
+ axisLabelColor: "black",
+ axisLabelFont: "Arial", // TODO(danvk): is this implemented?
+ axisLabelWidth: 50,
+ drawYGrid: true,
+ drawXGrid: true,
+ gridLineColor: "rgb(128,128,128)",
+
+ interactionModel: null // will be set to Dygraph.Interaction.defaultModel
};
// Various logging levels.
// Used for initializing annotation CSS rules only once.
Dygraph.addedAnnotationCSS = false;
+/**
+ * @private
+ * 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.boundaryIds_ = [];
- // Make a note of whether labels will be pulled from the CSV file.
- this.labelsFromCSV_ = (this.attr_("labels") == null);
-
// Create the containing DIV and other interactive elements
this.createInterface_();
throw "axis parameter to Dygraph.isZoomed must be missing, 'x' or 'y'.";
};
+/**
+ * Returns information about the Dygraph object, including its containing ID.
+ */
Dygraph.prototype.toString = function() {
var maindiv = this.maindiv_;
var id = (maindiv && maindiv.id) ? maindiv.id : maindiv
return "[Dygraph " + id + "]";
}
+/**
+ * @private
+ * Returns the value of an option. This may be set by the user (either in the
+ * constructor or by calling updateOptions) or by dygraphs, and may be set to a
+ * per-series value.
+ * @param { String } name The name of the option, e.g. 'rollPeriod'.
+ * @param { String } [seriesName] The name of the series to which the option
+ * will be applied. If no per-series value of this option is available, then
+ * the global value is returned. This is optional.
+ * @return { ... } The value of the option.
+ */
Dygraph.prototype.attr_ = function(name, seriesName) {
// <REMOVE_FOR_COMBINED>
if (typeof(Dygraph.OPTIONS_REFERENCE) === 'undefined') {
};
// TODO(danvk): any way I can get the line numbers to be this.warn call?
+/**
+ * @private
+ * Log an error on the JS console at the given severity.
+ * @param { Integer } severity One of Dygraph.{DEBUG,INFO,WARNING,ERROR}
+ * @param { String } The message to log.
+ */
Dygraph.prototype.log = function(severity, message) {
if (typeof(console) != 'undefined') {
switch (severity) {
break;
}
}
-}
+};
+
+/** @private */
Dygraph.prototype.info = function(message) {
this.log(Dygraph.INFO, message);
-}
+};
+
+/** @private */
Dygraph.prototype.warn = function(message) {
this.log(Dygraph.WARNING, message);
-}
+};
+
+/** @private */
Dygraph.prototype.error = function(message) {
this.log(Dygraph.ERROR, message);
-}
+};
/**
* Returns the current rolling period, as set by the user or an option.
*/
Dygraph.prototype.yAxisRange = function(idx) {
if (typeof(idx) == "undefined") idx = 0;
- if (idx < 0 || idx >= this.axes_.length) return null;
- return [ this.axes_[idx].computedValueRange[0],
- this.axes_[idx].computedValueRange[1] ];
+ if (idx < 0 || idx >= this.axes_.length) {
+ return null;
+ }
+ var axis = this.axes_[idx];
+ return [ axis.computedValueRange[0], axis.computedValueRange[1] ];
};
/**
if (typeof(axis) == "undefined") axis = 0;
if (!this.axes_[axis].logscale) {
- return yRange[0] + (area.h - y) / area.h * (yRange[1] - yRange[0]);
+ 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
*
* If y is null, this returns null.
* if axis is null, this uses the first axis.
+ *
+ * @param { Number } y The data y-coordinate.
+ * @param { Number } [axis] The axis number on which the data coordinate lives.
+ * @return { Number } A fraction in [0, 1] where 0 = the top edge.
*/
Dygraph.prototype.toPercentYCoord = function(y, axis) {
if (y == null) {
* values can fall outside the canvas.
*
* If x is null, this returns null.
+ * @param { Number } x The data x-coordinate.
+ * @return { Number } A fraction in [0, 1] where 0 = the left edge.
*/
Dygraph.prototype.toPercentXCoord = function(x) {
if (x == null) {
var xRange = this.xAxisRange();
return (x - xRange[0]) / (xRange[1] - xRange[0]);
-}
+};
/**
* Returns the number of columns (including the independent variable).
+ * @return { Integer } The number of columns.
*/
Dygraph.prototype.numColumns = function() {
return this.rawData_[0].length;
/**
* Returns the number of rows (excluding any header/label row).
+ * @return { Integer } The number of rows, less any header.
*/
Dygraph.prototype.numRows = function() {
return this.rawData_.length;
* Returns the value in the given row and column. If the row and column exceed
* the bounds on the data, returns null. Also returns null if the value is
* missing.
+ * @param { Number} row The row number of the data (0-based). Row 0 is the
+ * first row of data, not a header row.
+ * @param { Number} col The column number of the data (0-based)
+ * @return { Number } The value in the specified cell or null if the row/col
+ * were out of range.
*/
Dygraph.prototype.getValue = function(row, col) {
if (row < 0 || row > this.rawData_.length) return null;
return this.rawData_[row][col];
};
+/**
+ * @private
+ * Add an event handler. This smooths a difference between IE and the rest of
+ * the world.
+ * @param { DOM element } el The element to add the event to.
+ * @param { String } evt The name of the event, e.g. 'click' or 'mousemove'.
+ * @param { Function } fn The function to call on the event. The function takes
+ * one parameter: the event object.
+ */
Dygraph.addEvent = function(el, evt, fn) {
var normed_fn = function(e) {
if (!e) var e = window.event;
};
-// Based on the article at
-// http://www.switchonthecode.com/tutorials/javascript-tutorial-the-scroll-wheel
+/**
+ * @private
+ * Cancels further processing of an event. This is useful to prevent default
+ * browser actions, e.g. highlighting text on a double-click.
+ * Based on the article at
+ * http://www.switchonthecode.com/tutorials/javascript-tutorial-the-scroll-wheel
+ * @param { Event } e The event whose normal behavior should be canceled.
+ */
Dygraph.cancelEvent = function(e) {
e = e ? e : window.event;
if (e.stopPropagation) {
e.cancel = true;
e.returnValue = false;
return false;
-}
+};
/**
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_);
});
// Create the grapher
- // TODO(danvk): why does the Layout need its own set of options?
- this.layoutOptions_ = { 'xOriginIsZero': false };
- Dygraph.update(this.layoutOptions_, this.attrs_);
- Dygraph.update(this.layoutOptions_, this.user_attrs_);
- Dygraph.update(this.layoutOptions_, {
- 'errorBars': (this.attr_("errorBars") || this.attr_("customBars")) });
-
- this.layout_ = new DygraphLayout(this, this.layoutOptions_);
-
- // TODO(danvk): why does the Renderer need its own set of options?
- this.renderOptions_ = { colorScheme: this.colors_,
- strokeColor: null,
- axisLineWidth: Dygraph.AXIS_LINE_WIDTH };
- Dygraph.update(this.renderOptions_, this.attrs_);
- Dygraph.update(this.renderOptions_, this.user_attrs_);
+ this.layout_ = new DygraphLayout(this);
this.createStatusMessage_();
this.createDragInterface_();
};
/**
- * Creates the canvas containing the PlotKit graph. Only plotkit ever draws on
- * this particular canvas. All Dygraph work is done on this.canvas_.
+ * Creates the canvas on which the chart will be drawn. Only the Renderer ever
+ * draws on this particular canvas. All Dygraph work (i.e. drawing hover dots
+ * or the zoom rectangles) is done on this.canvas_.
* @param {Object} canvas The Dygraph canvas over which to overlay the plot
* @return {Object} The newly-created canvas
* @private
return h;
};
-// Taken from MochiKit.Color
+/**
+ * Convert hsv values to an rgb(r,g,b) string. Taken from MochiKit.Color. This
+ * is used to generate default series colors which are evenly spaced on the
+ * color wheel.
+ * @param { Number } hue Range is 0.0-1.0.
+ * @param { Number } saturation Range is 0.0-1.0.
+ * @param { Number } value Range is 0.0-1.0.
+ * @return { String } "rgb(r,g,b)" where r, g and b range from 0-255.
+ * @private
+ */
Dygraph.hsvToRGB = function (hue, saturation, value) {
var red;
var green;
* @private
*/
Dygraph.prototype.setColors_ = function() {
- // TODO(danvk): compute this directly into this.attrs_['colorScheme'] and do
- // away with this.renderOptions_.
var num = this.attr_("labels").length - 1;
this.colors_ = [];
var colors = this.attr_('colors');
}
}
- // TODO(danvk): update this w/r/t/ the new options system.
- this.renderOptions_.colorScheme = this.colors_;
- Dygraph.update(this.plotter_.options, this.renderOptions_);
- Dygraph.update(this.layoutOptions_, this.user_attrs_);
- Dygraph.update(this.layoutOptions_, this.attrs_);
-}
+ 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.
+ * attributes or the autogenerated list of rgb(r,g,b) strings.
* @return {Array<string>} The list of colors.
*/
Dygraph.prototype.getColors = function() {
// The following functions are from quirksmode.org with a modification for Safari from
// http://blog.firetree.net/2005/07/04/javascript-find-position/
// http://www.quirksmode.org/js/findpos.html
+
+/** @private */
Dygraph.findPosX = function(obj) {
var curleft = 0;
if(obj.offsetParent)
return curleft;
};
+
+/** @private */
Dygraph.findPosY = function(obj) {
var curtop = 0;
if(obj.offsetParent)
};
-
/**
* 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
* 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.
this.roller_.onchange = function() { dygraph.adjustRoll(dygraph.roller_.value); };
};
-// These functions are taken from MochiKit.Signal
+/**
+ * @private
+ * Returns the x-coordinate of the event in a coordinate system where the
+ * top-left corner of the page (not the window) is (0,0).
+ * Taken from MochiKit.Signal
+ */
Dygraph.pageX = function(e) {
if (e.pageX) {
return (!e.pageX || e.pageX < 0) ? 0 : e.pageX;
}
};
+/**
+ * @private
+ * Returns the y-coordinate of the event in a coordinate system where the
+ * top-left corner of the page (not the window) is (0,0).
+ * Taken from MochiKit.Signal
+ */
Dygraph.pageY = function(e) {
if (e.pageY) {
return (!e.pageY || e.pageY < 0) ? 0 : e.pageY;
}
};
+/**
+ * @private
+ * Converts page the x-coordinate of the event to pixel x-coordinates on the
+ * canvas (i.e. DOM Coords).
+ */
Dygraph.prototype.dragGetX_ = function(e, context) {
return Dygraph.pageX(e) - context.px
};
+/**
+ * @private
+ * Converts page the y-coordinate of the event to pixel y-coordinates on the
+ * canvas (i.e. DOM Coords).
+ */
Dygraph.prototype.dragGetY_ = function(e, context) {
return Dygraph.pageY(e) - context.py
};
-// Called in response to an interaction model operation that
-// should start the default panning behavior.
-//
-// It's used in the default callback for "mousedown" operations.
-// Custom interaction model builders can use it to provide the default
-// panning behavior.
-//
-Dygraph.startPan = function(event, g, context) {
- context.isPanning = true;
- var xRange = g.xAxisRange();
- context.dateRange = xRange[1] - xRange[0];
- 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;
- for (var i = 0; i < g.axes_.length; i++) {
- var axis = g.axes_[i];
- var yRange = g.yAxisRange(i);
- // TODO(konigsberg): These values should be in |context|.
- // In log scale, initialTopValue, dragValueRange and unitsPerPixel are log scale.
- if (axis.logscale) {
- axis.initialTopValue = Dygraph.log10(yRange[1]);
- axis.dragValueRange = Dygraph.log10(yRange[1]) - Dygraph.log10(yRange[0]);
- } else {
- axis.initialTopValue = yRange[1];
- axis.dragValueRange = yRange[1] - yRange[0];
- }
- axis.unitsPerPixel = axis.dragValueRange / (g.plotter_.area.h - 1);
-
- // While calculating axes, set 2dpan.
- if (axis.valueWindow || axis.valueRange) context.is2DPan = true;
- }
-};
-
-// Called in response to an interaction model operation that
-// responds to an event that pans the view.
-//
-// It's used in the default callback for "mousemove" operations.
-// Custom interaction model builders can use it to provide the default
-// panning behavior.
-//
-Dygraph.movePan = function(event, g, context) {
- context.dragEndX = g.dragGetX_(event, context);
- context.dragEndY = g.dragGetY_(event, context);
-
- 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.
- if (context.is2DPan) {
- // Adjust each axis appropriately.
- for (var i = 0; i < g.axes_.length; i++) {
- var axis = g.axes_[i];
-
- 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) ];
- } else {
- axis.valueWindow = [ minValue, maxValue ];
- }
- }
- }
-
- g.drawGraph_();
-}
-
-// Called in response to an interaction model operation that
-// responds to an event that ends panning.
-//
-// It's used in the default callback for "mouseup" operations.
-// Custom interaction model builders can use it to provide the default
-// panning behavior.
-//
-Dygraph.endPan = function(event, g, context) {
- // TODO(konigsberg): Clear the context data from the axis.
- // TODO(konigsberg): mouseup should just delete the
- // context object, and mousedown should create a new one.
- context.isPanning = false;
- context.is2DPan = false;
- context.initialLeftmostDate = null;
- context.dateRange = null;
- context.valueRange = null;
- context.boundedDates = null;
- context.boundedValues = null;
-}
-
-// Called in response to an interaction model operation that
-// responds to an event that starts zooming.
-//
-// It's used in the default callback for "mousedown" operations.
-// Custom interaction model builders can use it to provide the default
-// zooming behavior.
-//
-Dygraph.startZoom = function(event, g, context) {
- context.isZooming = true;
-}
-
-// Called in response to an interaction model operation that
-// responds to an event that defines zoom boundaries.
-//
-// It's used in the default callback for "mousemove" operations.
-// Custom interaction model builders can use it to provide the default
-// zooming behavior.
-//
-Dygraph.moveZoom = function(event, g, context) {
- context.dragEndX = g.dragGetX_(event, context);
- context.dragEndY = g.dragGetY_(event, context);
-
- var xDelta = Math.abs(context.dragStartX - context.dragEndX);
- var yDelta = Math.abs(context.dragStartY - context.dragEndY);
-
- // drag direction threshold for y axis is twice as large as x axis
- context.dragDirection = (xDelta < yDelta / 2) ? Dygraph.VERTICAL : Dygraph.HORIZONTAL;
-
- g.drawZoomRect_(
- context.dragDirection,
- context.dragStartX,
- context.dragEndX,
- context.dragStartY,
- context.dragEndY,
- context.prevDragDirection,
- context.prevEndX,
- context.prevEndY);
-
- context.prevEndX = context.dragEndX;
- context.prevEndY = context.dragEndY;
- context.prevDragDirection = context.dragDirection;
-}
-
-// Called in response to an interaction model operation that
-// responds to an event that performs a zoom based on previously defined
-// bounds..
-//
-// It's used in the default callback for "mouseup" operations.
-// Custom interaction model builders can use it to provide the default
-// zooming behavior.
-//
-Dygraph.endZoom = function(event, g, context) {
- context.isZooming = false;
- context.dragEndX = g.dragGetX_(event, context);
- context.dragEndY = g.dragGetY_(event, context);
- var regionWidth = Math.abs(context.dragEndX - context.dragStartX);
- var regionHeight = Math.abs(context.dragEndY - context.dragStartY);
-
- if (regionWidth < 2 && regionHeight < 2 &&
- g.lastx_ != undefined && g.lastx_ != -1) {
- // TODO(danvk): pass along more info about the points, e.g. 'x'
- if (g.attr_('clickCallback') != null) {
- g.attr_('clickCallback')(event, g.lastx_, g.selPoints_);
- }
- if (g.attr_('pointClickCallback')) {
- // check if the click was on a particular point.
- var closestIdx = -1;
- var closestDistance = 0;
- for (var i = 0; i < g.selPoints_.length; i++) {
- var p = g.selPoints_[i];
- var distance = Math.pow(p.canvasx - context.dragEndX, 2) +
- Math.pow(p.canvasy - context.dragEndY, 2);
- if (closestIdx == -1 || distance < closestDistance) {
- closestDistance = distance;
- closestIdx = i;
- }
- }
-
- // Allow any click within two pixels of the dot.
- var radius = g.attr_('highlightCircleSize') + 2;
- if (closestDistance <= 5 * 5) {
- g.attr_('pointClickCallback')(event, g.selPoints_[closestIdx]);
- }
- }
- }
-
- if (regionWidth >= 10 && context.dragDirection == Dygraph.HORIZONTAL) {
- g.doZoomX_(Math.min(context.dragStartX, context.dragEndX),
- Math.max(context.dragStartX, context.dragEndX));
- } else if (regionHeight >= 10 && context.dragDirection == Dygraph.VERTICAL) {
- 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);
- }
- context.dragStartX = null;
- context.dragStartY = null;
-}
-
-Dygraph.defaultInteractionModel = {
- // Track the beginning of drag events
- mousedown: function(event, g, context) {
- context.initializeMouseDown(event, g, context);
-
- if (event.altKey || event.shiftKey) {
- Dygraph.startPan(event, g, context);
- } else {
- Dygraph.startZoom(event, g, context);
- }
- },
-
- // Draw zoom rectangles when the mouse is down and the user moves around
- mousemove: function(event, g, context) {
- if (context.isZooming) {
- Dygraph.moveZoom(event, g, context);
- } else if (context.isPanning) {
- Dygraph.movePan(event, g, context);
- }
- },
-
- mouseup: function(event, g, context) {
- if (context.isZooming) {
- Dygraph.endZoom(event, g, context);
- } else if (context.isPanning) {
- Dygraph.endPan(event, g, context);
- }
- },
-
- // Temporarily cancel the dragging event when the mouse leaves the graph
- mouseout: function(event, g, context) {
- if (context.isZooming) {
- context.dragEndX = null;
- context.dragEndY = null;
- }
- },
-
- // Disable zooming out if panning.
- dblclick: function(event, g, context) {
- if (event.altKey || event.shiftKey) {
- return;
- }
- // TODO(konigsberg): replace g.doUnzoom()_ with something that is
- // friendlier to public use.
- g.doUnzoom_();
- }
-};
-
-Dygraph.DEFAULT_ATTRS.interactionModel = Dygraph.defaultInteractionModel;
-
/**
* Set up all the mouse handlers needed to capture dragging behavior for zoom
* events.
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) {
}
}
+ // Clear any selection, since it's likely to be drawn in the wrong place.
+ this.clearSelection();
+
if (dirty) {
// Putting the drawing operation before the callback because it resets
// yAxisRange.
return -1;
};
+/**
+ * @private
+ * @param { Number } x The number to consider.
+ * @return { Boolean } Whether the number is zero or NaN.
+ */
// TODO(danvk): rename this function to something like 'isNonZeroNan'.
Dygraph.isOK = function(x) {
return x && !isNaN(x);
};
+/**
+ * @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,
return html;
};
+/**
+ * @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");
*/
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;
};
/**
- * Set manually set selected dots, and display information about them
- * @param int row number that should by highlighted
- * false value clears the selection
- * @public
+ * Manually set the selected points and display information about them in the
+ * legend. The selection can be cleared using clearSelection() and queried
+ * 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.
*/
Dygraph.prototype.setSelection = function(row) {
// Extract the points we've selected
};
/**
- * Remove all selection from the canvas
- * @public
+ * Clears the current selection (i.e. points that were highlighted by moving
+ * the mouse over the chart).
*/
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.canvas_ctx_.clearRect(0, 0, this.width_, this.height_);
this.setLegendHTML_();
this.selPoints_ = [];
this.lastx_ = -1;
}
/**
- * Returns the number of the currently selected row
- * @return int row number, of -1 if nothing is selected
- * @public
+ * Returns the number of the currently selected row. To get data for this row,
+ * you can use the getValue method.
+ * @return { Integer } row number, or -1 if nothing is selected
*/
Dygraph.prototype.getSelection = function() {
if (!this.selPoints_ || this.selPoints_.length < 1) {
};
/**
+ * @private
* Return a string version of a number. This respects the digitsAfterDecimal
* and maxNumberWidth options.
* @param {Number} x The number to be formatted
}
};
+/**
+ * @private
+ * Converts '9' to '09' (useful for dates)
+ */
Dygraph.zeropad = function(x) {
if (x < 10) return "0" + x; else return "" + x;
};
}
var xTicks = this.attr_('xTicker')(range[0], range[1], this);
- this.layout_.updateOptions({xTicks: xTicks});
+ this.layout_.setXTicks(xTicks);
};
// Time granularity enumeration
Dygraph.SHORT_SPACINGS[Dygraph.DAILY] = 1000 * 86400;
Dygraph.SHORT_SPACINGS[Dygraph.WEEKLY] = 1000 * 604800;
-// NumXTicks()
-//
-// If we used this time granularity, how many ticks would there be?
-// This is only an approximation, but it's generally good enough.
-//
+/**
+ * @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.
}
};
-// GetXAxis()
-//
-// 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.
-//
+/**
+ * @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 = [];
* 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)
- * @return {Array.<Object>} Array of {label, value} tuples.
+ * @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);
}
};
-// 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.
+/**
+ * @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++) {
return vals;
}();
-// val is the value to search for
-// arry is the value over which to search
-// if abs > 0, find the lowest entry greater than val
-// if abs < 0, find the highest entry less than val
-// if abs == 0, find the entry that equals val.
-// Currently does not work when val is outside the range of arry's values.
+/**
+ * @private
+ * Implementation of binary search over an array.
+ * Currently does not work when val is outside the range of arry's values.
+ * @param { Integer } val the value to search for
+ * @param { Integer[] } arry is the value over which to search
+ * @param { Integer } abs If abs > 0, find the lowest entry greater than val
+ * If abs < 0, find the highest entry less than val.
+ * if abs == 0, find the entry that equals val.
+ * @param { Integer } [low] The first index in arry to consider (optional)
+ * @param { Integer } [high] The last index in arry to consider (optional)
+ */
Dygraph.binarySearch = function(val, arry, abs, low, high) {
if (low == null || high == null) {
low = 0;
}
};
+// TODO(konigsberg): Update comment.
/**
* Add ticks when the x axis has numbers on it (instead of dates)
- * TODO(konigsberg): Update comment.
*
* @param {Number} minV minimum value
* @param {Number} maxV maximum value
* @param self
* @param {function} attribute accessor function.
- * @return {Array.<Object>} Array of {label, value} tuples.
- * @public
+ * @return {[Object]} Array of {label, value} tuples.
*/
Dygraph.numericTicks = function(minV, maxV, self, axis_props, vals) {
var attr = function(k) {
return ticks;
};
-// Computes the range of the data series (including confidence intervals).
-// series is either [ [x1, y1], [x2, y2], ... ] or
-// [ [x1, [y1, dev_low, dev_high]], [x2, [y2, dev_low, dev_high]], ...
-// Returns [low, high]
+/**
+ * @private
+ * Computes the range of the data series (including confidence intervals).
+ * @param { [Array] } series either [ [x1, y1], [x2, y2], ... ] or
+ * [ [x1, [y1, dev_low, dev_high]], [x2, [y2, dev_low, dev_high]], ...
+ * @return [low, high]
+ */
Dygraph.prototype.extremeValues_ = function(series) {
var minY = null, maxY = null;
};
/**
+ * @private
* This function is called once when the chart's data is changed or the options
* dictionary is updated. It is _not_ called when the user pans or zooms. The
* idea is that values derived from the chart's data can be computed here,
// Create a new plotter.
if (this.plotter_) this.plotter_.clear();
this.plotter_ = new DygraphCanvasRenderer(this,
- this.hidden_, this.layout_,
- this.renderOptions_);
+ this.hidden_,
+ this.hidden_ctx_,
+ this.layout_);
// The roller sits in the bottom left corner of the chart. We don't know where
// this will be until the options are available, so it's positioned here.
* 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.
+ *
+ * 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.)
+ *
* @private
*/
-Dygraph.prototype.drawGraph_ = function() {
+Dygraph.prototype.drawGraph_ = function(clearSelection) {
+ if (typeof(clearSelection) === 'undefined') {
+ clearSelection = true;
+ }
+
var data = this.rawData_;
// This is used to set the second parameter to drawCallback, below.
}
this.computeYAxisRanges_(extremes);
- this.layout_.updateOptions( { yAxes: this.axes_,
- seriesToAxisMap: this.seriesToAxisMap_
- } );
+ this.layout_.setYAxes(this.axes_);
+
this.addXTicks_();
- // Save the X axis zoomed status as the updateOptions call will tend to set it errorneously
+ // 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_.updateOptions({dateWindow: this.dateWindow_});
+ this.layout_.setDateWindow(this.dateWindow_);
this.zoomed_x_ = tmp_zoomed_x;
this.layout_.evaluateWithError();
this.plotter_.clear();
// Generate a static legend before any particular point is selected.
this.setLegendHTML_();
} else {
- if (typeof(this.selPoints_) !== 'undefined' && this.selPoints_.length) {
- this.lastx_ = this.selPoints_[0].xval;
- this.updateSelection_();
- } else {
- this.clearSelection();
+ 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();
+ }
}
}
};
/**
+ * @private
* Determine properties of the y-axes which are independent of the data
* 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
* 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) {
- // Preserve valueWindow settings.
+ if (this.axes_ != undefined && this.user_attrs_.hasOwnProperty("valueRange") == false) {
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_ = {};
};
/**
+ * @private
+ * Returns axis properties for the given series.
+ * @param { String } setName The name of the series for which to get axis
+ * properties, e.g. 'Y1'.
+ * @return { Object } The axis properties.
+ */
+Dygraph.prototype.axisPropertiesForSeries = function(series) {
+ // TODO(danvk): handle errors.
+ return this.axes_[this.seriesToAxisMap_[series]];
+};
+
+/**
+ * @private
* Determine the value range and tick marks for each axis.
* @param {Object} extremes A mapping from seriesName -> [low, high]
* This fills in the valueRange and ticks fields in each entry of this.axes_.
};
/**
+ * @private
* Calculates the rolling average of a data set.
* If originalData is [label, val], rolls the average of those.
* If originalData is [label, [, it's interpreted as [value, stddev]
};
/**
+ * @private
* Parses a date, returning the number of milliseconds since epoch. This can be
* passed in as an xValueParser in the Dygraph constructor.
* TODO(danvk): enumerate formats that this understands.
* @param {String} A date in YYYYMMDD format.
* @return {Number} Milliseconds since epoch.
- * @public
*/
Dygraph.dateParser = function(dateStr, self) {
var dateStrSlashed;
this.attrs_.xAxisLabelFormatter = 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;
};
/**
+ * @private
* Parses a string in a special csv format. We expect a csv file where each
* line is a date point, and the first field in each line is the date string.
* We also expect that all remaining fields represent series.
* if the errorBars attribute is set, then interpret the fields as:
* date, series1, stddev1, series2, stddev2, ...
- * @param {Array.<Object>} data See above.
- * @private
+ * @param {[Object]} data See above.
*
- * @return Array.<Object> An array with one entry for each row. These entries
+ * @return [Object] An array with one entry for each row. These entries
* are an array of cells in that row. The first entry is the parsed x-value for
* the row. The second, third, etc. are the y-values. These can take on one of
* three forms, depending on the CSV and constructor parameters:
}
var start = 0;
- if (this.labelsFromCSV_) {
+ if (!('labels' in this.user_attrs_)) {
+ // User hasn't explicitly set labels, so they're (presumably) in the CSV.
start = 1;
- this.attrs_.labels = lines[0].split(delim);
+ this.attrs_.labels = lines[0].split(delim); // NOTE: _not_ user_attrs_.
}
var line_no = 0;
};
/**
+ * @private
* The user has provided their data as a pre-packaged JS array. If the x values
* are numeric, this is the same as dygraphs' internal format. If the x values
* are dates, we need to convert them from Date objects to ms since epoch.
- * @param {Array.<Object>} data
- * @return {Array.<Object>} data with numeric x values.
+ * @param {[Object]} data
+ * @return {[Object]} data with numeric x values.
*/
Dygraph.prototype.parseArray_ = function(data) {
// Peek at the first x value to see if it's numeric.
return parsedData;
} 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;
return data;
* number. All subsequent columns must be numbers. If there is a clear mismatch
* between this.xValueParser_ and the type of the first column, it will be
* fixed. Fills out rawData_.
- * @param {Array.<Object>} data See above.
+ * @param {[Object]} data See above.
* @private
*/
Dygraph.prototype.parseDataTable_ = function(data) {
}
}
-// 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.
+/**
+ * @private
+ * This is identical to JavaScript's built-in Date.parse() method, except that
+ * it doesn't get replaced with an incompatible method by aggressive JS
+ * libraries like MooTools or Joomla.
+ * @param { String } str The date string, e.g. "2011/05/06"
+ * @return { Integer } millis since epoch
+ */
Dygraph.dateStrToMillis = function(str) {
return new Date(str).getTime();
};
// These functions are all based on MochiKit.
+/**
+ * Copies all the properties from o to self.
+ *
+ * @private
+ */
Dygraph.update = function (self, o) {
if (typeof(o) != 'undefined' && o !== null) {
for (var k in o) {
return self;
};
+/**
+ * @private
+ */
Dygraph.isArrayLike = function (o) {
var typ = typeof(o);
if (
return true;
};
+/**
+ * @private
+ */
Dygraph.isDateLike = function (o) {
if (typeof(o) != "object" || o === null ||
typeof(o.getTime) != 'function') {
return true;
};
+/**
+ * @private
+ */
Dygraph.clone = function(o) {
// TODO(danvk): figure out how MochiKit's version works
var r = [];
var caller = this;
req.onreadystatechange = function () {
if (req.readyState == 4) {
- if (req.status == 200) {
+ if (req.status == 200 || // Normal http
+ req.status == 0) { // Chrome w/ --allow-file-access-from-files
caller.loadedEvent_(req.responseText);
}
}
* <li>errorBars: changes whether the data contains stddev</li>
* </ul>
*
+ * There's a huge variety of options that can be passed to this method. For a
+ * full list, see http://dygraphs.com/options.html.
+ *
* @param {Object} attrs The new properties and values
+ * @param {Boolean} [block_redraw] Usually the chart is redrawn after every
+ * call to updateOptions(). If you know better, you can pass true to explicitly
+ * block the redraw. This can be useful for chaining updateOptions() calls,
+ * avoiding the occasional infinite loop and preventing redraws when it's not
+ * necessary (e.g. when updating a callback).
*/
-Dygraph.prototype.updateOptions = function(attrs) {
- // TODO(danvk): this is a mess. Rethink this function.
+Dygraph.prototype.updateOptions = function(attrs, block_redraw) {
+ if (typeof(block_redraw) == 'undefined') block_redraw = false;
+
+ // TODO(danvk): this is a mess. Move these options into attr_.
if ('rollPeriod' in attrs) {
this.rollPeriod_ = attrs.rollPeriod;
}
// highlightCircleSize
Dygraph.update(this.user_attrs_, attrs);
- Dygraph.update(this.renderOptions_, attrs);
-
- this.labelsFromCSV_ = (this.attr_("labels") == null);
- // TODO(danvk): this doesn't match the constructor logic
- this.layout_.updateOptions({ 'errorBars': this.attr_("errorBars") });
if (attrs['file']) {
this.file_ = attrs['file'];
- this.start_();
+ if (!block_redraw) this.start_();
} else {
- this.predraw_();
+ if (!block_redraw) this.predraw_();
}
};
* This is far more efficient than destroying and re-instantiating a
* Dygraph, since it doesn't have to reparse the underlying data.
*
- * @param {Number} width Width (in pixels)
- * @param {Number} height Height (in pixels)
+ * @param {Number} [width] Width (in pixels)
+ * @param {Number} [height] Height (in pixels)
*/
Dygraph.prototype.resize = function(width, height) {
if (this.resize_lock) {
return null;
};
+/**
+ * @private
+ * Adds a default style for the annotation CSS classes to the document. This is
+ * only executed when annotations are actually used. It is designed to only be
+ * called once -- all calls after the first will return immediately.
+ */
Dygraph.addAnnotationRule = function() {
if (Dygraph.addedAnnotationCSS) return;
}
/**
+ * @private
* Create a new canvas element. This is more complex than a simple
* document.createElement("canvas") because of IE and excanvas.
*/
return canvas;
};
-
-/**
- * A wrapper around Dygraph that implements the gviz API.
- * @param {Object} container The DOM object the visualization should live in.
- */
-Dygraph.GVizChart = function(container) {
- this.container = container;
-}
-
-Dygraph.GVizChart.prototype.draw = function(data, options) {
- // Clear out any existing dygraph.
- // TODO(danvk): would it make more sense to simply redraw using the current
- // date_graph object?
- this.container.innerHTML = '';
- if (typeof(this.date_graph) != 'undefined') {
- this.date_graph.destroy();
- }
-
- this.date_graph = new Dygraph(this.container, data, options);
-}
-
-/**
- * Google charts compatible setSelection
- * Only row selection is supported, all points in the row will be highlighted
- * @param {Array} array of the selected cells
- * @public
- */
-Dygraph.GVizChart.prototype.setSelection = function(selection_array) {
- var row = false;
- if (selection_array.length) {
- row = selection_array[0].row;
- }
- this.date_graph.setSelection(row);
-}
-
-/**
- * Google charts compatible getSelection implementation
- * @return {Array} array of the selected cells
- * @public
- */
-Dygraph.GVizChart.prototype.getSelection = function() {
- var selection = [];
-
- var row = this.date_graph.getSelection();
-
- if (row < 0) return selection;
-
- col = 1;
- for (var i in this.date_graph.layout_.datasets) {
- selection.push({row: row, column: col});
- col++;
- }
-
- return selection;
-}
-
// Older pages may still use this name.
DateGraph = Dygraph;
-
-// <REMOVE_FOR_COMBINED>
-Dygraph.OPTIONS_REFERENCE = // <JSON>
-{
- "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",
- "labels": ["Data Line display"],
- "type": "boolean",
- "description": "If set, stack series on top of one another rather than drawing them independently."
- },
- "pointSize": {
- "default": "1",
- "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."
- },
- "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",
- "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": {
- "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."
- },
- "connectSeparatedPoints": {
- "default": "false",
- "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."
- },
- "highlightCallback": {
- "default": "null",
- "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>"
- },
- "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"
- },
- "rollPeriod": {
- "default": "1",
- "labels": ["Error Bars", "Rolling Averages"],
- "type": "integer >= 1",
- "description": "Number of days over which to average data. Discussed extensively above."
- },
- "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."
- },
- "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": {
- "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>."
- },
- "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",
- "labels": ["Annotations"],
- "type": "function(annotation, point, dygraph, event)",
- "description": "If provided, this function is called whenever the user mouses over an annotation."
- },
- "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."
- },
- "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": {
- "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."
- },
- "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."
- },
- "axisLabelFontSize": {
- "default": "14",
- "labels": ["Axis display"],
- "type": "integer",
- "description": "Size of the font (in pixels) to use in the axis labels, both x- and y-axis."
- },
- "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."
- },
- "width": {
- "default": "480",
- "labels": ["Overall display"],
- "type": "integer",
- "description": "Width, in pixels, of the chart. If the container div has been explicitly sized, this will be ignored."
- },
- "interactionModel": {
- "default": "...",
- "labels": ["Interactive Elements"],
- "type": "Object",
- "description": "TODO(konigsberg): document this"
- },
- "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": {
- "default": "50",
- "labels": ["Axis display"],
- "type": "integer",
- "description": "Width, in pixels, of the x-axis labels."
- },
- "showLabelsOnHighlight": {
- "default": "true",
- "labels": ["Interactive Elements", "Legend"],
- "type": "boolean",
- "description": "Whether to show the legend upon mouseover."
- },
- "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."
- },
- "pixelsPerXLabel": {
- "default": "60",
- "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."
- },
- "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": {
- "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)."
- },
- "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."
- },
- "fillGraph": {
- "default": "false",
- "labels": ["Data Line display"],
- "type": "boolean",
- "description": "Should the area underneath the graph be filled? This option is not compatible with error bars."
- },
- "highlightCircleSize": {
- "default": "3",
- "labels": ["Interactive Elements"],
- "type": "integer",
- "description": "The size in pixels of the dot drawn over highlighted points."
- },
- "gridLineColor": {
- "default": "rgb(128,128,128)",
- "labels": ["Grid"],
- "type": "red, blue",
- "description": "The color of the gridlines."
- },
- "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."
- },
- "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]."
- },
- "labelsDivWidth": {
- "default": "250",
- "labels": ["Legend"],
- "type": "integer",
- "description": "Width (in pixels) of the div which shows information on the currently-highlighted points."
- },
- "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",
- "description": "Width, in pixels, of the y-axis labels."
- },
- "hideOverlayOnMouseOut": {
- "default": "true",
- "labels": ["Interactive Elements", "Legend"],
- "type": "boolean",
- "description": "Whether to hide the legend when the mouse leaves the chart area."
- },
- "yValueFormatter": {
- "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."
- },
- "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",
- "labels": ["Data Line display"],
- "type": "boolean",
- "description": "When set, display the graph as a step plot instead of a line plot."
- },
- "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",
- "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": {
- "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."
- },
- "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."
- },
- "showRoller": {
- "default": "false",
- "labels": ["Interactive Elements", "Rolling Averages"],
- "type": "boolean",
- "description": "If the rolling average period text box should be shown."
- },
- "sigma": {
- "default": "2.0",
- "labels": ["Error Bars"],
- "type": "float",
- "description": "When errorBars is set, shade this many standard deviations above/below each point."
- },
- "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."
- },
- "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)"
- },
- "errorBars": {
- "default": "false",
- "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",
- "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."
- },
- "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."
- },
- "title": {
- "labels": ["Chart labels"],
- "type": "string",
- "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."
- },
- "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."
- },
- "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",
- "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."
- },
- "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."
- },
- "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."
- },
- "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. 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];
- for (var i = 0; i < flds.length; i++) {
- if (!op.hasOwnProperty(flds[i])) {
- warn('Option ' + k + ' missing "' + flds[i] + '" property');
- } else if (typeof(op[flds[i]]) != 'string') {
- 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