3 * Copyright 2011 Robert Konigsberg (konigsberg@google.com)
4 * MIT-licensed (http://opensource.org/licenses/MIT)
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)
13 /*global Dygraph:false */
16 import * as utils from
'./dygraph-utils';
19 * You can drag this many pixels past the edge of the chart and still have it
20 * be considered a zoom. This makes it easier to zoom to the exact edge of the
21 * chart, a fairly common operation.
23 var DRAG_EDGE_MARGIN
= 100;
26 * A collection of functions to facilitate build custom interaction models.
29 var DygraphInteraction
= {};
32 * Checks whether the beginning & ending of an event were close enough that it
33 * should be considered a click. If it should, dispatch appropriate events.
34 * Returns true if the event was treated as a click.
36 * @param {Event} event
38 * @param {Object} context
40 DygraphInteraction
.maybeTreatMouseOpAsClick
= function(event
, g
, context
) {
41 context
.dragEndX
= utils
.dragGetX_(event
, context
);
42 context
.dragEndY
= utils
.dragGetY_(event
, context
);
43 var regionWidth
= Math
.abs(context
.dragEndX
- context
.dragStartX
);
44 var regionHeight
= Math
.abs(context
.dragEndY
- context
.dragStartY
);
46 if (regionWidth
< 2 && regionHeight
< 2 &&
47 g
.lastx_
!== undefined
&& g
.lastx_
!= -1) {
48 DygraphInteraction
.treatMouseOpAsClick(g
, event
, context
);
51 context
.regionWidth
= regionWidth
;
52 context
.regionHeight
= regionHeight
;
56 * Called in response to an interaction model operation that
57 * should start the default panning behavior.
59 * It's used in the default callback for "mousedown" operations.
60 * Custom interaction model builders can use it to provide the default
63 * @param {Event} event the event object which led to the startPan call.
64 * @param {Dygraph} g The dygraph on which to act.
65 * @param {Object} context The dragging context object (with
66 * dragStartX/dragStartY/etc. properties). This function modifies the
69 DygraphInteraction
.startPan
= function(event
, g
, context
) {
71 context
.isPanning
= true;
72 var xRange
= g
.xAxisRange();
74 if (g
.getOptionForAxis("logscale", "x")) {
75 context
.initialLeftmostDate
= utils
.log10(xRange
[0]);
76 context
.dateRange
= utils
.log10(xRange
[1]) - utils
.log10(xRange
[0]);
78 context
.initialLeftmostDate
= xRange
[0];
79 context
.dateRange
= xRange
[1] - xRange
[0];
81 context
.xUnitsPerPixel
= context
.dateRange
/ (g
.plotter_
.area
.w
- 1);
83 if (g
.getNumericOption("panEdgeFraction")) {
84 var maxXPixelsToDraw
= g
.width_
* g
.getNumericOption("panEdgeFraction");
85 var xExtremes
= g
.xAxisExtremes(); // I REALLY WANT TO CALL THIS xTremes!
87 var boundedLeftX
= g
.toDomXCoord(xExtremes
[0]) - maxXPixelsToDraw
;
88 var boundedRightX
= g
.toDomXCoord(xExtremes
[1]) + maxXPixelsToDraw
;
90 var boundedLeftDate
= g
.toDataXCoord(boundedLeftX
);
91 var boundedRightDate
= g
.toDataXCoord(boundedRightX
);
92 context
.boundedDates
= [boundedLeftDate
, boundedRightDate
];
94 var boundedValues
= [];
95 var maxYPixelsToDraw
= g
.height_
* g
.getNumericOption("panEdgeFraction");
97 for (i
= 0; i
< g
.axes_
.length
; i
++) {
99 var yExtremes
= axis
.extremeRange
;
101 var boundedTopY
= g
.toDomYCoord(yExtremes
[0], i
) + maxYPixelsToDraw
;
102 var boundedBottomY
= g
.toDomYCoord(yExtremes
[1], i
) - maxYPixelsToDraw
;
104 var boundedTopValue
= g
.toDataYCoord(boundedTopY
, i
);
105 var boundedBottomValue
= g
.toDataYCoord(boundedBottomY
, i
);
107 boundedValues
[i
] = [boundedTopValue
, boundedBottomValue
];
109 context
.boundedValues
= boundedValues
;
112 // Record the range of each y-axis at the start of the drag.
113 // If any axis has a valueRange, then we want a 2D pan.
114 // We can't store data directly in g.axes_, because it does not belong to us
115 // and could change out from under us during a pan (say if there's a data
117 context
.is2DPan
= false;
119 for (i
= 0; i
< g
.axes_
.length
; i
++) {
122 var yRange
= g
.yAxisRange(i
);
123 // TODO(konigsberg): These values should be in |context|.
124 // In log scale, initialTopValue, dragValueRange and unitsPerPixel are log scale.
125 var logscale
= g
.attributes_
.getForAxis("logscale", i
);
127 axis_data
.initialTopValue
= utils
.log10(yRange
[1]);
128 axis_data
.dragValueRange
= utils
.log10(yRange
[1]) - utils
.log10(yRange
[0]);
130 axis_data
.initialTopValue
= yRange
[1];
131 axis_data
.dragValueRange
= yRange
[1] - yRange
[0];
133 axis_data
.unitsPerPixel
= axis_data
.dragValueRange
/ (g
.plotter_
.area
.h
- 1);
134 context
.axes
.push(axis_data
);
136 // While calculating axes, set 2dpan.
137 if (axis
.valueRange
) context
.is2DPan
= true;
142 * Called in response to an interaction model operation that
143 * responds to an event that pans the view.
145 * It's used in the default callback for "mousemove" operations.
146 * Custom interaction model builders can use it to provide the default
149 * @param {Event} event the event object which led to the movePan call.
150 * @param {Dygraph} g The dygraph on which to act.
151 * @param {Object} context The dragging context object (with
152 * dragStartX/dragStartY/etc. properties). This function modifies the
155 DygraphInteraction
.movePan
= function(event
, g
, context
) {
156 context
.dragEndX
= utils
.dragGetX_(event
, context
);
157 context
.dragEndY
= utils
.dragGetY_(event
, context
);
159 var minDate
= context
.initialLeftmostDate
-
160 (context
.dragEndX
- context
.dragStartX
) * context
.xUnitsPerPixel
;
161 if (context
.boundedDates
) {
162 minDate
= Math
.max(minDate
, context
.boundedDates
[0]);
164 var maxDate
= minDate
+ context
.dateRange
;
165 if (context
.boundedDates
) {
166 if (maxDate
> context
.boundedDates
[1]) {
167 // Adjust minDate, and recompute maxDate.
168 minDate
= minDate
- (maxDate
- context
.boundedDates
[1]);
169 maxDate
= minDate
+ context
.dateRange
;
173 if (g
.getOptionForAxis("logscale", "x")) {
174 g
.dateWindow_
= [ Math
.pow(utils
.LOG_SCALE
, minDate
),
175 Math
.pow(utils
.LOG_SCALE
, maxDate
) ];
177 g
.dateWindow_
= [minDate
, maxDate
];
180 // y-axis scaling is automatic unless this is a full 2D pan.
181 if (context
.is2DPan
) {
183 var pixelsDragged
= context
.dragEndY
- context
.dragStartY
;
185 // Adjust each axis appropriately.
186 for (var i
= 0; i
< g
.axes_
.length
; i
++) {
187 var axis
= g
.axes_
[i
];
188 var axis_data
= context
.axes
[i
];
189 var unitsDragged
= pixelsDragged
* axis_data
.unitsPerPixel
;
191 var boundedValue
= context
.boundedValues
? context
.boundedValues
[i
] : null;
193 // In log scale, maxValue and minValue are the logs of those values.
194 var maxValue
= axis_data
.initialTopValue
+ unitsDragged
;
196 maxValue
= Math
.min(maxValue
, boundedValue
[1]);
198 var minValue
= maxValue
- axis_data
.dragValueRange
;
200 if (minValue
< boundedValue
[0]) {
201 // Adjust maxValue, and recompute minValue.
202 maxValue
= maxValue
- (minValue
- boundedValue
[0]);
203 minValue
= maxValue
- axis_data
.dragValueRange
;
206 if (g
.attributes_
.getForAxis("logscale", i
)) {
207 axis
.valueRange
= [ Math
.pow(utils
.LOG_SCALE
, minValue
),
208 Math
.pow(utils
.LOG_SCALE
, maxValue
) ];
210 axis
.valueRange
= [ minValue
, maxValue
];
219 * Called in response to an interaction model operation that
220 * responds to an event that ends panning.
222 * It's used in the default callback for "mouseup" operations.
223 * Custom interaction model builders can use it to provide the default
226 * @param {Event} event the event object which led to the endPan call.
227 * @param {Dygraph} g The dygraph on which to act.
228 * @param {Object} context The dragging context object (with
229 * dragStartX/dragStartY/etc. properties). This function modifies the
232 DygraphInteraction
.endPan
= DygraphInteraction
.maybeTreatMouseOpAsClick
;
235 * Called in response to an interaction model operation that
236 * responds to an event that starts zooming.
238 * It's used in the default callback for "mousedown" operations.
239 * Custom interaction model builders can use it to provide the default
242 * @param {Event} event the event object which led to the startZoom call.
243 * @param {Dygraph} g The dygraph on which to act.
244 * @param {Object} context The dragging context object (with
245 * dragStartX/dragStartY/etc. properties). This function modifies the
248 DygraphInteraction
.startZoom
= function(event
, g
, context
) {
249 context
.isZooming
= true;
250 context
.zoomMoved
= false;
254 * Called in response to an interaction model operation that
255 * responds to an event that defines zoom boundaries.
257 * It's used in the default callback for "mousemove" operations.
258 * Custom interaction model builders can use it to provide the default
261 * @param {Event} event the event object which led to the moveZoom call.
262 * @param {Dygraph} g The dygraph on which to act.
263 * @param {Object} context The dragging context object (with
264 * dragStartX/dragStartY/etc. properties). This function modifies the
267 DygraphInteraction
.moveZoom
= function(event
, g
, context
) {
268 context
.zoomMoved
= true;
269 context
.dragEndX
= utils
.dragGetX_(event
, context
);
270 context
.dragEndY
= utils
.dragGetY_(event
, context
);
272 var xDelta
= Math
.abs(context
.dragStartX
- context
.dragEndX
);
273 var yDelta
= Math
.abs(context
.dragStartY
- context
.dragEndY
);
275 // drag direction threshold for y axis is twice as large as x axis
276 context
.dragDirection
= (xDelta
< yDelta
/ 2) ? utils
.VERTICAL
: utils
.HORIZONTAL
;
279 context
.dragDirection
,
284 context
.prevDragDirection
,
288 context
.prevEndX
= context
.dragEndX
;
289 context
.prevEndY
= context
.dragEndY
;
290 context
.prevDragDirection
= context
.dragDirection
;
294 * TODO(danvk): move this logic into dygraph.js
296 * @param {Event} event
297 * @param {Object} context
299 DygraphInteraction
.treatMouseOpAsClick
= function(g
, event
, context
) {
300 var clickCallback
= g
.getFunctionOption('clickCallback');
301 var pointClickCallback
= g
.getFunctionOption('pointClickCallback');
303 var selectedPoint
= null;
305 // Find out if the click occurs on a point.
307 var closestDistance
= Number
.MAX_VALUE
;
309 // check if the click was on a particular point.
310 for (var i
= 0; i
< g
.selPoints_
.length
; i
++) {
311 var p
= g
.selPoints_
[i
];
312 var distance
= Math
.pow(p
.canvasx
- context
.dragEndX
, 2) +
313 Math
.pow(p
.canvasy
- context
.dragEndY
, 2);
314 if (!isNaN(distance
) &&
315 (closestIdx
== -1 || distance
< closestDistance
)) {
316 closestDistance
= distance
;
321 // Allow any click within two pixels of the dot.
322 var radius
= g
.getNumericOption('highlightCircleSize') + 2;
323 if (closestDistance
<= radius
* radius
) {
324 selectedPoint
= g
.selPoints_
[closestIdx
];
330 point
: selectedPoint
,
331 canvasx
: context
.dragEndX
,
332 canvasy
: context
.dragEndY
334 var defaultPrevented
= g
.cascadeEvents_('pointClick', e
);
335 if (defaultPrevented
) {
336 // Note: this also prevents click / clickCallback from firing
.
339 if (pointClickCallback
) {
340 pointClickCallback
.call(g
, event
, selectedPoint
);
346 xval
: g
.lastx_
, // closest point by x value
348 canvasx
: context
.dragEndX
,
349 canvasy
: context
.dragEndY
351 if (!g
.cascadeEvents_('click', e
)) {
353 // TODO(danvk): pass along more info about the points, e.g. 'x'
354 clickCallback
.call(g
, event
, g
.lastx_
, g
.selPoints_
);
360 * Called in response to an interaction model operation that
361 * responds to an event that performs a zoom based on previously defined
364 * It's used in the default callback for "mouseup" operations.
365 * Custom interaction model builders can use it to provide the default
368 * @param {Event} event the event object which led to the endZoom call.
369 * @param {Dygraph} g The dygraph on which to end the zoom.
370 * @param {Object} context The dragging context object (with
371 * dragStartX/dragStartY/etc. properties). This function modifies the
374 DygraphInteraction
.endZoom
= function(event
, g
, context
) {
376 context
.isZooming
= false;
377 DygraphInteraction
.maybeTreatMouseOpAsClick(event
, g
, context
);
379 // The zoom rectangle is visibly clipped to the plot area, so its behavior
380 // should be as well.
381 // See http://code.google.com/p/dygraphs/issues/detail
?id
=280
382 var plotArea
= g
.getArea();
383 if (context
.regionWidth
>= 10 &&
384 context
.dragDirection
== utils
.HORIZONTAL
) {
385 var left
= Math
.min(context
.dragStartX
, context
.dragEndX
),
386 right
= Math
.max(context
.dragStartX
, context
.dragEndX
);
387 left
= Math
.max(left
, plotArea
.x
);
388 right
= Math
.min(right
, plotArea
.x
+ plotArea
.w
);
390 g
.doZoomX_(left
, right
);
392 context
.cancelNextDblclick
= true;
393 } else if (context
.regionHeight
>= 10 &&
394 context
.dragDirection
== utils
.VERTICAL
) {
395 var top
= Math
.min(context
.dragStartY
, context
.dragEndY
),
396 bottom
= Math
.max(context
.dragStartY
, context
.dragEndY
);
397 top
= Math
.max(top
, plotArea
.y
);
398 bottom
= Math
.min(bottom
, plotArea
.y
+ plotArea
.h
);
400 g
.doZoomY_(top
, bottom
);
402 context
.cancelNextDblclick
= true;
404 context
.dragStartX
= null;
405 context
.dragStartY
= null;
411 DygraphInteraction
.startTouch
= function(event
, g
, context
) {
412 event
.preventDefault(); // touch browsers are all nice.
413 if (event
.touches
.length
> 1) {
414 // If the user ever puts two fingers down, it's not a double tap.
415 context
.startTimeForDoubleTapMs
= null;
419 for (var i
= 0; i
< event
.touches
.length
; i
++) {
420 var t
= event
.touches
[i
];
421 // we dispense with 'dragGetX_' because all touchBrowsers support pageX
425 dataX
: g
.toDataXCoord(t
.pageX
),
426 dataY
: g
.toDataYCoord(t
.pageY
)
427 // identifier: t.identifier
430 context
.initialTouches
= touches
;
432 if (touches
.length
== 1) {
433 // This is possbily a touchOVER, save the last touch to check
434 context
.lastTouch
= event
;
435 // or This is just a swipe.
436 context
.initialPinchCenter
= touches
[0];
437 context
.touchDirections
= { x
: true, y
: true };
438 } else if (touches
.length
>= 2) {
439 // It's become a pinch!
440 // In case there are 3+ touches, we ignore all but the "first" two.
442 // only screen coordinates can be averaged (data coords could be log scale).
443 context
.initialPinchCenter
= {
444 pageX
: 0.5 * (touches
[0].pageX
+ touches
[1].pageX
),
445 pageY
: 0.5 * (touches
[0].pageY
+ touches
[1].pageY
),
447 // TODO(danvk): remove
448 dataX
: 0.5 * (touches
[0].dataX
+ touches
[1].dataX
),
449 dataY
: 0.5 * (touches
[0].dataY
+ touches
[1].dataY
)
452 // Make pinches in a 45-degree swath around either axis 1-dimensional zooms.
453 var initialAngle
= 180 / Math
.PI
* Math
.atan2(
454 context
.initialPinchCenter
.pageY
- touches
[0].pageY
,
455 touches
[0].pageX
- context
.initialPinchCenter
.pageX
);
457 // use symmetry to get it into the first quadrant.
458 initialAngle
= Math
.abs(initialAngle
);
459 if (initialAngle
> 90) initialAngle
= 90 - initialAngle
;
461 context
.touchDirections
= {
462 x
: (initialAngle
< (90 - 45/2)),
463 y
: (initialAngle
> 45/2)
467 // save the full x & y ranges.
468 context
.initialRange
= {
477 DygraphInteraction
.moveTouch
= function(event
, g
, context
) {
478 // If the tap moves, then it's definitely not part of a double-tap.
479 context
.startTimeForDoubleTapMs
= null;
481 // clear the last touch if it's doing something else
482 context
.lastTouch
= null;
485 for (i
= 0; i
< event
.touches
.length
; i
++) {
486 var t
= event
.touches
[i
];
492 var initialTouches
= context
.initialTouches
;
496 // old and new centers.
497 var c_init
= context
.initialPinchCenter
;
498 if (touches
.length
== 1) {
502 pageX
: 0.5 * (touches
[0].pageX
+ touches
[1].pageX
),
503 pageY
: 0.5 * (touches
[0].pageY
+ touches
[1].pageY
)
507 // this is the "swipe" component
508 // we toss it out for now, but could use it in the future.
510 pageX
: c_now
.pageX
- c_init
.pageX
,
511 pageY
: c_now
.pageY
- c_init
.pageY
513 var dataWidth
= context
.initialRange
.x
[1] - context
.initialRange
.x
[0];
514 var dataHeight
= context
.initialRange
.y
[0] - context
.initialRange
.y
[1];
515 swipe
.dataX
= (swipe
.pageX
/ g
.plotter_
.area
.w
) * dataWidth
;
516 swipe
.dataY
= (swipe
.pageY
/ g
.plotter_
.area
.h
) * dataHeight
;
519 // The residual bits are usually split into scale & rotate bits, but we split
520 // them into x-scale and y-scale bits.
521 if (touches
.length
== 1) {
524 } else if (touches
.length
>= 2) {
525 var initHalfWidth
= (initialTouches
[1].pageX
- c_init
.pageX
);
526 xScale
= (touches
[1].pageX
- c_now
.pageX
) / initHalfWidth
;
528 var initHalfHeight
= (initialTouches
[1].pageY
- c_init
.pageY
);
529 yScale
= (touches
[1].pageY
- c_now
.pageY
) / initHalfHeight
;
532 // Clip scaling to [1/8, 8] to prevent too much blowup
.
533 xScale
= Math
.min(8, Math
.max(0.125, xScale
));
534 yScale
= Math
.min(8, Math
.max(0.125, yScale
));
537 if (context
.touchDirections
.x
) {
539 c_init
.dataX
- swipe
.dataX
+ (context
.initialRange
.x
[0] - c_init
.dataX
) / xScale
,
540 c_init
.dataX
- swipe
.dataX
+ (context
.initialRange
.x
[1] - c_init
.dataX
) / xScale
545 if (context
.touchDirections
.y
) {
546 for (i
= 0; i
< 1 /*g.axes_.length*/; i
++) {
547 var axis
= g
.axes_
[i
];
548 var logscale
= g
.attributes_
.getForAxis("logscale", i
);
550 // TODO(danvk): implement
553 c_init
.dataY
- swipe
.dataY
+ (context
.initialRange
.y
[0] - c_init
.dataY
) / yScale
,
554 c_init
.dataY
- swipe
.dataY
+ (context
.initialRange
.y
[1] - c_init
.dataY
) / yScale
563 // We only call zoomCallback on zooms, not pans, to mirror desktop behavior.
564 if (didZoom
&& touches
.length
> 1 && g
.getFunctionOption('zoomCallback')) {
565 var viewWindow
= g
.xAxisRange();
566 g
.getFunctionOption("zoomCallback").call(g
, viewWindow
[0], viewWindow
[1], g
.yAxisRanges());
573 DygraphInteraction
.endTouch
= function(event
, g
, context
) {
574 if (event
.touches
.length
!== 0) {
575 // this is effectively a "reset"
576 DygraphInteraction
.startTouch(event
, g
, context
);
577 } else if (event
.changedTouches
.length
== 1) {
578 // Could be part of a "double tap"
579 // The heuristic here is that it's a double-tap if the two touchend events
580 // occur within 500ms and within a 50x50 pixel box.
581 var now
= new Date().getTime();
582 var t
= event
.changedTouches
[0];
583 if (context
.startTimeForDoubleTapMs
&&
584 now
- context
.startTimeForDoubleTapMs
< 500 &&
585 context
.doubleTapX
&& Math
.abs(context
.doubleTapX
- t
.screenX
) < 50 &&
586 context
.doubleTapY
&& Math
.abs(context
.doubleTapY
- t
.screenY
) < 50) {
590 if (context
.lastTouch
!== null){
591 // no double-tap, pan or pinch so it's a touchOVER
592 event
.isTouchOver
= true;
596 context
.startTimeForDoubleTapMs
= now
;
597 context
.doubleTapX
= t
.screenX
;
598 context
.doubleTapY
= t
.screenY
;
603 // Determine the distance from x to [left, right].
604 var distanceFromInterval
= function(x
, left
, right
) {
607 } else if (x
> right
) {
615 * Returns the number of pixels by which the event happens from the nearest
616 * edge of the chart. For events in the interior of the chart, this returns zero.
618 var distanceFromChart
= function(event
, g
) {
619 var chartPos
= utils
.findPos(g
.canvas_
);
622 right
: chartPos
.x
+ g
.canvas_
.offsetWidth
,
624 bottom
: chartPos
.y
+ g
.canvas_
.offsetHeight
628 x
: utils
.pageX(event
),
629 y
: utils
.pageY(event
)
632 var dx
= distanceFromInterval(pt
.x
, box
.left
, box
.right
),
633 dy
= distanceFromInterval(pt
.y
, box
.top
, box
.bottom
);
634 return Math
.max(dx
, dy
);
638 * Default interation model for dygraphs. You can refer to specific elements of
639 * this when constructing your own interaction model, e.g.:
641 * interactionModel: {
642 * mousedown: DygraphInteraction.defaultInteractionModel.mousedown
646 DygraphInteraction
.defaultModel
= {
647 // Track the beginning of drag events
648 mousedown
: function(event
, g
, context
) {
649 // Right-click should not initiate a zoom.
650 if (event
.button
&& event
.button
== 2) return;
652 context
.initializeMouseDown(event
, g
, context
);
654 if (event
.altKey
|| event
.shiftKey
) {
655 DygraphInteraction
.startPan(event
, g
, context
);
657 DygraphInteraction
.startZoom(event
, g
, context
);
660 // Note: we register mousemove/mouseup on document to allow some leeway
for
661 // events to move outside of the chart. Interaction model events get
662 // registered on the canvas, which is too small to allow this.
663 var mousemove
= function(event
) {
664 if (context
.isZooming
) {
665 // When the mouse moves >200px from the chart edge, cancel the zoom.
666 var d
= distanceFromChart(event
, g
);
667 if (d
< DRAG_EDGE_MARGIN
) {
668 DygraphInteraction
.moveZoom(event
, g
, context
);
670 if (context
.dragEndX
!== null) {
671 context
.dragEndX
= null;
672 context
.dragEndY
= null;
676 } else if (context
.isPanning
) {
677 DygraphInteraction
.movePan(event
, g
, context
);
680 var mouseup
= function(event
) {
681 if (context
.isZooming
) {
682 if (context
.dragEndX
!== null) {
683 DygraphInteraction
.endZoom(event
, g
, context
);
685 DygraphInteraction
.maybeTreatMouseOpAsClick(event
, g
, context
);
687 } else if (context
.isPanning
) {
688 DygraphInteraction
.endPan(event
, g
, context
);
691 utils
.removeEvent(document
, 'mousemove', mousemove
);
692 utils
.removeEvent(document
, 'mouseup', mouseup
);
696 g
.addAndTrackEvent(document
, 'mousemove', mousemove
);
697 g
.addAndTrackEvent(document
, 'mouseup', mouseup
);
699 willDestroyContextMyself
: true,
701 touchstart
: function(event
, g
, context
) {
702 DygraphInteraction
.startTouch(event
, g
, context
);
704 touchmove
: function(event
, g
, context
) {
705 DygraphInteraction
.moveTouch(event
, g
, context
);
707 touchend
: function(event
, g
, context
) {
708 DygraphInteraction
.endTouch(event
, g
, context
);
711 // Disable zooming out if panning.
712 dblclick
: function(event
, g
, context
) {
713 if (context
.cancelNextDblclick
) {
714 context
.cancelNextDblclick
= false;
718 // Give plugins a chance to grab this event.
720 canvasx
: context
.dragEndX
,
721 canvasy
: context
.dragEndY
,
724 if (g
.cascadeEvents_('dblclick', e
)) {
728 if (event
.altKey
|| event
.shiftKey
) {
736 Dygraph.DEFAULT_ATTRS.interactionModel = DygraphInteraction.defaultModel;
738 // old ways of accessing these methods/properties
739 Dygraph.defaultInteractionModel = DygraphInteraction.defaultModel;
740 Dygraph.endZoom = DygraphInteraction.endZoom;
741 Dygraph.moveZoom = DygraphInteraction.moveZoom;
742 Dygraph.startZoom = DygraphInteraction.startZoom;
743 Dygraph.endPan = DygraphInteraction.endPan;
744 Dygraph.movePan = DygraphInteraction.movePan;
745 Dygraph.startPan = DygraphInteraction.startPan;
748 DygraphInteraction
.nonInteractiveModel_
= {
749 mousedown
: function(event
, g
, context
) {
750 context
.initializeMouseDown(event
, g
, context
);
752 mouseup
: DygraphInteraction
.maybeTreatMouseOpAsClick
755 // Default interaction model when using the range selector.
756 DygraphInteraction
.dragIsPanInteractionModel
= {
757 mousedown
: function(event
, g
, context
) {
758 context
.initializeMouseDown(event
, g
, context
);
759 DygraphInteraction
.startPan(event
, g
, context
);
761 mousemove
: function(event
, g
, context
) {
762 if (context
.isPanning
) {
763 DygraphInteraction
.movePan(event
, g
, context
);
766 mouseup
: function(event
, g
, context
) {
767 if (context
.isPanning
) {
768 DygraphInteraction
.endPan(event
, g
, context
);
773 export default DygraphInteraction
;