X-Git-Url: https://adrianiainlam.tk/git/?a=blobdiff_plain;f=dygraph.js;h=5cfe2f424e0ce7af87ab1b45c696dab168b119aa;hb=1903f1e49133d38479059befb9dc50c7b622c826;hp=4adb7164760aca3d0a0d540d4e6cfb9572c21f74;hpb=e99fde0585bfc07ff26c9dc3a5ca30ea339cc81f;p=dygraphs.git
diff --git a/dygraph.js b/dygraph.js
index 4adb716..5cfe2f4 100644
--- a/dygraph.js
+++ b/dygraph.js
@@ -126,7 +126,8 @@ Dygraph.DEFAULT_ATTRS = {
stackedGraph: false,
hideOverlayOnMouseOut: true,
- stepPlot: false
+ stepPlot: false,
+ avoidMinZero: false
};
// Various logging levels.
@@ -135,6 +136,11 @@ Dygraph.INFO = 2;
Dygraph.WARNING = 3;
Dygraph.ERROR = 3;
+// Directions for panning and zooming. Use bit operations when combined
+// values are possible.
+Dygraph.HORIZONTAL = 1;
+Dygraph.VERTICAL = 2;
+
// Used for initializing annotation CSS rules only once.
Dygraph.addedAnnotationCSS = false;
@@ -171,7 +177,7 @@ Dygraph.prototype.__init__ = function(div, file, attrs) {
this.previousVerticalX_ = -1;
this.fractions_ = attrs.fractions || false;
this.dateWindow_ = attrs.dateWindow || null;
- this.valueRange_ = attrs.valueRange || null;
+
this.wilsonInterval_ = attrs.wilsonInterval || true;
this.is_initial_draw_ = true;
this.annotations_ = [];
@@ -183,10 +189,10 @@ Dygraph.prototype.__init__ = function(div, file, attrs) {
// If the div isn't already sized then inherit from our attrs or
// give it a default size.
if (div.style.width == '') {
- div.style.width = attrs.width || Dygraph.DEFAULT_WIDTH + "px";
+ div.style.width = (attrs.width || Dygraph.DEFAULT_WIDTH) + "px";
}
if (div.style.height == '') {
- div.style.height = attrs.height || Dygraph.DEFAULT_HEIGHT + "px";
+ div.style.height = (attrs.height || Dygraph.DEFAULT_HEIGHT) + "px";
}
this.width_ = parseInt(div.style.width, 10);
this.height_ = parseInt(div.style.height, 10);
@@ -232,16 +238,19 @@ Dygraph.prototype.__init__ = function(div, file, attrs) {
// Make a note of whether labels will be pulled from the CSV file.
this.labelsFromCSV_ = (this.attr_("labels") == null);
- Dygraph.addAnnotationRule();
-
// Create the containing DIV and other interactive elements
this.createInterface_();
this.start_();
};
-Dygraph.prototype.attr_ = function(name) {
- if (typeof(this.user_attrs_[name]) != 'undefined') {
+Dygraph.prototype.attr_ = function(name, seriesName) {
+ if (seriesName &&
+ typeof(this.user_attrs_[seriesName]) != 'undefined' &&
+ this.user_attrs_[seriesName] != null &&
+ typeof(this.user_attrs_[seriesName][name]) != 'undefined') {
+ return this.user_attrs_[seriesName][name];
+ } else if (typeof(this.user_attrs_[name]) != 'undefined') {
return this.user_attrs_[name];
} else if (typeof(this.attrs_[name]) != 'undefined') {
return this.attrs_[name];
@@ -303,19 +312,39 @@ Dygraph.prototype.xAxisRange = function() {
};
/**
- * Returns the currently-visible y-range. This can be affected by zooming,
- * panning or a call to updateOptions.
+ * Returns the currently-visible y-range for an axis. This can be affected by
+ * zooming, panning or a call to updateOptions. Axis indices are zero-based. If
+ * called with no arguments, returns the range of the first axis.
* Returns a two-element array: [bottom, top].
*/
-Dygraph.prototype.yAxisRange = function() {
- return this.displayedYRange_;
+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] ];
};
/**
+ * Returns the currently-visible y-ranges for each axis. This can be affected by
+ * zooming, panning, calls to updateOptions, etc.
+ * Returns an array of [bottom, top] pairs, one for each y-axis.
+ */
+Dygraph.prototype.yAxisRanges = function() {
+ var ret = [];
+ for (var i = 0; i < this.axes_.length; i++) {
+ ret.push(this.yAxisRange(i));
+ }
+ return ret;
+};
+
+// TODO(danvk): use these functions throughout dygraphs.
+/**
* Convert from data coordinates to canvas/div X/Y coordinates.
+ * If specified, do this conversion for the coordinate system of a particular
+ * axis. Uses the first axis by default.
* Returns a two-element array: [X, Y]
*/
-Dygraph.prototype.toDomCoords = function(x, y) {
+Dygraph.prototype.toDomCoords = function(x, y, axis) {
var ret = [null, null];
var area = this.plotter_.area;
if (x !== null) {
@@ -324,19 +353,20 @@ Dygraph.prototype.toDomCoords = function(x, y) {
}
if (y !== null) {
- var yRange = this.yAxisRange();
+ var yRange = this.yAxisRange(axis);
ret[1] = area.y + (yRange[1] - y) / (yRange[1] - yRange[0]) * area.h;
}
return ret;
};
-// TODO(danvk): use these functions throughout dygraphs.
/**
* Convert from canvas/div coords to data coordinates.
+ * If specified, do this conversion for the coordinate system of a particular
+ * axis. Uses the first axis by default.
* Returns a two-element array: [X, Y]
*/
-Dygraph.prototype.toDataCoords = function(x, y) {
+Dygraph.prototype.toDataCoords = function(x, y, axis) {
var ret = [null, null];
var area = this.plotter_.area;
if (x !== null) {
@@ -345,7 +375,7 @@ Dygraph.prototype.toDataCoords = function(x, y) {
}
if (y !== null) {
- var yRange = this.yAxisRange();
+ var yRange = this.yAxisRange(axis);
ret[1] = yRange[0] + (area.h - y) / area.h * (yRange[1] - yRange[0]);
}
@@ -390,13 +420,6 @@ Dygraph.addEvent = function(el, evt, fn) {
}
};
-Dygraph.clipCanvas_ = function(cnv, clip) {
- var ctx = cnv.getContext("2d");
- ctx.beginPath();
- ctx.rect(clip.left, clip.top, clip.width, clip.height);
- ctx.clip();
-};
-
/**
* Generates interface elements for the Dygraph: a containing div, a div to
* display the current point, and a textbox to adjust the rolling average
@@ -412,15 +435,6 @@ Dygraph.prototype.createInterface_ = function() {
this.graphDiv.style.height = this.height_ + "px";
enclosing.appendChild(this.graphDiv);
- var clip = {
- top: 0,
- left: this.attr_("yAxisLabelWidth") + 2 * this.attr_("axisTickSize")
- };
- clip.width = this.width_ - clip.left - this.attr_("rightGap");
- clip.height = this.height_ - this.attr_("axisLabelFontSize")
- - 2 * this.attr_("axisTickSize");
- this.clippingArea_ = clip;
-
// Create the canvas for interactive parts of the chart.
this.canvas_ = Dygraph.createCanvas();
this.canvas_.style.position = "absolute";
@@ -437,10 +451,6 @@ Dygraph.prototype.createInterface_ = function() {
this.graphDiv.appendChild(this.canvas_);
this.mouseEventElement_ = this.canvas_;
- // Make sure we don't overdraw.
- Dygraph.clipCanvas_(this.hidden_, this.clippingArea_);
- Dygraph.clipCanvas_(this.canvas_, this.clippingArea_);
-
var dygraph = this;
Dygraph.addEvent(this.mouseEventElement_, 'mousemove', function(e) {
dygraph.mouseMove_(e);
@@ -465,12 +475,8 @@ Dygraph.prototype.createInterface_ = function() {
axisLineWidth: Dygraph.AXIS_LINE_WIDTH };
Dygraph.update(this.renderOptions_, this.attrs_);
Dygraph.update(this.renderOptions_, this.user_attrs_);
- this.plotter_ = new DygraphCanvasRenderer(this,
- this.hidden_, this.layout_,
- this.renderOptions_);
this.createStatusMessage_();
- this.createRollInterface_();
this.createDragInterface_();
};
@@ -676,33 +682,49 @@ Dygraph.prototype.createStatusMessage_ = function() {
};
/**
+ * Position the labels div so that its right edge is flush with the right edge
+ * of the charting area.
+ */
+Dygraph.prototype.positionLabelsDiv_ = function() {
+ // Don't touch a user-specified labelsDiv.
+ if (this.user_attrs_.hasOwnProperty("labelsDiv")) return;
+
+ var area = this.plotter_.area;
+ var div = this.attr_("labelsDiv");
+ div.style.left = area.x + area.w - this.attr_("labelsDivWidth") - 1 + "px";
+};
+
+/**
* Create the text box to adjust the averaging period
- * @return {Object} The newly-created text box
* @private
*/
Dygraph.prototype.createRollInterface_ = function() {
- var display = this.attr_('showRoller') ? "block" : "none";
+ // Create a roller if one doesn't exist already.
+ if (!this.roller_) {
+ this.roller_ = document.createElement("input");
+ this.roller_.type = "text";
+ this.roller_.style.display = "none";
+ this.graphDiv.appendChild(this.roller_);
+ }
+
+ var display = this.attr_('showRoller') ? 'block' : 'none';
+
var textAttr = { "position": "absolute",
"zIndex": 10,
"top": (this.plotter_.area.h - 25) + "px",
"left": (this.plotter_.area.x + 1) + "px",
"display": display
};
- var roller = document.createElement("input");
- roller.type = "text";
- roller.size = "2";
- roller.value = this.rollPeriod_;
+ this.roller_.size = "2";
+ this.roller_.value = this.rollPeriod_;
for (var name in textAttr) {
if (textAttr.hasOwnProperty(name)) {
- roller.style[name] = textAttr[name];
+ this.roller_.style[name] = textAttr[name];
}
}
- var pa = this.graphDiv;
- pa.appendChild(roller);
var dygraph = this;
- roller.onchange = function() { dygraph.adjustRoll(roller.value); };
- return roller;
+ this.roller_.onchange = function() { dygraph.adjustRoll(dygraph.roller_.value); };
};
// These functions are taken from MochiKit.Signal
@@ -740,13 +762,27 @@ Dygraph.prototype.createDragInterface_ = function() {
// Tracks whether the mouse is down right now
var isZooming = false;
- var isPanning = false;
+ var isPanning = false; // is this drag part of a pan?
+ var is2DPan = false; // if so, is that pan 1- or 2-dimensional?
var dragStartX = null;
var dragStartY = null;
var dragEndX = null;
var dragEndY = null;
+ var dragDirection = null;
var prevEndX = null;
+ var prevEndY = null;
+ var prevDragDirection = null;
+
+ // TODO(danvk): update this comment
+ // draggingDate and draggingValue represent the [date,value] point on the
+ // graph at which the mouse was pressed. As the mouse moves while panning,
+ // the viewport must pan so that the mouse position points to
+ // [draggingDate, draggingValue]
var draggingDate = null;
+
+ // TODO(danvk): update this comment
+ // The range in second/value units that the viewport encompasses during a
+ // panning operation.
var dateRange = null;
// Utility function to convert page-wide coordinates to canvas coords
@@ -761,35 +797,95 @@ Dygraph.prototype.createDragInterface_ = function() {
dragEndX = getX(event);
dragEndY = getY(event);
- self.drawZoomRect_(dragStartX, dragEndX, prevEndX);
+ var xDelta = Math.abs(dragStartX - dragEndX);
+ var yDelta = Math.abs(dragStartY - dragEndY);
+
+ // drag direction threshold for y axis is twice as large as x axis
+ dragDirection = (xDelta < yDelta / 2) ? Dygraph.VERTICAL : Dygraph.HORIZONTAL;
+
+ self.drawZoomRect_(dragDirection, dragStartX, dragEndX, dragStartY, dragEndY,
+ prevDragDirection, prevEndX, prevEndY);
+
prevEndX = dragEndX;
+ prevEndY = dragEndY;
+ prevDragDirection = dragDirection;
} else if (isPanning) {
dragEndX = getX(event);
dragEndY = getY(event);
+ // TODO(danvk): update this comment
// Want to have it so that:
- // 1. draggingDate appears at dragEndX
+ // 1. draggingDate appears at dragEndX, draggingValue appears at dragEndY.
// 2. daterange = (dateWindow_[1] - dateWindow_[0]) is unaltered.
+ // 3. draggingValue appears at dragEndY.
+ // 4. valueRange is unaltered.
+
+ var minDate = draggingDate - (dragEndX / self.width_) * dateRange;
+ var maxDate = minDate + dateRange;
+ self.dateWindow_ = [minDate, maxDate];
+
+
+ // y-axis scaling is automatic unless this is a full 2D pan.
+ if (is2DPan) {
+ // Adjust each axis appropriately.
+ var y_frac = dragEndY / self.height_;
+ for (var i = 0; i < self.axes_.length; i++) {
+ var axis = self.axes_[i];
+ var maxValue = axis.draggingValue + y_frac * axis.dragValueRange;
+ var minValue = maxValue - axis.dragValueRange;
+ axis.valueWindow = [ minValue, maxValue ];
+ }
+ }
- self.dateWindow_[0] = draggingDate - (dragEndX / self.width_) * dateRange;
- self.dateWindow_[1] = self.dateWindow_[0] + dateRange;
- self.drawGraph_(self.rawData_);
+ self.drawGraph_();
}
});
// Track the beginning of drag events
Dygraph.addEvent(this.mouseEventElement_, 'mousedown', function(event) {
+ // prevents mouse drags from selecting page text.
+ if (event.preventDefault) {
+ event.preventDefault(); // Firefox, Chrome, etc.
+ } else {
+ event.returnValue = false; // IE
+ event.cancelBubble = true;
+ }
+
px = Dygraph.findPosX(self.canvas_);
py = Dygraph.findPosY(self.canvas_);
dragStartX = getX(event);
dragStartY = getY(event);
if (event.altKey || event.shiftKey) {
- if (!self.dateWindow_) return; // have to be zoomed in to pan.
+ // have to be zoomed in to pan.
+ var zoomedY = false;
+ for (var i = 0; i < self.axes_.length; i++) {
+ if (self.axes_[i].valueWindow || self.axes_[i].valueRange) {
+ zoomedY = true;
+ break;
+ }
+ }
+ if (!self.dateWindow_ && !zoomedY) return;
+
isPanning = true;
- dateRange = self.dateWindow_[1] - self.dateWindow_[0];
- draggingDate = (dragStartX / self.width_) * dateRange +
- self.dateWindow_[0];
+ var xRange = self.xAxisRange();
+ dateRange = xRange[1] - xRange[0];
+
+ // 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.
+ is2DPan = false;
+ for (var i = 0; i < self.axes_.length; i++) {
+ var axis = self.axes_[i];
+ var yRange = self.yAxisRange(i);
+ axis.dragValueRange = yRange[1] - yRange[0];
+ var r = self.toDataCoords(null, dragStartY, i);
+ axis.draggingValue = r[1];
+ if (axis.valueWindow || axis.valueRange) is2DPan = true;
+ }
+
+ // TODO(konigsberg): Switch from all this math to toDataCoords?
+ // Seems to work for the dragging value.
+ draggingDate = (dragStartX / self.width_) * dateRange + xRange[0];
} else {
isZooming = true;
}
@@ -808,6 +904,10 @@ Dygraph.prototype.createDragInterface_ = function() {
isPanning = false;
draggingDate = null;
dateRange = null;
+ for (var i = 0; i < self.axes_.length; i++) {
+ delete self.axes_[i].draggingValue;
+ delete self.axes_[i].dragValueRange;
+ }
}
});
@@ -857,9 +957,12 @@ Dygraph.prototype.createDragInterface_ = function() {
}
}
- if (regionWidth >= 10) {
- self.doZoom_(Math.min(dragStartX, dragEndX),
+ if (regionWidth >= 10 && dragDirection == Dygraph.HORIZONTAL) {
+ self.doZoomX_(Math.min(dragStartX, dragEndX),
Math.max(dragStartX, dragEndX));
+ } else if (regionHeight >= 10 && dragDirection == Dygraph.VERTICAL){
+ self.doZoomY_(Math.min(dragStartY, dragEndY),
+ Math.max(dragStartY, dragEndY));
} else {
self.canvas_.getContext("2d").clearRect(0, 0,
self.canvas_.width,
@@ -872,21 +975,19 @@ Dygraph.prototype.createDragInterface_ = function() {
if (isPanning) {
isPanning = false;
+ is2DPan = false;
draggingDate = null;
dateRange = null;
+ valueRange = null;
}
});
// Double-clicking zooms back out
Dygraph.addEvent(this.mouseEventElement_, 'dblclick', function(event) {
- if (self.dateWindow_ == null) return;
- self.dateWindow_ = null;
- self.drawGraph_(self.rawData_);
- var minDate = self.rawData_[0][0];
- var maxDate = self.rawData_[self.rawData_.length - 1][0];
- if (self.attr_("zoomCallback")) {
- self.attr_("zoomCallback")(minDate, maxDate);
- }
+ // Disable zooming out if panning.
+ if (event.altKey || event.shiftKey) return;
+
+ self.doUnzoom_();
});
};
@@ -895,49 +996,148 @@ Dygraph.prototype.createDragInterface_ = function() {
* up any previous zoom rectangles that were drawn. This could be optimized to
* avoid extra redrawing, but it's tricky to avoid interactions with the status
* dots.
+ *
+ * @param {Number} direction the direction of the zoom rectangle. Acceptable
+ * values are Dygraph.HORIZONTAL and Dygraph.VERTICAL.
* @param {Number} startX The X position where the drag started, in canvas
* coordinates.
* @param {Number} endX The current X position of the drag, in canvas coords.
+ * @param {Number} startY The Y position where the drag started, in canvas
+ * coordinates.
+ * @param {Number} endY The current Y position of the drag, in canvas coords.
+ * @param {Number} prevDirection the value of direction on the previous call to
+ * this function. Used to avoid excess redrawing
* @param {Number} prevEndX The value of endX on the previous call to this
* function. Used to avoid excess redrawing
+ * @param {Number} prevEndY The value of endY on the previous call to this
+ * function. Used to avoid excess redrawing
* @private
*/
-Dygraph.prototype.drawZoomRect_ = function(startX, endX, prevEndX) {
+Dygraph.prototype.drawZoomRect_ = function(direction, startX, endX, startY, endY,
+ prevDirection, prevEndX, prevEndY) {
var ctx = this.canvas_.getContext("2d");
// Clean up from the previous rect if necessary
- if (prevEndX) {
+ if (prevDirection == Dygraph.HORIZONTAL) {
ctx.clearRect(Math.min(startX, prevEndX), 0,
Math.abs(startX - prevEndX), this.height_);
+ } else if (prevDirection == Dygraph.VERTICAL){
+ ctx.clearRect(0, Math.min(startY, prevEndY),
+ this.width_, Math.abs(startY - prevEndY));
}
// Draw a light-grey rectangle to show the new viewing area
- if (endX && startX) {
- ctx.fillStyle = "rgba(128,128,128,0.33)";
- ctx.fillRect(Math.min(startX, endX), 0,
- Math.abs(endX - startX), this.height_);
+ if (direction == Dygraph.HORIZONTAL) {
+ if (endX && startX) {
+ ctx.fillStyle = "rgba(128,128,128,0.33)";
+ ctx.fillRect(Math.min(startX, endX), 0,
+ Math.abs(endX - startX), this.height_);
+ }
+ }
+ if (direction == Dygraph.VERTICAL) {
+ if (endY && startY) {
+ ctx.fillStyle = "rgba(128,128,128,0.33)";
+ ctx.fillRect(0, Math.min(startY, endY),
+ this.width_, Math.abs(endY - startY));
+ }
}
};
/**
- * Zoom to something containing [lowX, highX]. These are pixel coordinates
- * in the canvas. The exact zoom window may be slightly larger if there are no
- * data points near lowX or highX. This function redraws the graph.
+ * Zoom to something containing [lowX, highX]. These are pixel coordinates in
+ * the canvas. The exact zoom window may be slightly larger if there are no data
+ * points near lowX or highX. Don't confuse this function with doZoomXDates,
+ * which accepts dates that match the raw data. This function redraws the graph.
+ *
* @param {Number} lowX The leftmost pixel value that should be visible.
* @param {Number} highX The rightmost pixel value that should be visible.
* @private
*/
-Dygraph.prototype.doZoom_ = function(lowX, highX) {
+Dygraph.prototype.doZoomX_ = function(lowX, highX) {
// Find the earliest and latest dates contained in this canvasx range.
+ // Convert the call to date ranges of the raw data.
var r = this.toDataCoords(lowX, null);
var minDate = r[0];
r = this.toDataCoords(highX, null);
var maxDate = r[0];
+ this.doZoomXDates_(minDate, maxDate);
+};
+/**
+ * Zoom to something containing [minDate, maxDate] values. Don't confuse this
+ * method with doZoomX which accepts pixel coordinates. This function redraws
+ * the graph.
+ *
+ * @param {Number} minDate The minimum date that should be visible.
+ * @param {Number} maxDate The maximum date that should be visible.
+ * @private
+ */
+Dygraph.prototype.doZoomXDates_ = function(minDate, maxDate) {
this.dateWindow_ = [minDate, maxDate];
- this.drawGraph_(this.rawData_);
+ this.drawGraph_();
if (this.attr_("zoomCallback")) {
- this.attr_("zoomCallback")(minDate, maxDate);
+ var yRange = this.yAxisRange();
+ this.attr_("zoomCallback")(minDate, maxDate, yRange[0], yRange[1]);
+ }
+};
+
+/**
+ * Zoom to something containing [lowY, highY]. These are pixel coordinates in
+ * the canvas. This function redraws the graph.
+ *
+ * @param {Number} lowY The topmost pixel value that should be visible.
+ * @param {Number} highY The lowest pixel value that should be visible.
+ * @private
+ */
+Dygraph.prototype.doZoomY_ = function(lowY, highY) {
+ // Find the highest and lowest values in pixel range for each axis.
+ // Note that lowY (in pixels) corresponds to the max Value (in data coords).
+ // This is because pixels increase as you go down on the screen, whereas data
+ // coordinates increase as you go up the screen.
+ var valueRanges = [];
+ for (var i = 0; i < this.axes_.length; i++) {
+ var hi = this.toDataCoords(null, lowY, i);
+ var low = this.toDataCoords(null, highY, i);
+ this.axes_[i].valueWindow = [low[1], hi[1]];
+ valueRanges.push([low[1], hi[1]]);
+ }
+
+ this.drawGraph_();
+ if (this.attr_("zoomCallback")) {
+ var xRange = this.xAxisRange();
+ this.attr_("zoomCallback")(xRange[0], xRange[1], this.yAxisRanges());
+ }
+};
+
+/**
+ * Reset the zoom to the original view coordinates. This is the same as
+ * double-clicking on the graph.
+ *
+ * @private
+ */
+Dygraph.prototype.doUnzoom_ = function() {
+ var dirty = false;
+ if (this.dateWindow_ != null) {
+ dirty = true;
+ this.dateWindow_ = null;
+ }
+
+ for (var i = 0; i < this.axes_.length; i++) {
+ if (this.axes_[i].valueWindow != null) {
+ dirty = true;
+ delete this.axes_[i].valueWindow;
+ }
+ }
+
+ if (dirty) {
+ // Putting the drawing operation before the callback because it resets
+ // yAxisRange.
+ this.drawGraph_();
+ if (this.attr_("zoomCallback")) {
+ var minDate = this.rawData_[0][0];
+ var maxDate = this.rawData_[this.rawData_.length - 1][0];
+ this.attr_("zoomCallback")(minDate, maxDate, this.yAxisRanges());
+ }
}
};
@@ -960,6 +1160,8 @@ Dygraph.prototype.mouseMove_ = function(event) {
var minDist = 1e+100;
var idx = -1;
for (var i = 0; i < points.length; i++) {
+ var point = points[i];
+ if (point == null) continue;
var dist = Math.abs(points[i].canvasx - canvasx);
if (dist > minDist) continue;
minDist = dist;
@@ -967,7 +1169,8 @@ Dygraph.prototype.mouseMove_ = function(event) {
}
if (idx >= 0) lastx = points[idx].xval;
// Check that you can really highlight the last day's data
- if (canvasx > points[points.length-1].canvasx)
+ var last = points[points.length-1];
+ if (last != null && canvasx > last.canvasx)
lastx = points[points.length-1].xval;
// Extract the points we've selected
@@ -1000,7 +1203,7 @@ Dygraph.prototype.mouseMove_ = function(event) {
var px = this.lastx_;
if (px !== null && lastx != px) {
// only fire if the selected point has changed.
- this.attr_("highlightCallback")(event, lastx, this.selPoints_);
+ this.attr_("highlightCallback")(event, lastx, this.selPoints_, this.idxToRow_(idx));
}
}
@@ -1011,17 +1214,42 @@ Dygraph.prototype.mouseMove_ = function(event) {
};
/**
+ * Transforms layout_.points index into data row number.
+ * @param int layout_.points index
+ * @return int row number, or -1 if none could be found.
+ * @private
+ */
+Dygraph.prototype.idxToRow_ = function(idx) {
+ if (idx < 0) return -1;
+
+ for (var i in this.layout_.datasets) {
+ if (idx < this.layout_.datasets[i].length) {
+ return this.boundaryIds_[0][0]+idx;
+ }
+ idx -= this.layout_.datasets[i].length;
+ }
+ return -1;
+};
+
+/**
* Draw dots over the selectied points in the data series. This function
* takes care of cleanup of previously-drawn dots.
* @private
*/
Dygraph.prototype.updateSelection_ = function() {
// Clear the previously drawn vertical, if there is one
- var circleSize = this.attr_('highlightCircleSize');
var ctx = this.canvas_.getContext("2d");
if (this.previousVerticalX_ >= 0) {
+ // Determine the maximum highlight circle size.
+ var maxCircleSize = 0;
+ var labels = this.attr_('labels');
+ for (var i = 1; i < labels.length; i++) {
+ var r = this.attr_('highlightCircleSize', labels[i]);
+ if (r > maxCircleSize) maxCircleSize = r;
+ }
var px = this.previousVerticalX_;
- ctx.clearRect(px - circleSize - 1, 0, 2 * circleSize + 2, this.height_);
+ ctx.clearRect(px - maxCircleSize - 1, 0,
+ 2 * maxCircleSize + 2, this.height_);
}
var isOK = function(x) { return x && !isNaN(x); };
@@ -1037,13 +1265,13 @@ Dygraph.prototype.updateSelection_ = function() {
if (this.attr_('showLabelsOnHighlight')) {
// Set the status message to indicate the selected point(s)
for (var i = 0; i < this.selPoints_.length; i++) {
- if (!this.attr_("labelsShowZeroValues") && this.selPoints_[i].yval == 0) continue;
+ if (!this.attr_("labelsShowZeroValues") && this.selPoints_[i].yval == 0) continue;
if (!isOK(this.selPoints_[i].canvasy)) continue;
if (this.attr_("labelsSeparateLines")) {
replace += " ";
}
var point = this.selPoints_[i];
- var c = new RGBColor(this.colors_[i%clen]);
+ var c = new RGBColor(this.plotter_.colors[point.name]);
var yval = fmtFunc(point.yval);
replace += " "
+ point.name + ":"
@@ -1057,6 +1285,8 @@ Dygraph.prototype.updateSelection_ = function() {
ctx.save();
for (var i = 0; i < this.selPoints_.length; i++) {
if (!isOK(this.selPoints_[i].canvasy)) continue;
+ var circleSize =
+ this.attr_('highlightCircleSize', this.selPoints_[i].name);
ctx.beginPath();
ctx.fillStyle = this.plotter_.colors[this.selPoints_[i].name];
ctx.arc(canvasx, this.selPoints_[i].canvasy, circleSize,
@@ -1087,7 +1317,13 @@ Dygraph.prototype.setSelection = function(row) {
if (row !== false && row >= 0) {
for (var i in this.layout_.datasets) {
if (row < this.layout_.datasets[i].length) {
- this.selPoints_.push(this.layout_.points[pos+row]);
+ var point = this.layout_.points[pos+row];
+
+ if (this.attr_("stackedGraph")) {
+ point = this.layout_.unstackPointAtIndex(pos+row);
+ }
+
+ this.selPoints_.push(point);
}
pos += this.layout_.datasets[i].length;
}
@@ -1235,7 +1471,7 @@ Dygraph.round_ = function(num, places) {
*/
Dygraph.prototype.loadedEvent_ = function(data) {
this.rawData_ = this.parseCSV_(data);
- this.drawGraph_(this.rawData_);
+ this.predraw_();
};
Dygraph.prototype.months = ["Jan", "Feb", "Mar", "Apr", "May", "Jun",
@@ -1438,62 +1674,86 @@ Dygraph.dateTicker = function(startDate, endDate, self) {
* Add ticks when the x axis has numbers on it (instead of dates)
* @param {Number} startDate Start of the date window (millis since epoch)
* @param {Number} endDate End of the date window (millis since epoch)
+ * @param self
+ * @param {function} attribute accessor function.
* @return {Array.