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