Clean up some zooming oddities; fixes issues 434 and 280
[dygraphs.git] / dygraph-interaction-model.js
CommitLineData
88e95c46
DV
1/**
2 * @license
3 * Copyright 2011 Robert Konigsberg (konigsberg@google.com)
4 * MIT-licensed (http://opensource.org/licenses/MIT)
5 */
846f3d2d 6
88e95c46 7/**
846f3d2d
DV
8 * @fileoverview The default interaction model for Dygraphs. This is kept out
9 * of dygraph.js for better navigability.
10 * @author Robert Konigsberg (konigsberg@google.com)
11 */
12
758a629f
DV
13/*jshint globalstrict: true */
14/*global Dygraph:false */
c0f54d4f
DV
15"use strict";
16
846f3d2d
DV
17/**
18 * A collection of functions to facilitate build custom interaction models.
19 * @class
20 */
21Dygraph.Interaction = {};
22
23/**
24 * Called in response to an interaction model operation that
25 * should start the default panning behavior.
26 *
27 * It's used in the default callback for "mousedown" operations.
28 * Custom interaction model builders can use it to provide the default
29 * panning behavior.
30 *
d67a4279
DV
31 * @param {Event} event the event object which led to the startPan call.
32 * @param {Dygraph} g The dygraph on which to act.
33 * @param {Object} context The dragging context object (with
34 * dragStartX/dragStartY/etc. properties). This function modifies the
35 * context.
846f3d2d
DV
36 */
37Dygraph.Interaction.startPan = function(event, g, context) {
758a629f 38 var i, axis;
846f3d2d
DV
39 context.isPanning = true;
40 var xRange = g.xAxisRange();
41 context.dateRange = xRange[1] - xRange[0];
42 context.initialLeftmostDate = xRange[0];
43 context.xUnitsPerPixel = context.dateRange / (g.plotter_.area.w - 1);
44
45 if (g.attr_("panEdgeFraction")) {
46 var maxXPixelsToDraw = g.width_ * g.attr_("panEdgeFraction");
47 var xExtremes = g.xAxisExtremes(); // I REALLY WANT TO CALL THIS xTremes!
48
49 var boundedLeftX = g.toDomXCoord(xExtremes[0]) - maxXPixelsToDraw;
50 var boundedRightX = g.toDomXCoord(xExtremes[1]) + maxXPixelsToDraw;
51
52 var boundedLeftDate = g.toDataXCoord(boundedLeftX);
53 var boundedRightDate = g.toDataXCoord(boundedRightX);
54 context.boundedDates = [boundedLeftDate, boundedRightDate];
55
56 var boundedValues = [];
57 var maxYPixelsToDraw = g.height_ * g.attr_("panEdgeFraction");
58
758a629f
DV
59 for (i = 0; i < g.axes_.length; i++) {
60 axis = g.axes_[i];
846f3d2d
DV
61 var yExtremes = axis.extremeRange;
62
63 var boundedTopY = g.toDomYCoord(yExtremes[0], i) + maxYPixelsToDraw;
64 var boundedBottomY = g.toDomYCoord(yExtremes[1], i) - maxYPixelsToDraw;
65
66 var boundedTopValue = g.toDataYCoord(boundedTopY);
67 var boundedBottomValue = g.toDataYCoord(boundedBottomY);
68
69 boundedValues[i] = [boundedTopValue, boundedBottomValue];
70 }
71 context.boundedValues = boundedValues;
72 }
73
74 // Record the range of each y-axis at the start of the drag.
75 // If any axis has a valueRange or valueWindow, then we want a 2D pan.
97583b90
DV
76 // We can't store data directly in g.axes_, because it does not belong to us
77 // and could change out from under us during a pan (say if there's a data
78 // update).
846f3d2d 79 context.is2DPan = false;
97583b90 80 context.axes = [];
758a629f
DV
81 for (i = 0; i < g.axes_.length; i++) {
82 axis = g.axes_[i];
97583b90 83 var axis_data = {};
846f3d2d
DV
84 var yRange = g.yAxisRange(i);
85 // TODO(konigsberg): These values should be in |context|.
86 // In log scale, initialTopValue, dragValueRange and unitsPerPixel are log scale.
1ca77443
RK
87 var logscale = g.attributes_.getForAxis("logscale", i);
88 if (logscale) {
97583b90
DV
89 axis_data.initialTopValue = Dygraph.log10(yRange[1]);
90 axis_data.dragValueRange = Dygraph.log10(yRange[1]) - Dygraph.log10(yRange[0]);
846f3d2d 91 } else {
97583b90
DV
92 axis_data.initialTopValue = yRange[1];
93 axis_data.dragValueRange = yRange[1] - yRange[0];
846f3d2d 94 }
97583b90
DV
95 axis_data.unitsPerPixel = axis_data.dragValueRange / (g.plotter_.area.h - 1);
96 context.axes.push(axis_data);
846f3d2d
DV
97
98 // While calculating axes, set 2dpan.
99 if (axis.valueWindow || axis.valueRange) context.is2DPan = true;
100 }
101};
102
103/**
104 * Called in response to an interaction model operation that
105 * responds to an event that pans the view.
106 *
107 * It's used in the default callback for "mousemove" operations.
108 * Custom interaction model builders can use it to provide the default
109 * panning behavior.
110 *
d67a4279
DV
111 * @param {Event} event the event object which led to the movePan call.
112 * @param {Dygraph} g The dygraph on which to act.
113 * @param {Object} context The dragging context object (with
114 * dragStartX/dragStartY/etc. properties). This function modifies the
115 * context.
846f3d2d
DV
116 */
117Dygraph.Interaction.movePan = function(event, g, context) {
118 context.dragEndX = g.dragGetX_(event, context);
119 context.dragEndY = g.dragGetY_(event, context);
120
121 var minDate = context.initialLeftmostDate -
122 (context.dragEndX - context.dragStartX) * context.xUnitsPerPixel;
123 if (context.boundedDates) {
124 minDate = Math.max(minDate, context.boundedDates[0]);
125 }
126 var maxDate = minDate + context.dateRange;
127 if (context.boundedDates) {
128 if (maxDate > context.boundedDates[1]) {
129 // Adjust minDate, and recompute maxDate.
130 minDate = minDate - (maxDate - context.boundedDates[1]);
131 maxDate = minDate + context.dateRange;
132 }
133 }
134
135 g.dateWindow_ = [minDate, maxDate];
136
137 // y-axis scaling is automatic unless this is a full 2D pan.
138 if (context.is2DPan) {
139 // Adjust each axis appropriately.
140 for (var i = 0; i < g.axes_.length; i++) {
141 var axis = g.axes_[i];
97583b90 142 var axis_data = context.axes[i];
846f3d2d
DV
143
144 var pixelsDragged = context.dragEndY - context.dragStartY;
97583b90 145 var unitsDragged = pixelsDragged * axis_data.unitsPerPixel;
920208fb 146
846f3d2d
DV
147 var boundedValue = context.boundedValues ? context.boundedValues[i] : null;
148
149 // In log scale, maxValue and minValue are the logs of those values.
97583b90 150 var maxValue = axis_data.initialTopValue + unitsDragged;
846f3d2d
DV
151 if (boundedValue) {
152 maxValue = Math.min(maxValue, boundedValue[1]);
153 }
97583b90 154 var minValue = maxValue - axis_data.dragValueRange;
846f3d2d
DV
155 if (boundedValue) {
156 if (minValue < boundedValue[0]) {
157 // Adjust maxValue, and recompute minValue.
158 maxValue = maxValue - (minValue - boundedValue[0]);
97583b90 159 minValue = maxValue - axis_data.dragValueRange;
846f3d2d
DV
160 }
161 }
1ca77443
RK
162 var logscale = g.attributes_.getForAxis("logscale", i);
163 if (logscale) {
846f3d2d
DV
164 axis.valueWindow = [ Math.pow(Dygraph.LOG_SCALE, minValue),
165 Math.pow(Dygraph.LOG_SCALE, maxValue) ];
166 } else {
167 axis.valueWindow = [ minValue, maxValue ];
168 }
169 }
170 }
171
172 g.drawGraph_(false);
173};
174
175/**
176 * Called in response to an interaction model operation that
177 * responds to an event that ends panning.
178 *
179 * It's used in the default callback for "mouseup" operations.
180 * Custom interaction model builders can use it to provide the default
181 * panning behavior.
182 *
d67a4279
DV
183 * @param {Event} event the event object which led to the endPan call.
184 * @param {Dygraph} g The dygraph on which to act.
185 * @param {Object} context The dragging context object (with
186 * dragStartX/dragStartY/etc. properties). This function modifies the
187 * context.
846f3d2d
DV
188 */
189Dygraph.Interaction.endPan = function(event, g, context) {
190 context.dragEndX = g.dragGetX_(event, context);
191 context.dragEndY = g.dragGetY_(event, context);
192
193 var regionWidth = Math.abs(context.dragEndX - context.dragStartX);
194 var regionHeight = Math.abs(context.dragEndY - context.dragStartY);
195
196 if (regionWidth < 2 && regionHeight < 2 &&
758a629f 197 g.lastx_ !== undefined && g.lastx_ != -1) {
846f3d2d
DV
198 Dygraph.Interaction.treatMouseOpAsClick(g, event, context);
199 }
200
846f3d2d
DV
201 // TODO(konigsberg): mouseup should just delete the
202 // context object, and mousedown should create a new one.
203 context.isPanning = false;
204 context.is2DPan = false;
205 context.initialLeftmostDate = null;
206 context.dateRange = null;
207 context.valueRange = null;
208 context.boundedDates = null;
209 context.boundedValues = null;
97583b90 210 context.axes = null;
846f3d2d
DV
211};
212
213/**
214 * Called in response to an interaction model operation that
215 * responds to an event that starts zooming.
216 *
217 * It's used in the default callback for "mousedown" operations.
218 * Custom interaction model builders can use it to provide the default
219 * zooming behavior.
220 *
d67a4279
DV
221 * @param {Event} event the event object which led to the startZoom call.
222 * @param {Dygraph} g The dygraph on which to act.
223 * @param {Object} context The dragging context object (with
224 * dragStartX/dragStartY/etc. properties). This function modifies the
225 * context.
846f3d2d
DV
226 */
227Dygraph.Interaction.startZoom = function(event, g, context) {
228 context.isZooming = true;
214083b4 229 context.zoomMoved = false;
846f3d2d
DV
230};
231
232/**
233 * Called in response to an interaction model operation that
234 * responds to an event that defines zoom boundaries.
235 *
236 * It's used in the default callback for "mousemove" operations.
237 * Custom interaction model builders can use it to provide the default
238 * zooming behavior.
239 *
d67a4279
DV
240 * @param {Event} event the event object which led to the moveZoom call.
241 * @param {Dygraph} g The dygraph on which to act.
242 * @param {Object} context The dragging context object (with
243 * dragStartX/dragStartY/etc. properties). This function modifies the
244 * context.
846f3d2d
DV
245 */
246Dygraph.Interaction.moveZoom = function(event, g, context) {
214083b4 247 context.zoomMoved = true;
846f3d2d
DV
248 context.dragEndX = g.dragGetX_(event, context);
249 context.dragEndY = g.dragGetY_(event, context);
250
251 var xDelta = Math.abs(context.dragStartX - context.dragEndX);
252 var yDelta = Math.abs(context.dragStartY - context.dragEndY);
253
254 // drag direction threshold for y axis is twice as large as x axis
255 context.dragDirection = (xDelta < yDelta / 2) ? Dygraph.VERTICAL : Dygraph.HORIZONTAL;
256
257 g.drawZoomRect_(
258 context.dragDirection,
259 context.dragStartX,
260 context.dragEndX,
261 context.dragStartY,
262 context.dragEndY,
263 context.prevDragDirection,
264 context.prevEndX,
265 context.prevEndY);
266
267 context.prevEndX = context.dragEndX;
268 context.prevEndY = context.dragEndY;
269 context.prevDragDirection = context.dragDirection;
270};
271
d67a4279
DV
272/**
273 * @param {Dygraph} g
274 * @param {Event} event
275 * @param {Object} context
276 */
846f3d2d
DV
277Dygraph.Interaction.treatMouseOpAsClick = function(g, event, context) {
278 var clickCallback = g.attr_('clickCallback');
279 var pointClickCallback = g.attr_('pointClickCallback');
280
281 var selectedPoint = null;
282
d67a4279
DV
283 // Find out if the click occurs on a point. This only matters if there's a
284 // pointClickCallback.
846f3d2d
DV
285 if (pointClickCallback) {
286 var closestIdx = -1;
287 var closestDistance = Number.MAX_VALUE;
288
289 // check if the click was on a particular point.
290 for (var i = 0; i < g.selPoints_.length; i++) {
291 var p = g.selPoints_[i];
292 var distance = Math.pow(p.canvasx - context.dragEndX, 2) +
293 Math.pow(p.canvasy - context.dragEndY, 2);
fbff6d71
DV
294 if (!isNaN(distance) &&
295 (closestIdx == -1 || distance < closestDistance)) {
846f3d2d
DV
296 closestDistance = distance;
297 closestIdx = i;
298 }
299 }
300
301 // Allow any click within two pixels of the dot.
302 var radius = g.attr_('highlightCircleSize') + 2;
303 if (closestDistance <= radius * radius) {
304 selectedPoint = g.selPoints_[closestIdx];
305 }
306 }
307
308 if (selectedPoint) {
309 pointClickCallback(event, selectedPoint);
310 }
311
312 // TODO(danvk): pass along more info about the points, e.g. 'x'
313 if (clickCallback) {
314 clickCallback(event, g.lastx_, g.selPoints_);
315 }
316};
317
318/**
319 * Called in response to an interaction model operation that
320 * responds to an event that performs a zoom based on previously defined
321 * bounds..
322 *
323 * It's used in the default callback for "mouseup" operations.
324 * Custom interaction model builders can use it to provide the default
325 * zooming behavior.
326 *
d67a4279
DV
327 * @param {Event} event the event object which led to the endZoom call.
328 * @param {Dygraph} g The dygraph on which to end the zoom.
329 * @param {Object} context The dragging context object (with
330 * dragStartX/dragStartY/etc. properties). This function modifies the
331 * context.
846f3d2d
DV
332 */
333Dygraph.Interaction.endZoom = function(event, g, context) {
334 context.isZooming = false;
335 context.dragEndX = g.dragGetX_(event, context);
336 context.dragEndY = g.dragGetY_(event, context);
337 var regionWidth = Math.abs(context.dragEndX - context.dragStartX);
338 var regionHeight = Math.abs(context.dragEndY - context.dragStartY);
339
340 if (regionWidth < 2 && regionHeight < 2 &&
758a629f 341 g.lastx_ !== undefined && g.lastx_ != -1) {
846f3d2d
DV
342 Dygraph.Interaction.treatMouseOpAsClick(g, event, context);
343 }
344
b04888cc
DV
345 // The zoom rectangle is visibly clipped to the plot area, so its behavior
346 // should be as well.
347 // See http://code.google.com/p/dygraphs/issues/detail?id=280
348 var plotArea = g.getArea();
846f3d2d 349 if (regionWidth >= 10 && context.dragDirection == Dygraph.HORIZONTAL) {
b04888cc
DV
350 var left = Math.min(context.dragStartX, context.dragEndX),
351 right = Math.max(context.dragStartX, context.dragEndX);
352 g.doZoomX_(Math.max(left, plotArea.x),
353 Math.min(right, plotArea.x + plotArea.w));
421f1773 354 context.cancelNextDblclick = true;
846f3d2d 355 } else if (regionHeight >= 10 && context.dragDirection == Dygraph.VERTICAL) {
b04888cc
DV
356 var top = Math.min(context.dragStartY, context.dragEndY),
357 bottom = Math.max(context.dragStartY, context.dragEndY);
358 g.doZoomY_(Math.max(top, plotArea.y),
359 Math.min(bottom, plotArea.y + plotArea.h));
421f1773 360 context.cancelNextDblclick = true;
846f3d2d 361 } else {
42b3b41f 362 if (context.zoomMoved) g.clearZoomRect_();
846f3d2d
DV
363 }
364 context.dragStartX = null;
365 context.dragStartY = null;
366};
367
368/**
6125fedf
DV
369 * @private
370 */
371Dygraph.Interaction.startTouch = function(event, g, context) {
372 event.preventDefault(); // touch browsers are all nice.
b19d7411
DV
373 if (event.touches.length > 1) {
374 // If the user ever puts two fingers down, it's not a double tap.
375 context.startTimeForDoubleTapMs = null;
376 }
377
6125fedf
DV
378 var touches = [];
379 for (var i = 0; i < event.touches.length; i++) {
380 var t = event.touches[i];
381 // we dispense with 'dragGetX_' because all touchBrowsers support pageX
382 touches.push({
383 pageX: t.pageX,
384 pageY: t.pageY,
385 dataX: g.toDataXCoord(t.pageX),
386 dataY: g.toDataYCoord(t.pageY)
387 // identifier: t.identifier
388 });
389 }
390 context.initialTouches = touches;
391
392 if (touches.length == 1) {
393 // This is just a swipe.
394 context.initialPinchCenter = touches[0];
395 context.touchDirections = { x: true, y: true };
48cdd6c4 396 } else if (touches.length >= 2) {
6125fedf 397 // It's become a pinch!
48cdd6c4 398 // In case there are 3+ touches, we ignore all but the "first" two.
6125fedf
DV
399
400 // only screen coordinates can be averaged (data coords could be log scale).
401 context.initialPinchCenter = {
402 pageX: 0.5 * (touches[0].pageX + touches[1].pageX),
403 pageY: 0.5 * (touches[0].pageY + touches[1].pageY),
404
405 // TODO(danvk): remove
406 dataX: 0.5 * (touches[0].dataX + touches[1].dataX),
e446c952 407 dataY: 0.5 * (touches[0].dataY + touches[1].dataY)
6125fedf
DV
408 };
409
410 // Make pinches in a 45-degree swath around either axis 1-dimensional zooms.
411 var initialAngle = 180 / Math.PI * Math.atan2(
412 context.initialPinchCenter.pageY - touches[0].pageY,
413 touches[0].pageX - context.initialPinchCenter.pageX);
414
415 // use symmetry to get it into the first quadrant.
416 initialAngle = Math.abs(initialAngle);
417 if (initialAngle > 90) initialAngle = 90 - initialAngle;
418
419 context.touchDirections = {
420 x: (initialAngle < (90 - 45/2)),
421 y: (initialAngle > 45/2)
422 };
423 }
424
425 // save the full x & y ranges.
426 context.initialRange = {
427 x: g.xAxisRange(),
428 y: g.yAxisRange()
429 };
430};
431
432/**
433 * @private
434 */
435Dygraph.Interaction.moveTouch = function(event, g, context) {
b19d7411
DV
436 // If the tap moves, then it's definitely not part of a double-tap.
437 context.startTimeForDoubleTapMs = null;
438
e446c952
DV
439 var i, touches = [];
440 for (i = 0; i < event.touches.length; i++) {
6125fedf
DV
441 var t = event.touches[i];
442 touches.push({
443 pageX: t.pageX,
e446c952 444 pageY: t.pageY
6125fedf
DV
445 });
446 }
447 var initialTouches = context.initialTouches;
448
449 var c_now;
450
451 // old and new centers.
452 var c_init = context.initialPinchCenter;
453 if (touches.length == 1) {
454 c_now = touches[0];
455 } else {
456 c_now = {
457 pageX: 0.5 * (touches[0].pageX + touches[1].pageX),
458 pageY: 0.5 * (touches[0].pageY + touches[1].pageY)
459 };
460 }
461
462 // this is the "swipe" component
463 // we toss it out for now, but could use it in the future.
464 var swipe = {
465 pageX: c_now.pageX - c_init.pageX,
e446c952 466 pageY: c_now.pageY - c_init.pageY
6125fedf
DV
467 };
468 var dataWidth = context.initialRange.x[1] - context.initialRange.x[0];
469 var dataHeight = context.initialRange.y[0] - context.initialRange.y[1];
470 swipe.dataX = (swipe.pageX / g.plotter_.area.w) * dataWidth;
471 swipe.dataY = (swipe.pageY / g.plotter_.area.h) * dataHeight;
472 var xScale, yScale;
473
474 // The residual bits are usually split into scale & rotate bits, but we split
475 // them into x-scale and y-scale bits.
476 if (touches.length == 1) {
477 xScale = 1.0;
478 yScale = 1.0;
48cdd6c4 479 } else if (touches.length >= 2) {
6125fedf
DV
480 var initHalfWidth = (initialTouches[1].pageX - c_init.pageX);
481 xScale = (touches[1].pageX - c_now.pageX) / initHalfWidth;
482
483 var initHalfHeight = (initialTouches[1].pageY - c_init.pageY);
484 yScale = (touches[1].pageY - c_now.pageY) / initHalfHeight;
485 }
486
487 // Clip scaling to [1/8, 8] to prevent too much blowup.
488 xScale = Math.min(8, Math.max(0.125, xScale));
489 yScale = Math.min(8, Math.max(0.125, yScale));
490
b38afae5 491 var didZoom = false;
6125fedf
DV
492 if (context.touchDirections.x) {
493 g.dateWindow_ = [
494 c_init.dataX - swipe.dataX + (context.initialRange.x[0] - c_init.dataX) / xScale,
e446c952 495 c_init.dataX - swipe.dataX + (context.initialRange.x[1] - c_init.dataX) / xScale
6125fedf 496 ];
b38afae5 497 didZoom = true;
6125fedf
DV
498 }
499
500 if (context.touchDirections.y) {
e446c952 501 for (i = 0; i < 1 /*g.axes_.length*/; i++) {
6125fedf 502 var axis = g.axes_[i];
1ca77443
RK
503 var logscale = g.attributes_.getForAxis("logscale", i);
504 if (logscale) {
6125fedf
DV
505 // TODO(danvk): implement
506 } else {
507 axis.valueWindow = [
508 c_init.dataY - swipe.dataY + (context.initialRange.y[0] - c_init.dataY) / yScale,
e446c952 509 c_init.dataY - swipe.dataY + (context.initialRange.y[1] - c_init.dataY) / yScale
6125fedf 510 ];
b38afae5 511 didZoom = true;
6125fedf
DV
512 }
513 }
514 }
515
516 g.drawGraph_(false);
b38afae5
DV
517
518 // We only call zoomCallback on zooms, not pans, to mirror desktop behavior.
519 if (didZoom && touches.length > 1 && g.attr_('zoomCallback')) {
520 var viewWindow = g.xAxisRange();
521 g.attr_("zoomCallback")(viewWindow[0], viewWindow[1], g.yAxisRanges());
522 }
6125fedf
DV
523};
524
525/**
526 * @private
527 */
528Dygraph.Interaction.endTouch = function(event, g, context) {
42a9ebb8 529 if (event.touches.length !== 0) {
6125fedf
DV
530 // this is effectively a "reset"
531 Dygraph.Interaction.startTouch(event, g, context);
b19d7411
DV
532 } else if (event.changedTouches.length == 1) {
533 // Could be part of a "double tap"
534 // The heuristic here is that it's a double-tap if the two touchend events
535 // occur within 500ms and within a 50x50 pixel box.
536 var now = new Date().getTime();
537 var t = event.changedTouches[0];
538 if (context.startTimeForDoubleTapMs &&
539 now - context.startTimeForDoubleTapMs < 500 &&
540 context.doubleTapX && Math.abs(context.doubleTapX - t.screenX) < 50 &&
541 context.doubleTapY && Math.abs(context.doubleTapY - t.screenY) < 50) {
542 g.resetZoom();
543 } else {
544 context.startTimeForDoubleTapMs = now;
545 context.doubleTapX = t.screenX;
546 context.doubleTapY = t.screenY;
547 }
6125fedf
DV
548 }
549};
550
551/**
846f3d2d
DV
552 * Default interation model for dygraphs. You can refer to specific elements of
553 * this when constructing your own interaction model, e.g.:
554 * g.updateOptions( {
555 * interactionModel: {
556 * mousedown: Dygraph.defaultInteractionModel.mousedown
557 * }
558 * } );
559 */
560Dygraph.Interaction.defaultModel = {
561 // Track the beginning of drag events
562 mousedown: function(event, g, context) {
e992d194
DV
563 // Right-click should not initiate a zoom.
564 if (event.button && event.button == 2) return;
565
846f3d2d
DV
566 context.initializeMouseDown(event, g, context);
567
568 if (event.altKey || event.shiftKey) {
569 Dygraph.startPan(event, g, context);
570 } else {
571 Dygraph.startZoom(event, g, context);
572 }
573 },
574
575 // Draw zoom rectangles when the mouse is down and the user moves around
576 mousemove: function(event, g, context) {
577 if (context.isZooming) {
578 Dygraph.moveZoom(event, g, context);
579 } else if (context.isPanning) {
580 Dygraph.movePan(event, g, context);
581 }
582 },
583
584 mouseup: function(event, g, context) {
585 if (context.isZooming) {
586 Dygraph.endZoom(event, g, context);
587 } else if (context.isPanning) {
588 Dygraph.endPan(event, g, context);
589 }
590 },
591
6125fedf
DV
592 touchstart: function(event, g, context) {
593 Dygraph.Interaction.startTouch(event, g, context);
594 },
595 touchmove: function(event, g, context) {
596 Dygraph.Interaction.moveTouch(event, g, context);
597 },
598 touchend: function(event, g, context) {
599 Dygraph.Interaction.endTouch(event, g, context);
600 },
601
846f3d2d
DV
602 // Temporarily cancel the dragging event when the mouse leaves the graph
603 mouseout: function(event, g, context) {
604 if (context.isZooming) {
605 context.dragEndX = null;
606 context.dragEndY = null;
b04888cc 607 g.clearZoomRect_();
846f3d2d
DV
608 }
609 },
610
611 // Disable zooming out if panning.
612 dblclick: function(event, g, context) {
421f1773
DV
613 if (context.cancelNextDblclick) {
614 context.cancelNextDblclick = false;
615 return;
616 }
846f3d2d
DV
617 if (event.altKey || event.shiftKey) {
618 return;
619 }
e4f6e11a 620 g.resetZoom();
846f3d2d
DV
621 }
622};
623
624Dygraph.DEFAULT_ATTRS.interactionModel = Dygraph.Interaction.defaultModel;
625
626// old ways of accessing these methods/properties
627Dygraph.defaultInteractionModel = Dygraph.Interaction.defaultModel;
628Dygraph.endZoom = Dygraph.Interaction.endZoom;
629Dygraph.moveZoom = Dygraph.Interaction.moveZoom;
630Dygraph.startZoom = Dygraph.Interaction.startZoom;
631Dygraph.endPan = Dygraph.Interaction.endPan;
632Dygraph.movePan = Dygraph.Interaction.movePan;
633Dygraph.startPan = Dygraph.Interaction.startPan;
634
0290d079 635Dygraph.Interaction.nonInteractiveModel_ = {
027e9e9b
DV
636 mousedown: function(event, g, context) {
637 context.initializeMouseDown(event, g, context);
638 },
639 mouseup: function(event, g, context) {
640 // TODO(danvk): this logic is repeated in Dygraph.Interaction.endZoom
641 context.dragEndX = g.dragGetX_(event, context);
642 context.dragEndY = g.dragGetY_(event, context);
643 var regionWidth = Math.abs(context.dragEndX - context.dragStartX);
644 var regionHeight = Math.abs(context.dragEndY - context.dragStartY);
645
646 if (regionWidth < 2 && regionHeight < 2 &&
758a629f 647 g.lastx_ !== undefined && g.lastx_ != -1) {
027e9e9b
DV
648 Dygraph.Interaction.treatMouseOpAsClick(g, event, context);
649 }
650 }
651};
3417f017
DV
652
653// Default interaction model when using the range selector.
654Dygraph.Interaction.dragIsPanInteractionModel = {
655 mousedown: function(event, g, context) {
656 context.initializeMouseDown(event, g, context);
657 Dygraph.startPan(event, g, context);
658 },
659 mousemove: function(event, g, context) {
660 if (context.isPanning) {
661 Dygraph.movePan(event, g, context);
662 }
663 },
664 mouseup: function(event, g, context) {
665 if (context.isPanning) {
666 Dygraph.endPan(event, g, context);
667 }
668 }
669};