dygraph-range-selector.js

   1 // Copyright 2011 Paul Felix (paul.eric.felix@gmail.com)
   2 // All Rights Reserved.
   3
   4 /**
   5  * @fileoverview This file contains the DygraphRangeSelector class used to provide
   6  * a timeline range selector widget for dygraphs.
   7  */
   8
   9 /*jshint globalstrict: true */
  10 /*global Dygraph:false */
  11 "use strict";
  12
  13 /**
  14  * The DygraphRangeSelector class provides a timeline range selector widget.
  15  * @param {Dygraph} dygraph The dygraph object
  16  * @constructor
  17  */
  18 var DygraphRangeSelector = function(dygraph) {
  19   this.isIE_ = /MSIE/.test(navigator.userAgent) && !window.opera;
  20   this.isUsingExcanvas_ = dygraph.isUsingExcanvas_;
  21   this.dygraph_ = dygraph;
  22   this.createCanvases_();
  23   if (this.isUsingExcanvas_) {
  24     this.createIEPanOverlay_();
  25   }
  26   this.createZoomHandles_();
  27   this.initInteraction_();
  28 };
  29
  30 /**
  31  * Adds the range selector to the dygraph.
  32  * @param {Object} graphDiv The container div for the range selector.
  33  * @param {DygraphLayout} layout The DygraphLayout object for this graph.
  34  */
  35 DygraphRangeSelector.prototype.addToGraph = function(graphDiv, layout) {
  36   this.layout_ = layout;
  37   this.resize_();
  38   graphDiv.appendChild(this.bgcanvas_);
  39   graphDiv.appendChild(this.fgcanvas_);
  40   graphDiv.appendChild(this.leftZoomHandle_);
  41   graphDiv.appendChild(this.rightZoomHandle_);
  42 };
  43
  44 /**
  45  * Renders the static background portion of the range selector.
  46  */
  47 DygraphRangeSelector.prototype.renderStaticLayer = function() {
  48   this.resize_();
  49   this.drawStaticLayer_();
  50 };
  51
  52 /**
  53  * Renders the interactive foreground portion of the range selector.
  54  */
  55 DygraphRangeSelector.prototype.renderInteractiveLayer = function() {
  56   if (this.isChangingRange_) {
  57     return;
  58   }
  59   this.placeZoomHandles_();
  60   this.drawInteractiveLayer_();
  61 };
  62
  63 /**
  64  * @private
  65  * Resizes the range selector.
  66  */
  67 DygraphRangeSelector.prototype.resize_ = function() {
  68   function setElementRect(canvas, rect) {
  69     canvas.style.top = rect.y + 'px';
  70     canvas.style.left = rect.x + 'px';
  71     canvas.width = rect.w;
  72     canvas.height = rect.h;
  73     canvas.style.width = canvas.width + 'px';    // for IE
  74     canvas.style.height = canvas.height + 'px';  // for IE
  75   }
  76
  77   var plotArea = this.layout_.getPlotArea();
  78   var xAxisLabelHeight = this.attr_('axisLabelFontSize') + 2 * this.attr_('axisTickSize');
  79   this.canvasRect_ = {
  80     x: plotArea.x,
  81     y: plotArea.y + plotArea.h + xAxisLabelHeight + 4,
  82     w: plotArea.w,
  83     h: this.attr_('rangeSelectorHeight')
  84   };
  85
  86   setElementRect(this.bgcanvas_, this.canvasRect_);
  87   setElementRect(this.fgcanvas_, this.canvasRect_);
  88 };
  89
  90 DygraphRangeSelector.prototype.attr_ = function(name) {
  91   return this.dygraph_.attr_(name);
  92 };
  93
  94 /**
  95  * @private
  96  * Creates the background and foreground canvases.
  97  */
  98 DygraphRangeSelector.prototype.createCanvases_ = function() {
  99   this.bgcanvas_ = Dygraph.createCanvas();
 100   this.bgcanvas_.className = 'dygraph-rangesel-bgcanvas';
 101   this.bgcanvas_.style.position = 'absolute';
 102   this.bgcanvas_.style.zIndex = 9;
 103   this.bgcanvas_ctx_ = Dygraph.getContext(this.bgcanvas_);
 104
 105   this.fgcanvas_ = Dygraph.createCanvas();
 106   this.fgcanvas_.className = 'dygraph-rangesel-fgcanvas';
 107   this.fgcanvas_.style.position = 'absolute';
 108   this.fgcanvas_.style.zIndex = 9;
 109   this.fgcanvas_.style.cursor = 'default';
 110   this.fgcanvas_ctx_ = Dygraph.getContext(this.fgcanvas_);
 111 };
 112
 113 /**
 114  * @private
 115  * Creates overlay divs for IE/Excanvas so that mouse events are handled properly.
 116  */
 117 DygraphRangeSelector.prototype.createIEPanOverlay_ = function() {
 118   this.iePanOverlay_ = document.createElement("div");
 119   this.iePanOverlay_.style.position = 'absolute';
 120   this.iePanOverlay_.style.backgroundColor = 'white';
 121   this.iePanOverlay_.style.filter = 'alpha(opacity=0)';
 122   this.iePanOverlay_.style.display = 'none';
 123   this.iePanOverlay_.style.cursor = 'move';
 124   this.fgcanvas_.appendChild(this.iePanOverlay_);
 125 };
 126
 127 /**
 128  * @private
 129  * Creates the zoom handle elements.
 130  */
 131 DygraphRangeSelector.prototype.createZoomHandles_ = function() {
 132   var img = new Image();
 133   img.className = 'dygraph-rangesel-zoomhandle';
 134   img.style.position = 'absolute';
 135   img.style.zIndex = 10;
 136   img.style.visibility = 'hidden'; // Initially hidden so they don't show up in the wrong place.
 137   img.style.cursor = 'col-resize';
 138   if (/MSIE 7/.test(navigator.userAgent)) { // IE7 doesn't support embedded src data.
 139       img.width = 7;
 140       img.height = 14;
 141       img.style.backgroundColor = 'white';
 142       img.style.border = '1px solid #333333'; // Just show box in IE7.
 143   } else {
 144       img.width = 9;
 145       img.height = 16;
 146       img.src = 'data:image/png;base64,' +
 147 'iVBORw0KGgoAAAANSUhEUgAAAAkAAAAQCAYAAADESFVDAAAAAXNSR0IArs4c6QAAAAZiS0dEANAA' +
 148 'zwDP4Z7KegAAAAlwSFlzAAAOxAAADsQBlSsOGwAAAAd0SU1FB9sHGw0cMqdt1UwAAAAZdEVYdENv' +
 149 'bW1lbnQAQ3JlYXRlZCB3aXRoIEdJTVBXgQ4XAAAAaElEQVQoz+3SsRFAQBCF4Z9WJM8KCDVwownl' +
 150 '6YXsTmCUsyKGkZzcl7zkz3YLkypgAnreFmDEpHkIwVOMfpdi9CEEN2nGpFdwD03yEqDtOgCaun7s' +
 151 'qSTDH32I1pQA2Pb9sZecAxc5r3IAb21d6878xsAAAAAASUVORK5CYII=';
 152   }
 153
 154   this.leftZoomHandle_ = img;
 155   this.rightZoomHandle_ = img.cloneNode(false);
 156 };
 157
 158 /**
 159  * @private
 160  * Sets up the interaction for the range selector.
 161  */
 162 DygraphRangeSelector.prototype.initInteraction_ = function() {
 163   var self = this;
 164   var topElem = this.isIE_ ? document : window;
 165   var xLast = 0;
 166   var handle = null;
 167   var isZooming = false;
 168   var isPanning = false;
 169
 170   // functions, defined below.  Defining them this way (rather than with
 171   // "function foo() {...}" makes JSHint happy.
 172   var toXDataWindow, onZoomStart, onZoom, onZoomEnd, doZoom, isMouseInPanZone,
 173       onPanStart, onPan, onPanEnd, doPan, onCanvasMouseMove;
 174
 175   toXDataWindow = function(zoomHandleStatus) {
 176     var xDataLimits = self.dygraph_.xAxisExtremes();
 177     var fact = (xDataLimits[1] - xDataLimits[0])/self.canvasRect_.w;
 178     var xDataMin = xDataLimits[0] + (zoomHandleStatus.leftHandlePos - self.canvasRect_.x)*fact;
 179     var xDataMax = xDataLimits[0] + (zoomHandleStatus.rightHandlePos - self.canvasRect_.x)*fact;
 180     return [xDataMin, xDataMax];
 181   };
 182
 183   onZoomStart = function(e) {
 184     Dygraph.cancelEvent(e);
 185     isZooming = true;
 186     xLast = e.screenX;
 187     handle = e.target ? e.target : e.srcElement;
 188     Dygraph.addEvent(topElem, 'mousemove', onZoom);
 189     Dygraph.addEvent(topElem, 'mouseup', onZoomEnd);
 190     self.fgcanvas_.style.cursor = 'col-resize';
 191   };
 192
 193   onZoom = function(e) {
 194     if (!isZooming) {
 195       return;
 196     }
 197     var delX = e.screenX - xLast;
 198     if (Math.abs(delX) < 4) {
 199       return;
 200     }
 201     xLast = e.screenX;
 202     var zoomHandleStatus = self.getZoomHandleStatus_();
 203     var newPos;
 204     if (handle == self.leftZoomHandle_) {
 205       newPos = zoomHandleStatus.leftHandlePos + delX;
 206       newPos = Math.min(newPos, zoomHandleStatus.rightHandlePos - handle.width - 3);
 207       newPos = Math.max(newPos, self.canvasRect_.x);
 208     } else {
 209       newPos = zoomHandleStatus.rightHandlePos + delX;
 210       newPos = Math.min(newPos, self.canvasRect_.x + self.canvasRect_.w);
 211       newPos = Math.max(newPos, zoomHandleStatus.leftHandlePos + handle.width + 3);
 212     }
 213     var halfHandleWidth = handle.width/2;
 214     handle.style.left = (newPos - halfHandleWidth) + 'px';
 215     self.drawInteractiveLayer_();
 216
 217     // Zoom on the fly (if not using excanvas).
 218     if (!self.isUsingExcanvas_) {
 219       doZoom();
 220     }
 221   };
 222
 223   onZoomEnd = function(e) {
 224     if (!isZooming) {
 225       return;
 226     }
 227     isZooming = false;
 228     Dygraph.removeEvent(topElem, 'mousemove', onZoom);
 229     Dygraph.removeEvent(topElem, 'mouseup', onZoomEnd);
 230     self.fgcanvas_.style.cursor = 'default';
 231
 232     // If using excanvas, Zoom now.
 233     if (self.isUsingExcanvas_) {
 234       doZoom();
 235     }
 236   };
 237
 238   doZoom = function() {
 239     try {
 240       var zoomHandleStatus = self.getZoomHandleStatus_();
 241       self.isChangingRange_ = true;
 242       if (!zoomHandleStatus.isZoomed) {
 243         self.dygraph_.doUnzoom_();
 244       } else {
 245         var xDataWindow = toXDataWindow(zoomHandleStatus);
 246         self.dygraph_.doZoomXDates_(xDataWindow[0], xDataWindow[1]);
 247       }
 248     } finally {
 249       self.isChangingRange_ = false;
 250     }
 251   };
 252
 253   isMouseInPanZone = function(e) {
 254     if (self.isUsingExcanvas_) {
 255         return e.srcElement == self.iePanOverlay_;
 256     } else {
 257       // Getting clientX directly from the event is not accurate enough :(
 258       var clientX = self.canvasRect_.x + (e.layerX !== undefined ? e.layerX : e.offsetX);
 259       var zoomHandleStatus = self.getZoomHandleStatus_();
 260       return (clientX > zoomHandleStatus.leftHandlePos && clientX < zoomHandleStatus.rightHandlePos);
 261     }
 262   };
 263
 264   onPanStart = function(e) {
 265     if (!isPanning && isMouseInPanZone(e) && self.getZoomHandleStatus_().isZoomed) {
 266       Dygraph.cancelEvent(e);
 267       isPanning = true;
 268       xLast = e.screenX;
 269       Dygraph.addEvent(topElem, 'mousemove', onPan);
 270       Dygraph.addEvent(topElem, 'mouseup', onPanEnd);
 271     }
 272   };
 273
 274   onPan = function(e) {
 275     if (!isPanning) {
 276       return;
 277     }
 278     Dygraph.cancelEvent(e);
 279
 280     var delX = e.screenX - xLast;
 281     if (Math.abs(delX) < 4) {
 282       return;
 283     }
 284     xLast = e.screenX;
 285
 286     // Move range view
 287     var zoomHandleStatus = self.getZoomHandleStatus_();
 288     var leftHandlePos = zoomHandleStatus.leftHandlePos;
 289     var rightHandlePos = zoomHandleStatus.rightHandlePos;
 290     var rangeSize = rightHandlePos - leftHandlePos;
 291     if (leftHandlePos + delX <= self.canvasRect_.x) {
 292       leftHandlePos = self.canvasRect_.x;
 293       rightHandlePos = leftHandlePos + rangeSize;
 294     } else if (rightHandlePos + delX >= self.canvasRect_.x + self.canvasRect_.w) {
 295       rightHandlePos = self.canvasRect_.x + self.canvasRect_.w;
 296       leftHandlePos = rightHandlePos - rangeSize;
 297     } else {
 298       leftHandlePos += delX;
 299       rightHandlePos += delX;
 300     }
 301     var halfHandleWidth = self.leftZoomHandle_.width/2;
 302     self.leftZoomHandle_.style.left = (leftHandlePos - halfHandleWidth) + 'px';
 303     self.rightZoomHandle_.style.left = (rightHandlePos - halfHandleWidth) + 'px';
 304     self.drawInteractiveLayer_();
 305
 306     // Do pan on the fly (if not using excanvas).
 307     if (!self.isUsingExcanvas_) {
 308       doPan();
 309     }
 310   };
 311
 312   onPanEnd = function(e) {
 313     if (!isPanning) {
 314       return;
 315     }
 316     isPanning = false;
 317     Dygraph.removeEvent(topElem, 'mousemove', onPan);
 318     Dygraph.removeEvent(topElem, 'mouseup', onPanEnd);
 319     // If using excanvas, do pan now.
 320     if (self.isUsingExcanvas_) {
 321       doPan();
 322     }
 323   };
 324
 325   doPan = function() {
 326     try {
 327       self.isChangingRange_ = true;
 328       self.dygraph_.dateWindow_ = toXDataWindow(self.getZoomHandleStatus_());
 329       self.dygraph_.drawGraph_(false);
 330     } finally {
 331       self.isChangingRange_ = false;
 332     }
 333   };
 334
 335   onCanvasMouseMove = function(e) {
 336     if (isZooming || isPanning) {
 337       return;
 338     }
 339     var cursor = isMouseInPanZone(e) ? 'move' : 'default';
 340     if (cursor != self.fgcanvas_.style.cursor) {
 341       self.fgcanvas_.style.cursor = cursor;
 342     }
 343   };
 344
 345   var interactionModel = {
 346     mousedown: function(event, g, context) {
 347       context.initializeMouseDown(event, g, context);
 348       Dygraph.startPan(event, g, context);
 349     },
 350     mousemove: function(event, g, context) {
 351       if (context.isPanning) {
 352         Dygraph.movePan(event, g, context);
 353       }
 354     },
 355     mouseup: function(event, g, context) {
 356       if (context.isPanning) {
 357         Dygraph.endPan(event, g, context);
 358       }
 359     }
 360   };
 361
 362   this.dygraph_.attrs_.interactionModel = interactionModel;
 363   this.dygraph_.attrs_.panEdgeFraction = 0.0001;
 364
 365   var dragStartEvent = window.opera ? 'mousedown' : 'dragstart';
 366   Dygraph.addEvent(this.leftZoomHandle_, dragStartEvent, onZoomStart);
 367   Dygraph.addEvent(this.rightZoomHandle_, dragStartEvent, onZoomStart);
 368
 369   if (this.isUsingExcanvas_) {
 370     Dygraph.addEvent(this.iePanOverlay_, 'mousedown', onPanStart);
 371   } else {
 372     Dygraph.addEvent(this.fgcanvas_, 'mousedown', onPanStart);
 373     Dygraph.addEvent(this.fgcanvas_, 'mousemove', onCanvasMouseMove);
 374   }
 375 };
 376
 377 /**
 378  * @private
 379  * Draws the static layer in the background canvas.
 380  */
 381 DygraphRangeSelector.prototype.drawStaticLayer_ = function() {
 382   var ctx = this.bgcanvas_ctx_;
 383   ctx.clearRect(0, 0, this.canvasRect_.w, this.canvasRect_.h);
 384   try {
 385     this.drawMiniPlot_();
 386   } catch(ex) {
 387     Dygraph.warn(ex);
 388   }
 389
 390   var margin = 0.5;
 391   this.bgcanvas_ctx_.lineWidth = 1;
 392   ctx.strokeStyle = 'gray';
 393   ctx.beginPath();
 394   ctx.moveTo(margin, margin);
 395   ctx.lineTo(margin, this.canvasRect_.h-margin);
 396   ctx.lineTo(this.canvasRect_.w-margin, this.canvasRect_.h-margin);
 397   ctx.lineTo(this.canvasRect_.w-margin, margin);
 398   ctx.stroke();
 399 };
 400
 401
 402 /**
 403  * @private
 404  * Draws the mini plot in the background canvas.
 405  */
 406 DygraphRangeSelector.prototype.drawMiniPlot_ = function() {
 407   var fillStyle = this.attr_('rangeSelectorPlotFillColor');
 408   var strokeStyle = this.attr_('rangeSelectorPlotStrokeColor');
 409   if (!fillStyle && !strokeStyle) {
 410     return;
 411   }
 412
 413   var combinedSeriesData = this.computeCombinedSeriesAndLimits_();
 414   var yRange = combinedSeriesData.yMax - combinedSeriesData.yMin;
 415
 416   // Draw the mini plot.
 417   var ctx = this.bgcanvas_ctx_;
 418   var margin = 0.5;
 419
 420   var xExtremes = this.dygraph_.xAxisExtremes();
 421   var xRange = Math.max(xExtremes[1] - xExtremes[0], 1.e-30);
 422   var xFact = (this.canvasRect_.w - margin)/xRange;
 423   var yFact = (this.canvasRect_.h - margin)/yRange;
 424   var canvasWidth = this.canvasRect_.w - margin;
 425   var canvasHeight = this.canvasRect_.h - margin;
 426
 427   ctx.beginPath();
 428   ctx.moveTo(margin, canvasHeight);
 429   for (var i = 0; i < combinedSeriesData.data.length; i++) {
 430     var dataPoint = combinedSeriesData.data[i];
 431     var x = (dataPoint[0] - xExtremes[0])*xFact;
 432     var y = canvasHeight - (dataPoint[1] - combinedSeriesData.yMin)*yFact;
 433     if (isFinite(x) && isFinite(y)) {
 434       ctx.lineTo(x, y);
 435     }
 436   }
 437   ctx.lineTo(canvasWidth, canvasHeight);
 438   ctx.closePath();
 439
 440   if (fillStyle) {
 441     var lingrad = this.bgcanvas_ctx_.createLinearGradient(0, 0, 0, canvasHeight);
 442     lingrad.addColorStop(0, 'white');
 443     lingrad.addColorStop(1, fillStyle);
 444     this.bgcanvas_ctx_.fillStyle = lingrad;
 445     ctx.fill();
 446   }
 447
 448   if (strokeStyle) {
 449     this.bgcanvas_ctx_.strokeStyle = strokeStyle;
 450     this.bgcanvas_ctx_.lineWidth = 1.5;
 451     ctx.stroke();
 452   }
 453 };
 454
 455 /**
 456  * @private
 457  * Computes and returns the combinded series data along with min/max for the mini plot.
 458  * @return {Object} An object containing combinded series array, ymin, ymax.
 459  */
 460 DygraphRangeSelector.prototype.computeCombinedSeriesAndLimits_ = function() {
 461   var data = this.dygraph_.rawData_;
 462   var logscale = this.attr_('logscale');
 463
 464   // Create a combined series (average of all series values).
 465   var combinedSeries = [];
 466   var sum;
 467   var count;
 468   var yVal, y;
 469   var mutipleValues;
 470   var i, j, k;
 471
 472   // Find out if data has multiple values per datapoint.
 473   // Go to first data point that actually has values (see http://code.google.com/p/dygraphs/issues/detail?id=246)
 474   for (i = 0; i < data.length; i++) {
 475     if (data[i].length > 1 && data[i][1] != null) {
 476       mutipleValues = typeof data[i][1] != 'number';
 477       if (mutipleValues) {
 478         sum = [];
 479         count = [];
 480         for (k = 0; k < data[i][1].length; k++) {
 481           sum.push(0);
 482           count.push(0);
 483         }
 484       }
 485       break;
 486     }
 487   }
 488
 489   for (i = 0; i < data.length; i++) {
 490     var dataPoint = data[i];
 491     var xVal = dataPoint[0];
 492
 493     if (mutipleValues) {
 494       for (k = 0; k < sum.length; k++) {
 495         sum[k] = count[k] = 0;
 496       }
 497     } else {
 498       sum = count = 0;
 499     }
 500
 501     for (j = 1; j < dataPoint.length; j++) {
 502       if (this.dygraph_.visibility()[j-1]) {
 503         if (mutipleValues) {
 504           for (k = 0; k < sum.length; k++) {
 505             y = dataPoint[j][k];
 506             if (y === null || isNaN(y)) continue;
 507             sum[k] += y;
 508             count[k]++;
 509           }
 510         } else {
 511           y = dataPoint[j];
 512           if (y === null || isNaN(y)) continue;
 513           sum += y;
 514           count++;
 515         }
 516       }
 517     }
 518
 519     if (mutipleValues) {
 520       for (k = 0; k < sum.length; k++) {
 521         sum[k] /= count[k];
 522       }
 523       yVal = sum.slice(0);
 524     } else {
 525       yVal = sum/count;
 526     }
 527
 528     combinedSeries.push([xVal, yVal]);
 529   }
 530
 531   // Account for roll period, fractions.
 532   combinedSeries = this.dygraph_.rollingAverage(combinedSeries, this.dygraph_.rollPeriod_);
 533
 534   if (typeof combinedSeries[0][1] != 'number') {
 535     for (i = 0; i < combinedSeries.length; i++) {
 536       yVal = combinedSeries[i][1];
 537       combinedSeries[i][1] = yVal[0];
 538     }
 539   }
 540
 541   // Compute the y range.
 542   var yMin = Number.MAX_VALUE;
 543   var yMax = -Number.MAX_VALUE;
 544   for (i = 0; i < combinedSeries.length; i++) {
 545     yVal = combinedSeries[i][1];
 546     if (yVal !== null && isFinite(yVal) && (!logscale || yVal > 0)) {
 547       yMin = Math.min(yMin, yVal);
 548       yMax = Math.max(yMax, yVal);
 549     }
 550   }
 551
 552   // Convert Y data to log scale if needed.
 553   // Also, expand the Y range to compress the mini plot a little.
 554   var extraPercent = 0.25;
 555   if (logscale) {
 556     yMax = Dygraph.log10(yMax);
 557     yMax += yMax*extraPercent;
 558     yMin = Dygraph.log10(yMin);
 559     for (i = 0; i < combinedSeries.length; i++) {
 560       combinedSeries[i][1] = Dygraph.log10(combinedSeries[i][1]);
 561     }
 562   } else {
 563     var yExtra;
 564     var yRange = yMax - yMin;
 565     if (yRange <= Number.MIN_VALUE) {
 566       yExtra = yMax*extraPercent;
 567     } else {
 568       yExtra = yRange*extraPercent;
 569     }
 570     yMax += yExtra;
 571     yMin -= yExtra;
 572   }
 573
 574   return {data: combinedSeries, yMin: yMin, yMax: yMax};
 575 };
 576
 577 /**
 578  * @private
 579  * Places the zoom handles in the proper position based on the current X data window.
 580  */
 581 DygraphRangeSelector.prototype.placeZoomHandles_ = function() {
 582   var xExtremes = this.dygraph_.xAxisExtremes();
 583   var xWindowLimits = this.dygraph_.xAxisRange();
 584   var xRange = xExtremes[1] - xExtremes[0];
 585   var leftPercent = Math.max(0, (xWindowLimits[0] - xExtremes[0])/xRange);
 586   var rightPercent = Math.max(0, (xExtremes[1] - xWindowLimits[1])/xRange);
 587   var leftCoord = this.canvasRect_.x + this.canvasRect_.w*leftPercent;
 588   var rightCoord = this.canvasRect_.x + this.canvasRect_.w*(1 - rightPercent);
 589   var handleTop = Math.max(this.canvasRect_.y, this.canvasRect_.y + (this.canvasRect_.h - this.leftZoomHandle_.height)/2);
 590   var halfHandleWidth = this.leftZoomHandle_.width/2;
 591   this.leftZoomHandle_.style.left = (leftCoord - halfHandleWidth) + 'px';
 592   this.leftZoomHandle_.style.top = handleTop + 'px';
 593   this.rightZoomHandle_.style.left = (rightCoord - halfHandleWidth) + 'px';
 594   this.rightZoomHandle_.style.top = this.leftZoomHandle_.style.top;
 595
 596   this.leftZoomHandle_.style.visibility = 'visible';
 597   this.rightZoomHandle_.style.visibility = 'visible';
 598 };
 599
 600 /**
 601  * @private
 602  * Draws the interactive layer in the foreground canvas.
 603  */
 604 DygraphRangeSelector.prototype.drawInteractiveLayer_ = function() {
 605   var ctx = this.fgcanvas_ctx_;
 606   ctx.clearRect(0, 0, this.canvasRect_.w, this.canvasRect_.h);
 607   var margin = 1;
 608   var width = this.canvasRect_.w - margin;
 609   var height = this.canvasRect_.h - margin;
 610   var zoomHandleStatus = this.getZoomHandleStatus_();
 611
 612   ctx.strokeStyle = 'black';
 613   if (!zoomHandleStatus.isZoomed) {
 614     ctx.beginPath();
 615     ctx.moveTo(margin, margin);
 616     ctx.lineTo(margin, height);
 617     ctx.lineTo(width, height);
 618     ctx.lineTo(width, margin);
 619     ctx.stroke();
 620     if (this.iePanOverlay_) {
 621       this.iePanOverlay_.style.display = 'none';
 622     }
 623   } else {
 624     var leftHandleCanvasPos = Math.max(margin, zoomHandleStatus.leftHandlePos - this.canvasRect_.x);
 625     var rightHandleCanvasPos = Math.min(width, zoomHandleStatus.rightHandlePos - this.canvasRect_.x);
 626
 627     ctx.fillStyle = 'rgba(240, 240, 240, 0.6)';
 628     ctx.fillRect(0, 0, leftHandleCanvasPos, this.canvasRect_.h);
 629     ctx.fillRect(rightHandleCanvasPos, 0, this.canvasRect_.w - rightHandleCanvasPos, this.canvasRect_.h);
 630
 631     ctx.beginPath();
 632     ctx.moveTo(margin, margin);
 633     ctx.lineTo(leftHandleCanvasPos, margin);
 634     ctx.lineTo(leftHandleCanvasPos, height);
 635     ctx.lineTo(rightHandleCanvasPos, height);
 636     ctx.lineTo(rightHandleCanvasPos, margin);
 637     ctx.lineTo(width, margin);
 638     ctx.stroke();
 639
 640     if (this.isUsingExcanvas_) {
 641       this.iePanOverlay_.style.width = (rightHandleCanvasPos - leftHandleCanvasPos) + 'px';
 642       this.iePanOverlay_.style.left = leftHandleCanvasPos + 'px';
 643       this.iePanOverlay_.style.height = height + 'px';
 644       this.iePanOverlay_.style.display = 'inline';
 645     }
 646   }
 647 };
 648
 649 /**
 650  * @private
 651  * Returns the current zoom handle position information.
 652  * @return {Object} The zoom handle status.
 653  */
 654 DygraphRangeSelector.prototype.getZoomHandleStatus_ = function() {
 655   var halfHandleWidth = this.leftZoomHandle_.width/2;
 656   var leftHandlePos = parseInt(this.leftZoomHandle_.style.left, 10) + halfHandleWidth;
 657   var rightHandlePos = parseInt(this.rightZoomHandle_.style.left, 10) + halfHandleWidth;
 658   return {
 659       leftHandlePos: leftHandlePos,
 660       rightHandlePos: rightHandlePos,
 661       isZoomed: (leftHandlePos - 1 > this.canvasRect_.x || rightHandlePos + 1 < this.canvasRect_.x+this.canvasRect_.w)
 662   };
 663 };